• R/O
  • SSH

quipu: Commit

quipu mercurial repository


Commit MetaInfo

Revisãoebca8eb602d8aeee6ead8df255dce13aa8b10c55 (tree)
Hora2020-03-27 12:10:43
AutorAgustina Arzille <avarzille@rise...>
CommiterAgustina Arzille

Mensagem de Log

Remove double underscores

Mudança Sumário

Diff

diff -r cee131b9ae2c -r ebca8eb602d8 arith.h
--- a/arith.h Thu Mar 26 22:26:35 2020 -0300
+++ b/arith.h Fri Mar 27 00:10:43 2020 -0300
@@ -19,142 +19,142 @@
1919
2020 // Normalize the limbs at [PTR .. PTR + LEN)
2121 template <class T>
22-inline void uitrim (limb_t *__ptr, T& __len)
22+inline void uitrim (limb_t *ptr, T& len)
2323 {
24- for (; __len > 0 && __ptr[__len - 1] == 0; --__len) ;
24+ for (; len > 0 && ptr[len - 1] == 0; --len) ;
2525 }
2626
2727 // Compare XP and YP, up to N limbs.
28-QP_EXPORT int uicmpn (const limb_t *__xp,
29- const limb_t *__yp, int __n);
28+QP_EXPORT int uicmpn (const limb_t *xp,
29+ const limb_t *yp, int n);
3030
3131 // Compare [XP .. XP + XL) with [YP .. YP + YL)
32-QP_EXPORT int uicmp (const limb_t *__xp, int __xl,
33- const limb_t *__yp, int __yl);
32+QP_EXPORT int uicmp (const limb_t *xp, int xl,
33+ const limb_t *yp, int yl);
3434
3535 // Add VAL to [SRC .. SRC + LEN), placing the result at DST.
36-QP_EXPORT limb_t uiadd1 (limb_t *__dst,
37- const limb_t *__src, int __len, limb_t __val);
36+QP_EXPORT limb_t uiadd1 (limb_t *dst,
37+ const limb_t *src, int len, limb_t val);
3838
3939 // Add LEN limbs from XP and YP, placing the result at DST.
40-QP_EXPORT int uiaddn (limb_t *__dst,
41- const limb_t *__xp, const limb_t *__yp, int __len);
40+QP_EXPORT int uiaddn (limb_t *dst,
41+ const limb_t *xp, const limb_t *yp, int len);
4242
4343 // Add [YP .. YP + YL) to [XP .. XP + XL), placing the result at DST.
44-QP_EXPORT int uiadd (limb_t *__dst,
45- const limb_t *__xp, int __xl,
46- const limb_t *__yp, int __yl);
44+QP_EXPORT int uiadd (limb_t *dst,
45+ const limb_t *xp, int xl,
46+ const limb_t *yp, int yl);
4747
4848 // Subtract VAL from [SRC .. SRC + LEN), placing the result at DST.
49-QP_EXPORT limb_t uisub1 (limb_t *__dst,
50- const limb_t *__src, int __len, limb_t __val);
49+QP_EXPORT limb_t uisub1 (limb_t *dst,
50+ const limb_t *src, int len, limb_t val);
5151
5252 // Subtract LEN limbs from XP and YP, placing the result at DST. */
53-QP_EXPORT int uisubn (limb_t *__dst,
54- const limb_t *__xp, const limb_t *__yp, int __len);
53+QP_EXPORT int uisubn (limb_t *dst,
54+ const limb_t *xp, const limb_t *yp, int len);
5555
5656 // Subtract [YP .. YP + YL) from [XP .. XP + XL), placing the result at DST.
57-QP_EXPORT int uisub (limb_t *__dst, const limb_t *__xp,
58- int __xl, const limb_t *__yp, int __yl);
57+QP_EXPORT int uisub (limb_t *dst, const limb_t *xp,
58+ int xl, const limb_t *yp, int yl);
5959
6060 /* Left shift [SRC .. SRC + LEN) by SHIFT bits, placing the result at DST.
6161 * SHIFT cannot exceed 32 bits. */
62-QP_EXPORT int uilsh (limb_t *__dst,
63- const limb_t *__src, int __len, int __shift);
62+QP_EXPORT int uilsh (limb_t *dst,
63+ const limb_t *src, int len, int shift);
6464
6565 // Multiply [SRC .. SRC + LEN) by 2^EXPO, and place the result at DST.
66-QP_EXPORT int uimul2exp (limb_t *__dst,
67- const limb_t *__src, int __len, int __expo);
66+QP_EXPORT int uimul2exp (limb_t *dst,
67+ const limb_t *src, int len, int expo);
6868
6969 /* Right shift [SRC .. SRC + LEN) by SHIFT bits, placing the result at DST.
7070 * SHIFT cannot exceed 32 bits. */
71-QP_EXPORT int uirsh (limb_t *__dst,
72- const limb_t *__src, int __len, int __shift);
71+QP_EXPORT int uirsh (limb_t *dst,
72+ const limb_t *src, int len, int shift);
7373
7474 // Divide [SRC .. SRC + LEN) by 2^EXPO, placing the result at DST.
75-QP_EXPORT int uidiv2exp (limb_t *__dst,
76- const limb_t *__src, int __len, int __expo);
75+QP_EXPORT int uidiv2exp (limb_t *dst,
76+ const limb_t *src, int len, int expo);
7777
7878 // Multiply [SRC .. SRC + LEN) by VAL, placing the result in DST.
79-QP_EXPORT int uimul1 (limb_t *__dst,
80- const limb_t *__src, int __len, limb_t __val);
79+QP_EXPORT int uimul1 (limb_t *dst,
80+ const limb_t *src, int len, limb_t val);
8181
8282 // Multiply [XP .. XP + XL) by [YP ..YP + YL), placing the result at DST.
83-QP_EXPORT limb_t uimul (interpreter *__interp, limb_t *__dst,
84- const limb_t *__xp, int __xl,
85- const limb_t *__yp, int __yl);
83+QP_EXPORT limb_t uimul (interpreter *interp, limb_t *dst,
84+ const limb_t *xp, int xl,
85+ const limb_t *yp, int yl);
8686
8787 // Square [SRC .. SRC + LEN), placing the results at DST.
88-QP_EXPORT limb_t uisqr (interpreter *__interp,
89- limb_t *__dst, const limb_t *__src, int __len);
88+QP_EXPORT limb_t uisqr (interpreter *interp,
89+ limb_t *dst, const limb_t *src, int len);
9090
9191 /* Divide [SRC .. SRC + LEN) by VAL, placing the result at DST,
9292 * and returning the remainder. */
93-QP_EXPORT limb_t uidivrem1 (limb_t *__dst,
94- const limb_t *__src, int __len, limb_t __val);
93+QP_EXPORT limb_t uidivrem1 (limb_t *dst,
94+ const limb_t *src, int len, limb_t val);
9595
9696 /* Divide [XP .. XP + XL) by [YP .. YP + YL). If REM_P is true,
9797 * compute the remainder as well. The quotient is stored at
9898 * [DST + YL .. DST + XL - YL), and the remainder at [DST .. DST + YL). */
99-QP_EXPORT int uidiv (interpreter *__interp,
100- const limb_t *__xp, int __xl,
101- const limb_t *__yp, int __yl,
102- limb_t *__dst, bool __rem_p);
99+QP_EXPORT int uidiv (interpreter *interp,
100+ const limb_t *xp, int xl,
101+ const limb_t *yp, int yl,
102+ limb_t *dst, bool rem_p);
103103
104104 /* For LEN limbs, the most significant being MSD, compute the needed number
105105 * characters to produce a string in radix RADIX. */
106-QP_EXPORT int uibsize (int __radix, limb_t __msd, int __len);
106+QP_EXPORT int uibsize (int radix, limb_t msd, int len);
107107
108108 /* Given a string of length LEN in radix RADIX, compute the number of limbs
109109 * needed to represent the integer number. */
110-QP_EXPORT int invbsize (int __radix, int __len);
110+QP_EXPORT int invbsize (int radix, int len);
111111
112112 /* Convert [SRC .. SRC + LEN) into a string of size CAP in *DST,
113113 * using RADIX as the radix. Returns the resulting string's length. */
114-QP_EXPORT int uitostr (interpreter *__interp, char **__dst,
115- int __cap, const limb_t *__src, int __len, int __radix);
114+QP_EXPORT int uitostr (interpreter *interp, char **dst,
115+ int cap, const limb_t *src, int len, int radix);
116116
117117 /* Convert the string at [SRC .. SRC + LEN) into a limb array, placing
118118 * the result at DST, and using RADIX as the radix. */
119-QP_EXPORT int strtoui (limb_t *__dst,
120- const char *__src, int __len, int __radix);
119+QP_EXPORT int strtoui (limb_t *dst,
120+ const char *src, int len, int radix);
121121
122122 // Same as above, for single limbs.
123-QP_EXPORT char* uitostr1 (char *__dst, limb_t __val, int __radix);
123+QP_EXPORT char* uitostr1 (char *dst, limb_t val, int radix);
124124
125-QP_EXPORT intptr_t strtoui1 (const char *__src, int __len, int __radix);
125+QP_EXPORT intptr_t strtoui1 (const char *src, int len, int radix);
126126
127127 #ifdef __GNUC__
128128
129- inline unsigned int uiclz (limb_t __val)
129+ inline unsigned int uiclz (limb_t val)
130130 {
131- return (__builtin_clz (__val));
131+ return (__builtin_clz (val));
132132 }
133133
134134 #elif defined (QP_PLATFORM_UNIX)
135135 #include <strings.h>
136136
137- inline unsigned int uiclz (limb_t __val)
137+ inline unsigned int uiclz (limb_t val)
138138 {
139- return (LIMB_BITS - 1 - ffsl (__val));
139+ return (LIMB_BITS - 1 - ffsl (val));
140140 }
141141 #else
142142
143- extern int uiclz (limb_t __val);
143+ extern int uiclz (limb_t val);
144144
145145 #endif
146146
147147 // Convert a floating point value VAL into a limb array.
148-QP_EXPORT int dbltoui (double __val, limb_t *__dst, int& __len);
148+QP_EXPORT int dbltoui (double val, limb_t *dst, int& len);
149149
150150 // Convert [SRC .. SRC + LEN) with exponent EXPO to a floating point value.
151-QP_EXPORT double uitodbl (const limb_t *__src, int __len, int __expo);
151+QP_EXPORT double uitodbl (const limb_t *src, int len, int expo);
152152
153153 /* Convert a long float indicated by [SRC .. SRC + LEN), with exponent *EXPP
154154 * into a string, placing the result a DST. Produce no more than DIGS digits,
155155 * and use RADIX as the radix. */
156-QP_EXPORT int lftostr (interpreter *__interp, char *__dst,
157- int *__expp, const limb_t *__src, int __len, int __digs, int __radix);
156+QP_EXPORT int lftostr (interpreter *interp, char *dst,
157+ int *expp, const limb_t *src, int len, int digs, int radix);
158158
159159 struct num_info
160160 {
@@ -171,14 +171,14 @@
171171
172172 /* Parse the string [SRC .. SRC + LEN), and determine the numeric
173173 * type it evaluates to. Store the information at INFO. */
174-QP_EXPORT int parse_num (interpreter *__interp, const char *__src,
175- int __len, num_info& __info);
174+QP_EXPORT int parse_num (interpreter *interp, const char *src,
175+ int len, num_info& info);
176176
177177 /* Transform [SRC .. SRC + SLEN) into a series of limbs, and multiply
178178 * it by radix^EXPO, taking the radix, as well as any necessary numeric data
179179 * from INFO. Place the result at OUTP. */
180-QP_EXPORT int strtolf (interpreter *__interp, const char *__src,
181- int __slen, const num_info& __info, int& __expo, limb_t *__outp);
180+QP_EXPORT int strtolf (interpreter *interp, const char *src,
181+ int slen, const num_info& info, int& expo, limb_t *outp);
182182
183183 union uival
184184 {
@@ -203,7 +203,7 @@
203203 }
204204
205205 // Compute M1 * M2 and store the result in *this.
206- void qmul (limb_t __m1, limb_t __m2)
206+ void qmul (limb_t m1, limb_t m2)
207207 {
208208 #if !defined (QP_ARCH_WIDE) && defined (__GNUC__)
209209 #define QP_UIQMUL_DEFINED
@@ -213,7 +213,7 @@
213213 (
214214 "umull %0, %1, %2, %3"
215215 : "=&r" (this->limbs.lo), "=&r" (this->limbs.hi)
216- : "r" (__m1), "r" (__m2)
216+ : "r" (m1), "r" (m2)
217217 );
218218
219219 # elif defined (QP_ARCH_HPPA)
@@ -221,7 +221,7 @@
221221 (
222222 "xmpyu %1, %2, %0"
223223 : "=*f" (this->qv)
224- : "*f" (__m1), "*f" (__m2)
224+ : "*f" (m1), "*f" (m2)
225225 );
226226
227227 # elif defined (QP_ARCH_I386)
@@ -229,7 +229,7 @@
229229 (
230230 "mull %3"
231231 : "=a" (this->limbs.lo), "=d" (this->limbs.hi)
232- : "%0" (__m1), "rm" (__m2)
232+ : "%0" (m1), "rm" (m2)
233233 );
234234
235235 # elif defined (QP_ARCH_PPC32)
@@ -237,10 +237,10 @@
237237 (
238238 "mulhwu %0, %1, %2"
239239 : "=r" (this->limbs.hi)
240- : "%r" (__m1), "r" (__m2)
240+ : "%r" (m1), "r" (m2)
241241 );
242242
243- this->limbs.lo = __m1 * __m2;
243+ this->limbs.lo = m1 * m2;
244244
245245 # elif defined (QP_ARCH_SPARC)
246246 __asm__ __volatile__
@@ -248,7 +248,7 @@
248248 "mul %2, %3, %1\n\t"
249249 "rd %%y, %0"
250250 : "=r" (this->limbs.hi), "=r" (this->limbs.lo)
251- : "r" (__m1), "r" (__m2)
251+ : "r" (m1), "r" (m2)
252252 );
253253
254254 # else
@@ -257,17 +257,17 @@
257257 #endif
258258
259259 #ifndef QP_UIQMUL_DEFINED
260- this->qv = (twolimb_t)__m1 * __m2;
260+ this->qv = (twolimb_t)m1 * m2;
261261 #endif
262262
263263 #undef QP_UIQMUL_DEFINED
264264 }
265265
266266 // Compute M1 * M2 + ADD and store the result in *this.
267- void qmuladd (limb_t __m1, limb_t __m2, limb_t __add)
267+ void qmuladd (limb_t m1, limb_t m2, limb_t add)
268268 {
269- this->qmul (__m1, __m2);
270- this->qv += __add;
269+ this->qmul (m1, m2);
270+ this->qv += add;
271271 }
272272 };
273273
diff -r cee131b9ae2c -r ebca8eb602d8 array.h
--- a/array.h Thu Mar 26 22:26:35 2020 -0300
+++ b/array.h Fri Mar 27 00:10:43 2020 -0300
@@ -15,7 +15,7 @@
1515 uint32_t len;
1616 object *data;
1717
18- static array* alloc_raw (uint32_t __nelems);
18+ static array* alloc_raw (uint32_t nelems);
1919
2020 // Needed by the raw_acc interface.
2121
@@ -29,44 +29,44 @@
2929 return (this->data);
3030 }
3131
32- void local_init (object *__data = nullptr, uint32_t __len = 0)
32+ void local_init (object *data = nullptr, uint32_t len = 0)
3333 {
34- this->data = __data;
35- this->len = __len;
34+ this->data = data;
35+ this->len = len;
3636 }
3737 };
3838
39-inline array* as_array (object __obj)
39+inline array* as_array (object obj)
4040 {
41- return ((array *)unmask (__obj));
41+ return ((array *)unmask (obj));
4242 }
4343
4444 #ifdef QP_ARCH_WIDE
4545
46-inline constexpr bool array_p (object __obj)
46+inline constexpr bool array_p (object obj)
4747 {
48- return (itype (__obj) == typecode::ARRAY);
48+ return (itype (obj) == typecode::ARRAY);
4949 }
5050
5151 #else
5252
53-inline bool array_p (object __obj)
53+inline bool array_p (object obj)
5454 {
55- return (varobj_p (__obj) && as_varobj(__obj)->vo_type == typecode::ARRAY);
55+ return (varobj_p (obj) && as_varobj(obj)->vo_type == typecode::ARRAY);
5656 }
5757
5858 #endif
5959
6060 template <class T>
61-inline object& xaref (object __obj, T __idx)
61+inline object& xaref (object obj, T idx)
6262 {
63- return (as_array(__obj)->data[__idx]);
63+ return (as_array(obj)->data[idx]);
6464 }
6565
6666 inline uint32_t
67-len_a (object __obj)
67+len_a (object obj)
6868 {
69- return (as_array(__obj)->len);
69+ return (as_array(obj)->len);
7070 }
7171
7272 struct stream;
@@ -74,74 +74,73 @@
7474 struct pack_info;
7575
7676 // Allocate an array of length NELEM, filling it with FILL.
77-QP_EXPORT object alloc_array (interpreter *__interp,
78- uint32_t __nelem, object __fill = UNBOUND);
77+QP_EXPORT object alloc_array (interpreter *interp,
78+ uint32_t nelem, object fill = UNBOUND);
7979
8080 // Add 2 arrays.
81-QP_EXPORT object add_aa (interpreter *__interp, object __a1, object __a2);
81+QP_EXPORT object add_aa (interpreter *interp, object a1, object a2);
8282
8383 // Concatenate ARGC arrays from ARGV.
8484 QP_EXPORT object concat_a (interpreter *interp, object *argv, int argc);
8585
8686 // Multiply an array by an integer.
87-QP_EXPORT object mul_ia (interpreter *__interp,
88- object __ival, object __array);
87+QP_EXPORT object mul_ia (interpreter *interp, object ival, object array);
8988
9089 // Index an array.
91-QP_EXPORT object get_a (interpreter *__interp,
92- object __array, object __idx, object __dfl);
90+QP_EXPORT object get_a (interpreter *interp,
91+ object array, object idx, object dfl);
9392
9493 // Destructively set an object inside an array.
95-QP_EXPORT object nput_a (interpreter *__interp,
96- object __array, object __idx, object __val);
94+QP_EXPORT object nput_a (interpreter *interp,
95+ object array, object idx, object val);
9796
9897 // Compute the hashcode of an array.
99-QP_EXPORT uint32_t hash_a (interpreter *__interp, object __obj);
98+QP_EXPORT uint32_t hash_a (interpreter *interp, object obj);
10099
101100 // Get the subsequence of an array.
102-QP_EXPORT object subseq_a (interpreter *__interp,
103- object __array, object __i1, object __i2);
101+QP_EXPORT object subseq_a (interpreter *interp,
102+ object array, object i1, object i2);
104103
105104 // Copy an array.
106-QP_EXPORT object copy_a (interpreter *__interp, object __obj, bool __deep);
105+QP_EXPORT object copy_a (interpreter *interp, object obj, bool deep);
107106
108107 // Reverse an array.
109-QP_EXPORT object reverse_a (interpreter *__interp, object __obj);
108+QP_EXPORT object reverse_a (interpreter *interp, object obj);
110109
111110 // Destructively reverse an array.
112-QP_EXPORT object nreverse_a (interpreter *__interp, object __obj);
111+QP_EXPORT object nreverse_a (interpreter *interp, object obj);
113112
114113 // Destructively sort an array.
115-QP_EXPORT object nsort_a (interpreter *__interp, object __obj);
114+QP_EXPORT object nsort_a (interpreter *interp, object obj);
116115
117116 // Test for array equality.
118-QP_EXPORT bool eq_aa (interpreter *__interp, object __a1, object __a2);
117+QP_EXPORT bool eq_aa (interpreter *interp, object a1, object a2);
119118
120119 // Compare 2 arrays.
121-QP_EXPORT int cmp_aa (interpreter *__interp, object __a1, object __a2);
120+QP_EXPORT int cmp_aa (interpreter *interp, object a1, object a2);
122121
123122 // Iterator interface for an array.
124-QP_EXPORT object iter_a (interpreter *__interp,
125- object __obj, object __token, bool __adv);
123+QP_EXPORT object iter_a (interpreter *interp,
124+ object obj, object token, bool adv);
126125
127126 // Mutate an object inside the array
128127 QP_EXPORT object nzap_a (interpreter *interp, object obj, object key,
129128 uint32_t flags, object fn, object *argv, int argc);
130129
131130 // Return the last element of an array.
132-QP_EXPORT object last_a (interpreter *__interp, object __obj);
131+QP_EXPORT object last_a (interpreter *interp, object obj);
133132
134133 // Write an array to a stream.
135-QP_EXPORT int write_a (interpreter *__interp,
136- stream *__strm, object __obj, io_info& __info);
134+QP_EXPORT int write_a (interpreter *interp,
135+ stream *strm, object obj, io_info& info);
137136
138137 // Serialize an array in a stream.
139-QP_EXPORT int64_t pack_a (interpreter *__interp,
140- stream *__strm, object __obj, pack_info& __info);
138+QP_EXPORT int64_t pack_a (interpreter *interp,
139+ stream *strm, object obj, pack_info& info);
141140
142141 // Deserialize an array from a stream.
143-QP_EXPORT object unpack_a (interpreter *__interp,
144- stream *__strm, pack_info& __info, bool __save);
142+QP_EXPORT object unpack_a (interpreter *interp,
143+ stream *strm, pack_info& info, bool save);
145144
146145 // Init OP for arrays.
147146 QP_EXPORT init_op init_array;
diff -r cee131b9ae2c -r ebca8eb602d8 builtins.h
--- a/builtins.h Thu Mar 26 22:26:35 2020 -0300
+++ b/builtins.h Fri Mar 27 00:10:43 2020 -0300
@@ -7,35 +7,35 @@
77 QP_DECLS_BEGIN
88
99 // Basic routine to copy any object.
10-QP_EXPORT object copy (interpreter *__interp,
11- object __obj, bool __deep = false);
10+QP_EXPORT object copy (interpreter *interp,
11+ object obj, bool deep = false);
1212
1313 // Hash a generic object.
14-QP_EXPORT uint32_t xhash (interpreter *__interp, object __obj);
14+QP_EXPORT uint32_t xhash (interpreter *interp, object obj);
1515
1616 // Return the length of a generic object.
17-QP_EXPORT object length (interpreter *__interp, object __obj);
17+QP_EXPORT object length (interpreter *interp, object obj);
1818
1919 // Add objects X and Y.
20-QP_EXPORT object add (interpreter *__interp, object __x, object __y);
20+QP_EXPORT object add (interpreter *interp, object x, object y);
2121
2222 // Subtract object Y from X.
23-QP_EXPORT object sub (interpreter *__interp, object __x, object __y);
23+QP_EXPORT object sub (interpreter *interp, object x, object y);
2424
2525 // Multiply objects X and Y.
26-QP_EXPORT object mul (interpreter *__interp, object __x, object __y);
26+QP_EXPORT object mul (interpreter *interp, object x, object y);
2727
2828 // Divide object X by Y.
29-QP_EXPORT object div (interpreter *__interp, object __x, object __y);
29+QP_EXPORT object div (interpreter *interp, object x, object y);
3030
3131 // Return the modulo of X by Y.
32-QP_EXPORT object modulo (interpreter *__interp, object __x, object __y);
32+QP_EXPORT object modulo (interpreter *interp, object x, object y);
3333
3434 // Test for object equality.
35-QP_EXPORT bool equal (interpreter *__interp, object __x, object __y);
35+QP_EXPORT bool equal (interpreter *interp, object x, object y);
3636
3737 // Compare 2 objects.
38-QP_EXPORT int xcmp (interpreter *__interp, object __x, object __y);
38+QP_EXPORT int xcmp (interpreter *interp, object x, object y);
3939
4040 #define DEFBUILTIN(name) \
4141 QP_EXPORT object name (interpreter *interp, object *argv, int argc)
@@ -111,7 +111,7 @@
111111
112112 typedef object (*indexer_t) (interpreter *, object, object, object);
113113
114-QP_EXPORT indexer_t index_seq (object __seq);
114+QP_EXPORT indexer_t index_seq (object seq);
115115
116116 struct builtin_iter
117117 {
diff -r cee131b9ae2c -r ebca8eb602d8 bvector.h
--- a/bvector.h Thu Mar 26 22:26:35 2020 -0300
+++ b/bvector.h Fri Mar 27 00:10:43 2020 -0300
@@ -13,7 +13,7 @@
1313 unsigned char *data;
1414 uint32_t nbytes;
1515
16- static bvector* alloc_raw (uint32_t __cap);
16+ static bvector* alloc_raw (uint32_t cap);
1717
1818 // Needed by the raw_acc interface.
1919 uint32_t& len_ref ()
@@ -27,31 +27,31 @@
2727 }
2828 };
2929
30-inline bvector* as_bvector (object __obj)
30+inline bvector* as_bvector (object obj)
3131 {
32- return ((bvector *)unmask (__obj));
32+ return ((bvector *)unmask (obj));
3333 }
3434
3535 #ifdef QP_ARCH_WIDE
3636
37-inline constexpr bool bvector_p (object __obj)
37+inline constexpr bool bvector_p (object obj)
3838 {
39- return (itype (__obj) == typecode::BVECTOR);
39+ return (itype (obj) == typecode::BVECTOR);
4040 }
4141
4242 #else
4343
44-inline bool bvector_p (object __obj)
44+inline bool bvector_p (object obj)
4545 {
46- return (varobj_p (__obj) && as_varobj(__obj)->vo_type == typecode::BVECTOR);
46+ return (varobj_p (obj) && as_varobj(obj)->vo_type == typecode::BVECTOR);
4747 }
4848
4949 #endif
5050
5151 inline uint32_t
52-len_b (object __obj)
52+len_b (object obj)
5353 {
54- return (as_bvector(__obj)->nbytes);
54+ return (as_bvector(obj)->nbytes);
5555 }
5656
5757 /* Byte vectors and strings share a large part of
@@ -63,113 +63,111 @@
6363 struct pack_info;
6464
6565 // Allocate a byte vector with room for NBYTES bytes.
66-QP_EXPORT object alloc_bvector (interpreter *__interp, uint32_t __nbytes);
66+QP_EXPORT object alloc_bvector (interpreter *interp, uint32_t nbytes);
6767
6868 // Index a byte vector.
69-QP_EXPORT object get_b (interpreter *__interp,
70- object __bvector, object __idx, object __dfl);
69+QP_EXPORT object get_b (interpreter *interp,
70+ object bvector, object idx, object dfl);
7171
7272 // Get the subsequence of a byte vector.
73-QP_EXPORT object subseq_b (interpreter *__interp,
74- object __bvector, object __ix1, object __ix2);
73+QP_EXPORT object subseq_b (interpreter *interp,
74+ object bvector, object ix1, object ix2);
7575
7676 // Replace the subsequence of a byte vector.
77-QP_EXPORT object rpl_b (interpreter *__interp,
78- object __bvector, object __ix1, object __ix2, object __rpl);
77+QP_EXPORT object rpl_b (interpreter *interp,
78+ object bvector, object ix1, object ix2, object rpl);
7979
8080 // Erase the subsequence of a byte vector.
81-QP_EXPORT object erase_b (interpreter *__interp,
82- object __bvector, object __ix1, object __ix2);
81+QP_EXPORT object erase_b (interpreter *interp,
82+ object bvector, object ix1, object ix2);
8383
8484 // Insert into a byte vector.
85-QP_EXPORT object insert_b (interpreter *__interp,
86- object __bvector, object __ix1, object __ins);
85+QP_EXPORT object insert_b (interpreter *interp,
86+ object bvector, object ix1, object ins);
8787
8888 // Destructively set an element inside a byte vector.
89-QP_EXPORT object nput_b (interpreter *__interp,
90- object __bvector, object __idx, object __byte);
89+QP_EXPORT object nput_b (interpreter *interp,
90+ object bvector, object idx, object byte);
9191
9292 // Copy a byte vector.
93-QP_EXPORT object copy_b (interpreter *__interp, object __obj, bool __deep);
93+QP_EXPORT object copy_b (interpreter *interp, object obj, bool deep);
9494
9595 // Iterator interface for a byte vector.
96-QP_EXPORT object iter_b (interpreter *__interp, object __obj,
97- object __token, bool __adv);
96+QP_EXPORT object iter_b (interpreter *interp,
97+ object obj, object token, bool adv);
9898
9999 // Write a byte vector to a stream.
100-QP_EXPORT int write_b (interpreter *__interp,
101- stream *__strm, object __bvector, io_info& __info);
100+QP_EXPORT int write_b (interpreter *interp,
101+ stream *strm, object bvector, io_info& info);
102102
103103 // Serialize a byte vector in a stream.
104-QP_EXPORT int64_t pack_b (interpreter *__interp,
105- stream *__strm, object __obj, pack_info& __info);
104+QP_EXPORT int64_t pack_b (interpreter *interp,
105+ stream *strm, object obj, pack_info& info);
106106
107107 // Deserialize a byte vector from a stream.
108-QP_EXPORT object unpack_b (interpreter *__interp,
109- stream *__strm, pack_info& __info, bool __save);
108+QP_EXPORT object unpack_b (interpreter *interp,
109+ stream *strm, pack_info& info, bool save);
110110
111111 // Concatenate byte vectors BV1 and BV2.
112-QP_EXPORT object add_bb (interpreter *__interp, object __bv1, object __bv2);
112+QP_EXPORT object add_bb (interpreter *interp, object bv1, object bv2);
113113
114114 // Concatenate ARGC byte vectors from ARGV.
115-QP_EXPORT object concat_b (interpreter *__interp, object *__argv, int __argc);
115+QP_EXPORT object concat_b (interpreter *interp, object *argv, int argc);
116116
117117 // Multiply a byte vector with an integer.
118-QP_EXPORT object mul_ib (interpreter *__interp,
119- object __ix, object __bvector);
118+QP_EXPORT object mul_ib (interpreter *interp, object ix, object bvector);
120119
121120 // Compare byte vectors V1 and V2.
122-QP_EXPORT int cmp_bb (interpreter *__interp,
123- object __v1, object __v2);
121+QP_EXPORT int cmp_bb (interpreter *interp, object v1, object v2);
124122
125123 /* Let's take advantage of the fact that both types
126124 * have the same internal representation. */
127125
128-inline int cmp_bs (interpreter *__interp, object __b, object __s)
126+inline int cmp_bs (interpreter *interp, object b, object s)
129127 {
130- return (cmp_bb (__interp, __b, __s));
128+ return (cmp_bb (interp, b, s));
131129 }
132130
133-inline int cmp_ss (interpreter *__interp, object __s1, object __s2)
131+inline int cmp_ss (interpreter *interp, object s1, object s2)
134132 {
135- return (cmp_bb (__interp, __s1, __s2));
133+ return (cmp_bb (interp, s1, s2));
136134 }
137135
138136 // Test for byte vector equality.
139-QP_EXPORT bool eq_bb (interpreter *__interp,
140- object __v1, object __v2);
137+QP_EXPORT bool eq_bb (interpreter *interp,
138+ object v1, object v2);
141139
142-inline bool eq_bs (interpreter *__interp, object __b, object __s)
140+inline bool eq_bs (interpreter *interp, object b, object s)
143141 {
144- return (eq_bb (__interp, __b, __s));
142+ return (eq_bb (interp, b, s));
145143 }
146144
147-inline bool eq_ss (interpreter *__interp, object __s1, object __s2)
145+inline bool eq_ss (interpreter *interp, object s1, object s2)
148146 {
149- return (eq_bb (__interp, __s1, __s2));
147+ return (eq_bb (interp, s1, s2));
150148 }
151149
152150 // Hash the buffer [PTR .. PTR + LEN).
153-QP_EXPORT uint32_t hashbuf (const void *__ptr, uint32_t __len);
151+QP_EXPORT uint32_t hashbuf (const void *ptr, uint32_t len);
154152
155153 // Compute the hashcode of a byte vector.
156-QP_EXPORT uint32_t hash_b (interpreter *__interp, object __obj);
154+QP_EXPORT uint32_t hash_b (interpreter *interp, object obj);
157155
158156 // Reverse a byte vector.
159-QP_EXPORT object reverse_b (interpreter *__interp, object __obj);
157+QP_EXPORT object reverse_b (interpreter *interp, object obj);
160158
161159 // Destructively reverse a byte vector.
162-QP_EXPORT object nreverse_b (interpreter *__interp, object __obj);
160+QP_EXPORT object nreverse_b (interpreter *interp, object obj);
163161
164162 // Get the last element of a byte vector.
165-QP_EXPORT object last_b (interpreter *__interp, object __obj);
163+QP_EXPORT object last_b (interpreter *interp, object obj);
166164
167165 // Create a stream with from byte vector BV.
168-QP_EXPORT stream* bvstream (interpreter *__interp, object __bv, int __mode);
166+QP_EXPORT stream* bvstream (interpreter *interp, object bv, int mode);
169167
170168 // Get the byte vector from stream STRM.
171-QP_EXPORT object bvstream_get (interpreter *__interp,
172- stream *__strm, bool __release);
169+QP_EXPORT object bvstream_get (interpreter *interp,
170+ stream *strm, bool release);
173171
174172 // Init OP for byte vectors.
175173 QP_EXPORT init_op init_bvector;
diff -r cee131b9ae2c -r ebca8eb602d8 bytecode.h
--- a/bytecode.h Thu Mar 26 22:26:35 2020 -0300
+++ b/bytecode.h Fri Mar 27 00:10:43 2020 -0300
@@ -166,43 +166,43 @@
166166 (this->branch_p () ? sizeof (int16_t) : 1));
167167 }
168168
169- int getarg (const void *__ptr) const
169+ int getarg (const void *ptr) const
170170 {
171171 switch (this->argsize ())
172172 {
173173 case sizeof (int32_t):
174- return ((int32_t)get32 (__ptr));
174+ return ((int32_t)get32 (ptr));
175175 case sizeof (int16_t):
176- return ((int16_t)get16 (__ptr));
176+ return ((int16_t)get16 (ptr));
177177 default:
178- return (*(int8_t *)__ptr);
178+ return (*(int8_t *)ptr);
179179 }
180180 }
181181 };
182182
183-QP_EXPORT const bcode_instr* bcode_get (int __opc) __attribute__ ((pure));
183+QP_EXPORT const bcode_instr* bcode_get (int opc) __attribute__ ((pure));
184184
185-inline const char* bcode_name (int __opc)
185+inline const char* bcode_name (int opc)
186186 {
187- return (bcode_get(__opc)->name ());
187+ return (bcode_get(opc)->name ());
188188 }
189189
190190 inline int
191-bcode_nops (int __opc)
191+bcode_nops (int opc)
192192 {
193- return (bcode_get(__opc)->nops ());
193+ return (bcode_get(opc)->nops ());
194194 }
195195
196196 inline bool
197-bcode_branch_p (int __opc)
197+bcode_branch_p (int opc)
198198 {
199- return (bcode_get(__opc)->branch_p ());
199+ return (bcode_get(opc)->branch_p ());
200200 }
201201
202202 inline bool
203-bcode_long_p (int __opc)
203+bcode_long_p (int opc)
204204 {
205- return (bcode_get(__opc)->long_p ());
205+ return (bcode_get(opc)->long_p ());
206206 }
207207
208208 QP_DECLS_END
diff -r cee131b9ae2c -r ebca8eb602d8 cons.h
--- a/cons.h Thu Mar 26 22:26:35 2020 -0300
+++ b/cons.h Fri Mar 27 00:10:43 2020 -0300
@@ -25,14 +25,14 @@
2525 #endif
2626 }
2727
28- static object make (interpreter *__interp,
29- object __car, object __cdr);
28+ static object make (interpreter *interp,
29+ object car, object cdr);
3030
3131 struct iter_base
3232 {
3333 int state = 0;
3434
35- inline void _Advance (object& __fast, object& __slow);
35+ inline void _Advance (object& fast, object& slow);
3636 };
3737
3838 struct unsafe_iter : public iter_base
@@ -40,7 +40,7 @@
4040 object fast;
4141 object slow;
4242
43- unsafe_iter (object __cons) : fast (__cons), slow (__cons)
43+ unsafe_iter (object cons) : fast (cons), slow (cons)
4444 {
4545 }
4646
@@ -61,9 +61,9 @@
6161
6262 unsafe_iter operator++ (int)
6363 {
64- unsafe_iter __rv = *this;
64+ unsafe_iter rv = *this;
6565 ++*this;
66- return (__rv);
66+ return (rv);
6767 }
6868
6969 object node () const
@@ -82,13 +82,13 @@
8282 valref fast;
8383 valref slow;
8484
85- safe_iter (interpreter *__interp, object __cons) :
86- fast (__interp, __cons), slow (__interp, __cons)
85+ safe_iter (interpreter *interp, object cons) :
86+ fast (interp, cons), slow (interp, cons)
8787 {
8888 }
8989
90- safe_iter (interpreter *__interp, const safe_iter& __right) :
91- fast (__interp, *__right.fast), slow (__interp, *__right.slow)
90+ safe_iter (interpreter *interp, const safe_iter& right) :
91+ fast (interp, *right.fast), slow (interp, *right.slow)
9292 {
9393 }
9494
@@ -109,9 +109,9 @@
109109
110110 safe_iter operator++ (int)
111111 {
112- safe_iter __rv { interpreter::self (), *this };
112+ safe_iter rv { interpreter::self (), *this };
113113 ++*this;
114- return (__rv);
114+ return (rv);
115115 }
116116
117117 object node () const
@@ -139,63 +139,63 @@
139139
140140 #ifdef QP_ARCH_WIDE
141141
142-inline constexpr bool xcons_p (object __obj)
142+inline constexpr bool xcons_p (object obj)
143143 {
144- return (itype (__obj) == typecode::CONS);
144+ return (itype (obj) == typecode::CONS);
145145 }
146146
147147 #else
148148
149-inline constexpr bool xcons_p (object __obj)
149+inline constexpr bool xcons_p (object obj)
150150 {
151- return ((__obj & 3) == 2);
151+ return ((obj & 3) == 2);
152152 }
153153
154154 #endif
155155
156-inline bool cons_p (object __obj)
156+inline bool cons_p (object obj)
157157 {
158- return (__obj != NIL && xcons_p (__obj));
158+ return (obj != NIL && xcons_p (obj));
159159 }
160160
161-inline bool atom_p (object __obj)
161+inline bool atom_p (object obj)
162162 {
163- return (!cons_p (__obj));
163+ return (!cons_p (obj));
164164 }
165165
166-inline cons* as_cons (object __obj)
166+inline cons* as_cons (object obj)
167167 {
168- return ((cons *)unmask (__obj));
168+ return ((cons *)unmask (obj));
169169 }
170170
171171 // Fast, unsafe access.
172-inline object& xcar (object __obj)
172+inline object& xcar (object obj)
173173 {
174- return (as_cons(__obj)->car);
175-}
176-
177-inline object& xcdr (object __obj)
178-{
179- return (as_cons(__obj)->cdr);
174+ return (as_cons(obj)->car);
180175 }
181176
182-inline object& xcadr (object __obj)
177+inline object& xcdr (object obj)
183178 {
184- return (xcar (xcdr (__obj)));
179+ return (as_cons(obj)->cdr);
185180 }
186181
187-inline object& xcddr (object __obj)
182+inline object& xcadr (object obj)
188183 {
189- return (xcdr (xcdr (__obj)));
184+ return (xcar (xcdr (obj)));
190185 }
191186
192-void cons::iter_base::_Advance (object& __fast, object& __slow)
187+inline object& xcddr (object obj)
193188 {
194- __fast = xcdr (__fast);
195- if (__fast == __slow)
196- __fast = UNBOUND;
189+ return (xcdr (xcdr (obj)));
190+}
191+
192+void cons::iter_base::_Advance (object& fast, object& slow)
193+{
194+ fast = xcdr (fast);
195+ if (fast == slow)
196+ fast = UNBOUND;
197197 else if (this->state == 1)
198- __slow = xcdr (__slow);
198+ slow = xcdr (slow);
199199
200200 this->state ^= 1;
201201 }
@@ -235,95 +235,92 @@
235235 struct pack_info;
236236
237237 // Allocate a single cons.
238-QP_EXPORT object alloc_cons (interpreter *__interp);
238+QP_EXPORT object alloc_cons (interpreter *interp);
239239
240240 // Allocate N conses.
241-QP_EXPORT object alloc_cons (interpreter *__interp, uint32_t __n);
241+QP_EXPORT object alloc_cons (interpreter *interp, uint32_t n);
242242
243243 // Return the length of the list CONS. Place its tail in DOTC.
244-QP_EXPORT int32_t len_L (interpreter *__interp, object __cons, object& __dotc);
244+QP_EXPORT int32_t len_L (interpreter *interp, object cons, object& dotc);
245245
246246 // Same as above, only it raises an exception if CONS is not a proper list.
247-QP_EXPORT int32_t len_L (interpreter *__interp, object __cons);
247+QP_EXPORT int32_t len_L (interpreter *interp, object cons);
248248
249249 // Index a list.
250-QP_EXPORT object get_L (interpreter *__interp, object __cons,
251- object __idx, object __dfl);
250+QP_EXPORT object get_L (interpreter *interp,
251+ object cons, object idx, object dfl);
252252
253253 // Get the subsequence of a list.
254-QP_EXPORT object subseq_L (interpreter *__interp,
255- object __cons, object __i1, object __i2);
254+QP_EXPORT object subseq_L (interpreter *interp,
255+ object cons, object i1, object i2);
256256
257257 // Destructively set an object inside a list.
258-QP_EXPORT object nput_L (interpreter *__interp, object __cons,
259- object __idx, object __val);
258+QP_EXPORT object nput_L (interpreter *interp,
259+ object cons, object idx, object val);
260260
261261 // Copy a list.
262-QP_EXPORT object copy_L (interpreter *__interp, object __obj, bool __deep);
262+QP_EXPORT object copy_L (interpreter *interp, object obj, bool deep);
263263
264264 // Concatenate lists L1 and L2.
265-QP_EXPORT object add_LL (interpreter *__interp, object __l1, object __l2);
265+QP_EXPORT object add_LL (interpreter *interp, object l1, object l2);
266266
267267 // Concate ARGC lists inside ARGV.
268268 QP_EXPORT object concat_L (interpreter *interp, object *argv, int argc);
269269
270270 // Compute the hashcode of a list.
271-QP_EXPORT uint32_t hash_L (interpreter *__interp, object __obj);
271+QP_EXPORT uint32_t hash_L (interpreter *interp, object obj);
272272
273273 // Iterator interface for a list.
274-QP_EXPORT object iter_L (interpreter *__interp, object __obj,
275- object __token, bool __adv);
274+QP_EXPORT object iter_L (interpreter *interp,
275+ object obj, object token, bool adv);
276276
277277 // Write a list to a stream.
278-QP_EXPORT int write_L (interpreter *__interp,
279- stream *__strm, object __obj, io_info& __info);
278+QP_EXPORT int write_L (interpreter *interp,
279+ stream *strm, object obj, io_info& info);
280280
281281 // Serialize a list in a stream.
282-QP_EXPORT int64_t pack_L (interpreter *__interp,
283- stream *__strm, object __obj, pack_info& __info);
282+QP_EXPORT int64_t pack_L (interpreter *interp,
283+ stream *strm, object obj, pack_info& info);
284284
285285 // Deserialize a list from a stream.
286-QP_EXPORT object unpack_L (interpreter *__interp,
287- stream *__strm, pack_info& __info, bool __save);
286+QP_EXPORT object unpack_L (interpreter *interp,
287+ stream *strm, pack_info& info, bool save);
288288
289289 // Reverse a list.
290-QP_EXPORT object reverse_L (interpreter *__interp, object __obj);
290+QP_EXPORT object reverse_L (interpreter *interp, object obj);
291291
292292 // Destructively reverse a list.
293-QP_EXPORT object nreverse_L (interpreter *__interp, object __obj);
293+QP_EXPORT object nreverse_L (interpreter *interp, object obj);
294294
295295 // Sort a list.
296-QP_EXPORT object sort_L (interpreter *__interp, object __obj);
296+QP_EXPORT object sort_L (interpreter *interp, object obj);
297297
298298 // Destructively sort a list.
299-QP_EXPORT object nsort_L (interpreter *__interp, object __obj);
299+QP_EXPORT object nsort_L (interpreter *interp, object obj);
300300
301301 // Test for list equality.
302-QP_EXPORT bool eq_LL (interpreter *__interp, object __l1, object __l2);
302+QP_EXPORT bool eq_LL (interpreter *interp, object l1, object l2);
303303
304304 // Compare lists L1 and L2.
305-QP_EXPORT int cmp_LL (interpreter *__interp, object __l1, object __l2);
305+QP_EXPORT int cmp_LL (interpreter *interp, object l1, object l2);
306306
307307 // Return the IDX'th cdr of list LST.
308-QP_EXPORT object nthcdr (interpreter *__interp, object __idx, object __lst);
308+QP_EXPORT object nthcdr (interpreter *interp, object idx, object lst);
309309
310310 // Get the last cdr of list LST.
311-QP_EXPORT object last_L (interpreter *__interp, object __lst);
311+QP_EXPORT object last_L (interpreter *interp, object lst);
312312
313313 // Destructively concatenate ARGC lists in ARGV.
314314 QP_EXPORT object nconcat (interpreter *interp, object *argv, int argc);
315315
316316 // Destructively reverse LST and concatenate TAIL into it.
317-QP_EXPORT object nrevconc (interpreter *__interp,
318- object __lst, object __tail);
317+QP_EXPORT object nrevconc (interpreter *interp, object lst, object tail);
319318
320319 // Set the car of LST to OBJ.
321-QP_EXPORT object nputcar (interpreter *__interp,
322- object __lst, object __obj);
320+QP_EXPORT object nputcar (interpreter *interp, object lst, object obj);
323321
324322 // Set the cdr of LST to OBJ.
325-QP_EXPORT object nputcdr (interpreter *__interp,
326- object __lst, object __obj);
323+QP_EXPORT object nputcdr (interpreter *interp, object lst, object obj);
327324
328325 // Mutate an object inside the list.
329326 QP_EXPORT object nzap_L (interpreter *interp, object obj, object key,
diff -r cee131b9ae2c -r ebca8eb602d8 coro.h
--- a/coro.h Thu Mar 26 22:26:35 2020 -0300
+++ b/coro.h Fri Mar 27 00:10:43 2020 -0300
@@ -1,5 +1,5 @@
11 #ifndef __QP_CORO_H__
2-#define __QP_CORO_H__ 1
2+#define __QP_CORO_H 1
33
44 #include "interp.h"
55
@@ -9,7 +9,7 @@
99 {
1010 static const int code = typecode::CORO;
1111 static coroutine* alloc_raw ();
12- static object make (interpreter *__interp, uint32_t __bp);
12+ static object make (interpreter *interp, uint32_t bp);
1313
1414 object value;
1515 object argv;
@@ -30,31 +30,31 @@
3030 }
3131 };
3232
33-inline bool coro_p (object __obj)
33+inline bool coro_p (object obj)
3434 {
35- return (itype (__obj) == typecode::CORO);
35+ return (itype (obj) == typecode::CORO);
3636 }
3737
38-inline coroutine* as_coro (object __obj)
38+inline coroutine* as_coro (object obj)
3939 {
40- return ((coroutine *)unmask (__obj));
40+ return ((coroutine *)unmask (obj));
4141 }
4242
43-QP_EXPORT object alloc_coroutine (interpreter *__interp);
43+QP_EXPORT object alloc_coroutine (interpreter *interp);
4444
45-QP_EXPORT object call_coroutine (interpreter *__interp, object __coro);
45+QP_EXPORT object call_coroutine (interpreter *interp, object coro);
4646
47-QP_EXPORT object coro_next (interpreter *__interp, object *__argv, int __argc);
47+QP_EXPORT object coro_next (interpreter *interp, object *argv, int argc);
4848
4949 struct stream;
5050 struct io_info;
5151 struct pack_info;
5252
53-QP_EXPORT int pack_G (interpreter *__interp,
54- stream *__strm, object __obj, pack_info& __info);
53+QP_EXPORT int pack_G (interpreter *interp,
54+ stream *strm, object obj, pack_info& info);
5555
56-QP_EXPORT object unpack_G (interpreter *__interp,
57- stream *__strm, pack_info& __info, bool __save);
56+QP_EXPORT object unpack_G (interpreter *interp,
57+ stream *strm, pack_info& info, bool save);
5858
5959 QP_DECLS_END
6060
diff -r cee131b9ae2c -r ebca8eb602d8 defs.h
--- a/defs.h Thu Mar 26 22:26:35 2020 -0300
+++ b/defs.h Fri Mar 27 00:10:43 2020 -0300
@@ -71,40 +71,40 @@
7171 const object SIGN_BIT = UINT64_C (1) << (TYPE_SHIFT - 1);
7272 const object EXTRA_BIT = SIGN_BIT >> 1;
7373
74-inline constexpr int varobj_sign (object __obj)
74+inline constexpr int varobj_sign (object obj)
7575 {
76- return ((int)((__obj >> (TYPE_SHIFT - 1))) & 1);
76+ return ((int)((obj >> (TYPE_SHIFT - 1))) & 1);
7777 }
7878
7979 // Get a pointer from a varobj, masking sign bit and type.
80-inline constexpr void* unmask (object __obj)
80+inline constexpr void* unmask (object obj)
8181 {
82- return ((obj_cast_helper { __obj & (EXTRA_BIT - 1) }).ptr);
83-}
84-
85-inline constexpr object ptrtype (const void *__p, int __type)
86-{
87- return ((((object)__type) << TYPE_SHIFT) | ((ptr_cast_helper { __p }).obj));
82+ return ((obj_cast_helper { obj & (EXTRA_BIT - 1) }).ptr);
8883 }
8984
90-inline constexpr object ptrtype (object __ptrval, int __type)
85+inline constexpr object ptrtype (const void *p, int type)
9186 {
92- return ((((object)__type) << TYPE_SHIFT) | __ptrval);
87+ return ((((object)type) << TYPE_SHIFT) | ((ptr_cast_helper { p }).obj));
9388 }
9489
95-inline constexpr int itype (object __obj)
90+inline constexpr object ptrtype (object ptrval, int type)
9691 {
97- return ((int)(__obj >> TYPE_SHIFT));
92+ return ((((object)type) << TYPE_SHIFT) | ptrval);
9893 }
9994
100-inline constexpr bool immediate_p (object __obj)
95+inline constexpr int itype (object obj)
10196 {
102- return (itype (__obj) <= typecode::CHAR);
97+ return ((int)(obj >> TYPE_SHIFT));
98+}
99+
100+inline constexpr bool immediate_p (object obj)
101+{
102+ return (itype (obj) <= typecode::CHAR);
103103 }
104104
105105 const object UNBOUND = UINT64_C (0x7f) << TYPE_SHIFT;
106106
107-extern void* ensure_mask_impl (void *__ptr, int __mask);
107+extern void* ensure_mask_impl (void *ptr, int mask);
108108
109109 #else
110110
@@ -114,23 +114,23 @@
114114 * purposes as described above. */
115115
116116 // Get a pointer from a varobj, masking type and extra bits.
117-inline constexpr void* unmask (object __obj)
117+inline constexpr void* unmask (object obj)
118118 {
119- return ((obj_cast_helper { __obj & ~7 }).ptr);
119+ return ((obj_cast_helper { obj & ~7 }).ptr);
120120 }
121121
122-inline constexpr void* ensure_mask_impl (void *__p, int)
122+inline constexpr void* ensure_mask_impl (void *p, int)
123123 {
124- return (__p);
124+ return (p);
125125 }
126126
127127 const int EXTRA_BIT = 4;
128128 const int TYPE_SHIFT = 0;
129129
130130 // Immediate objects have typecodes 0 and 1 encoded in the first bits.
131-inline constexpr bool immediate_p (object __obj)
131+inline constexpr bool immediate_p (object obj)
132132 {
133- return ((__obj & 3) < 2);
133+ return ((obj & 3) < 2);
134134 }
135135
136136 /* UNBOUND has the typecode of a 'char', but its representation is beyond
@@ -144,9 +144,9 @@
144144 "#<unbound> must not have the extra bit set");
145145
146146 template <class T>
147-T* ensure_mask (T *__ptr, int __mask)
147+T* ensure_mask (T *ptr, int mask)
148148 {
149- return ((T *)ensure_mask_impl (__ptr, __mask));
149+ return ((T *)ensure_mask_impl (ptr, mask));
150150 }
151151
152152 // Basic double-linked list, used quite frequently.
@@ -252,9 +252,9 @@
252252
253253 iter_type<T> operator++ (int)
254254 {
255- iter_type<T> __ret = *this;
255+ iter_type<T> ret = *this;
256256 this->_Adv ();
257- return (__ret);
257+ return (ret);
258258 }
259259 };
260260
@@ -309,9 +309,9 @@
309309 #endif
310310 }
311311
312- bool flagged_p (uint32_t __flg) const
312+ bool flagged_p (uint32_t flg) const
313313 {
314- return ((this->vo_full & __flg) != 0);
314+ return ((this->vo_full & flg) != 0);
315315 }
316316
317317 bool local_p () const
@@ -320,8 +320,8 @@
320320 }
321321
322322 // Atomically manipulate the flags of a varobj.
323- bool set_flag (uint32_t __flg);
324- bool clr_flag (uint32_t __flg);
323+ bool set_flag (uint32_t flg);
324+ bool clr_flag (uint32_t flg);
325325 };
326326
327327 // Flags that apply to every object.
@@ -343,9 +343,9 @@
343343 NZAP_PREV = 1 << 2
344344 };
345345
346-inline varobj* as_varobj (object __obj)
346+inline varobj* as_varobj (object obj)
347347 {
348- return ((varobj *)unmask (__obj));
348+ return ((varobj *)unmask (obj));
349349 }
350350
351351 // Finalizable objects.
@@ -354,23 +354,23 @@
354354 void (*fini) (finobj *);
355355 };
356356
357-inline finobj* as_finobj (object __obj)
357+inline finobj* as_finobj (object obj)
358358 {
359- return ((finobj *)unmask (__obj));
359+ return ((finobj *)unmask (obj));
360360 }
361361
362362 #ifdef QP_ARCH_WIDE
363363
364-inline constexpr bool varobj_p (object __obj)
364+inline constexpr bool varobj_p (object obj)
365365 {
366- return (itype (__obj) > typecode::CONS);
366+ return (itype (obj) > typecode::CONS);
367367 }
368368
369369 #else
370370
371-inline constexpr bool varobj_p (object __obj)
371+inline constexpr bool varobj_p (object obj)
372372 {
373- return ((__obj & 3) == 3);
373+ return ((obj & 3) == 3);
374374 }
375375
376376 #endif
@@ -392,34 +392,34 @@
392392
393393 // Common definitions, because why not?
394394 template <class T>
395-inline T (min) (const T& __left, const T& __right)
395+inline T (min) (const T& left, const T& right)
396396 {
397- return (__right < __left ? __right : __left);
398-}
399-
400-template <class T>
401-inline T (max) (const T& __left, const T& __right)
402-{
403- return (__left > __right ? __left : __right);
397+ return (right < left ? right : left);
404398 }
405399
406400 template <class T>
407-inline T (abs) (T __val)
401+inline T (max) (const T& left, const T& right)
408402 {
409- return (__val < 0 ? -__val : __val);
403+ return (left > right ? left : right);
410404 }
411405
412406 template <class T>
413-void (swap) (T& __left, T& __right)
407+inline T (abs) (T val)
414408 {
415- T __tmp = __left;
416- __left = __right, __right = __tmp;
409+ return (val < 0 ? -val : val);
417410 }
418411
419412 template <class T>
420-inline constexpr bool pow2_p (T __val)
413+void (swap) (T& left, T& right)
421414 {
422- return (__val != 0 && ((__val & (__val - 1)) == 0));
415+ T tmp = left;
416+ left = right, right = tmp;
417+}
418+
419+template <class T>
420+inline constexpr bool pow2_p (T val)
421+{
422+ return (val != 0 && ((val & (val - 1)) == 0));
423423 }
424424
425425 template <class T>
@@ -443,28 +443,28 @@
443443 # undef QP_HAS_ALLOCA
444444 #endif
445445
446-inline constexpr uint32_t hash_rotl (uint32_t __code, uint32_t __nb)
446+inline constexpr uint32_t hash_rotl (uint32_t code, uint32_t nb)
447447 {
448- return ((__code << __nb) | (__code >> (32 - __nb)));
448+ return ((code << nb) | (code >> (32 - nb)));
449449 }
450450
451-inline constexpr uint32_t mix_hash (uint32_t __h1, uint32_t __h2)
451+inline constexpr uint32_t mix_hash (uint32_t h1, uint32_t h2)
452452 {
453- return (hash_rotl (__h1, 5) ^ __h2);
453+ return (hash_rotl (h1, 5) ^ h2);
454454 }
455455
456456 // Like 'memcpy' and 'memmove' for objects.
457-inline object* copy_objs (object *__dst,
458- const object *__src, size_t __nobjs)
457+inline object* copy_objs (object *dst,
458+ const object *src, size_t nobjs)
459459 {
460- memcpy (__dst, __src, __nobjs * sizeof (object));
461- return (__dst + __nobjs);
460+ memcpy (dst, src, nobjs * sizeof (object));
461+ return (dst + nobjs);
462462 }
463463
464-inline void move_objs (object *__dst,
465- const object *__src, size_t __nobjs)
464+inline void move_objs (object *dst,
465+ const object *src, size_t nobjs)
466466 {
467- memmove (__dst, __src, __nobjs * sizeof (object));
467+ memmove (dst, src, nobjs * sizeof (object));
468468 }
469469
470470 // Misc. definitions.
@@ -481,23 +481,23 @@
481481 // Utility functions.
482482 #ifndef QP_ARCH_WIDE
483483
484-inline int itype (object __obj)
484+inline int itype (object obj)
485485 {
486- auto __tmp = __obj & 3;
487- switch (__tmp)
486+ auto tmp = obj & 3;
487+ switch (tmp)
488488 {
489489 case 0: case 2:
490- return (__tmp);
490+ return (tmp);
491491 case 1:
492- return (__obj == UNBOUND ? 0x7f : __tmp);
492+ return (obj == UNBOUND ? 0x7f : tmp);
493493 default:
494- return (as_varobj(__obj)->vo_type);
494+ return (as_varobj(obj)->vo_type);
495495 }
496496 }
497497
498498 #endif
499499
500-QP_EXPORT uint32_t upsize (uint32_t __n);
500+QP_EXPORT uint32_t upsize (uint32_t n);
501501
502502 #ifdef __GNUC__
503503 # define qp_expect(cond, val) __builtin_expect (!!(cond), (val))
@@ -510,56 +510,56 @@
510510
511511 #ifdef __GNUC__
512512
513-inline constexpr int ctz (uint32_t __val)
513+inline constexpr int ctz (uint32_t val)
514514 {
515- return (__builtin_ctz (__val));
515+ return (__builtin_ctz (val));
516516 }
517517
518518 #else
519519
520-inline int ctz (uint32_t __val)
520+inline int ctz (uint32_t val)
521521 {
522- int __ret = 0;
522+ int ret = 0;
523523
524- __val &= ~__val + 1; // Isolate the LSB.
525- __ret += !!(__val & 0xaaaaaaaau) << 0;
526- __ret += !!(__val & 0xccccccccu) << 1;
527- __ret += !!(__val & 0xf0f0f0f0u) << 2;
528- __ret += !!(__val & 0xff00ff00u) << 3;
529- __ret += !!(__val & 0xffff0000u) << 4;
524+ val &= ~val + 1; // Isolate the LSB.
525+ ret += !!(val & 0xaaaaaaaau) << 0;
526+ ret += !!(val & 0xccccccccu) << 1;
527+ ret += !!(val & 0xf0f0f0f0u) << 2;
528+ ret += !!(val & 0xff00ff00u) << 3;
529+ ret += !!(val & 0xffff0000u) << 4;
530530
531- return (__ret);
531+ return (ret);
532532 }
533533
534534 #endif
535535
536536 inline uint16_t
537-get16 (const void *__ptr)
537+get16 (const void *ptr)
538538 {
539- uint16_t __ret;
540- memcpy (&__ret, __ptr, sizeof (__ret));
541- return (__ret);
539+ uint16_t ret;
540+ memcpy (&ret, ptr, sizeof (ret));
541+ return (ret);
542542 }
543543
544544 inline uint32_t
545-get32 (const void *__ptr)
545+get32 (const void *ptr)
546546 {
547- uint32_t __ret;
548- memcpy (&__ret, __ptr, sizeof (__ret));
549- return (__ret);
547+ uint32_t ret;
548+ memcpy (&ret, ptr, sizeof (ret));
549+ return (ret);
550550 }
551551
552552 inline void
553-put16 (void *__ptr, uint32_t __val)
553+put16 (void *ptr, uint32_t val)
554554 {
555- uint16_t __v2 = (uint16_t)__val;
556- memcpy (__ptr, &__v2, sizeof (__v2));
555+ uint16_t v2 = (uint16_t)val;
556+ memcpy (ptr, &v2, sizeof (v2));
557557 }
558558
559559 inline void
560-put32 (void *__ptr, uint32_t __val)
560+put32 (void *ptr, uint32_t val)
561561 {
562- memcpy (__ptr, &__val, sizeof (__val));
562+ memcpy (ptr, &val, sizeof (val));
563563 }
564564
565565 // Return value for builtins - Assumes 'interp' is bound.
diff -r cee131b9ae2c -r ebca8eb602d8 dynlib.h
--- a/dynlib.h Thu Mar 26 22:26:35 2020 -0300
+++ b/dynlib.h Fri Mar 27 00:10:43 2020 -0300
@@ -13,15 +13,15 @@
1313
1414 struct interpreter;
1515
16-QP_EXPORT void* dynlib_open (interpreter *__interp,
17- const char *__path, uint32_t __path_len, uint32_t __flags);
16+QP_EXPORT void* dynlib_open (interpreter *interp,
17+ const char *path, uint32_t path_len, uint32_t flags);
1818
19-QP_EXPORT void* dynlib_open (interpreter *__interp,
20- const char *__path, uint32_t __flags);
19+QP_EXPORT void* dynlib_open (interpreter *interp,
20+ const char *path, uint32_t flags);
2121
22-QP_EXPORT void* dynlib_sym (void *__dynlib, const char *__symbol);
22+QP_EXPORT void* dynlib_sym (void *dynlib, const char *symbol);
2323
24-QP_EXPORT void dynlib_close (void *__dynlib);
24+QP_EXPORT void dynlib_close (void *dynlib);
2525
2626 QP_EXPORT const char* dynlib_extension ();
2727
diff -r cee131b9ae2c -r ebca8eb602d8 event.h
--- a/event.h Thu Mar 26 22:26:35 2020 -0300
+++ b/event.h Fri Mar 27 00:10:43 2020 -0300
@@ -32,10 +32,10 @@
3232 const int NPENDEV = QP_NSIG + 3;
3333
3434 // Install the event handler FCT for event EV.
35-object add_evhandler (interpreter *__interp, unsigned int __ev, object __fct);
35+object add_evhandler (interpreter *interp, unsigned int ev, object fct);
3636
3737 // Get the event handler for event EV.
38-object get_evhandler (interpreter *__interp, unsigned int __ev);
38+object get_evhandler (interpreter *interp, unsigned int ev);
3939
4040 // Init OP for the event subsystem.
4141 QP_EXPORT init_op init_event;
diff -r cee131b9ae2c -r ebca8eb602d8 floatp.h
--- a/floatp.h Thu Mar 26 22:26:35 2020 -0300
+++ b/floatp.h Fri Mar 27 00:10:43 2020 -0300
@@ -14,40 +14,40 @@
1414
1515 double val;
1616
17- static object make (interpreter *__interp, double __val);
17+ static object make (interpreter *interp, double val);
1818 };
1919
2020 #ifdef QP_ARCH_WIDE
2121
22-inline constexpr bool float_p (object __obj)
22+inline constexpr bool float_p (object obj)
2323 {
24- return (itype (__obj) == typecode::FLOAT);
24+ return (itype (obj) == typecode::FLOAT);
2525 }
2626
2727 #else
2828
29-inline bool float_p (object __obj)
29+inline bool float_p (object obj)
3030 {
31- return (varobj_p (__obj) && as_varobj(__obj)->vo_type == typecode::FLOAT);
31+ return (varobj_p (obj) && as_varobj(obj)->vo_type == typecode::FLOAT);
3232 }
3333
3434 #endif
3535
36-inline fltobj* as_fltobj (object __obj)
36+inline fltobj* as_fltobj (object obj)
3737 {
38- return ((fltobj *)unmask (__obj));
38+ return ((fltobj *)unmask (obj));
3939 }
4040
4141 #ifndef QP_ARCH_WIDE
4242
43-QP_EXPORT double as_float (object __obj);
43+QP_EXPORT double as_float (object obj);
4444
4545 #else
4646
47-inline double as_float (object __obj)
47+inline double as_float (object obj)
4848 {
49- double __ret = as_fltobj(__obj)->val;
50- return ((__obj & SIGN_BIT) ? -__ret : __ret);
49+ double ret = as_fltobj(obj)->val;
50+ return ((obj & SIGN_BIT) ? -ret : ret);
5151 }
5252
5353 #endif
@@ -62,88 +62,88 @@
6262 int expo;
6363 limb_t *data;
6464
65- static bigfloat* alloc_raw (int __len);
65+ static bigfloat* alloc_raw (int len);
6666
67- void local_init (limb_t *__data = nullptr, int __len = 0, int __expo = 0)
67+ void local_init (limb_t *data = nullptr, int len = 0, int expo = 0)
6868 {
69- this->data = __data;
70- this->len = __len;
71- this->expo = __expo;
69+ this->data = data;
70+ this->len = len;
71+ this->expo = expo;
7272 }
7373 };
7474
7575 #ifdef QP_ARCH_WIDE
7676
77-inline constexpr bool bigfloat_p (object __obj)
77+inline constexpr bool bigfloat_p (object obj)
7878 {
79- return (itype (__obj) == typecode::BIGFLOAT);
79+ return (itype (obj) == typecode::BIGFLOAT);
8080 }
8181
8282 #else
8383
84-inline bool bigfloat_p (object __obj)
84+inline bool bigfloat_p (object obj)
8585 {
86- return (varobj_p (__obj) && as_varobj(__obj)->vo_type == typecode::BIGFLOAT);
86+ return (varobj_p (obj) && as_varobj(obj)->vo_type == typecode::BIGFLOAT);
8787 }
8888
8989 #endif
9090
91-inline bigfloat* as_bigfloat (object __obj)
91+inline bigfloat* as_bigfloat (object obj)
9292 {
93- return ((bigfloat *)unmask (__obj));
93+ return ((bigfloat *)unmask (obj));
9494 }
9595
9696 // Test if DBL is NaN.
97-QP_EXPORT bool fnan_p (double __dbl);
97+QP_EXPORT bool fnan_p (double dbl);
9898
9999 // Test if DBL is +/- infinity.
100-QP_EXPORT int finf_p (double __dbl);
100+QP_EXPORT int finf_p (double dbl);
101101
102102 // Allocate a bigfloat with LEN limbs.
103-QP_EXPORT object alloc_bigfloat (interpreter *__interp, int __len);
103+QP_EXPORT object alloc_bigfloat (interpreter *interp, int len);
104104
105105 // Arithmetic functions with floats.
106-QP_EXPORT object add_ff (interpreter *__interp, object __x, object __y);
107-QP_EXPORT object add_fF (interpreter *__interp, object __x, object __y);
108-QP_EXPORT object add_FF (interpreter *__interp, object __x, object __y);
109-
110-QP_EXPORT object sub_ff (interpreter *__interp, object __x, object __y);
111-QP_EXPORT object sub_fF (interpreter *__interp, object __x, object __y);
112-QP_EXPORT object sub_FF (interpreter *__interp, object __x, object __y);
106+QP_EXPORT object add_ff (interpreter *interp, object x, object y);
107+QP_EXPORT object add_fF (interpreter *interp, object x, object y);
108+QP_EXPORT object add_FF (interpreter *interp, object x, object y);
113109
114-QP_EXPORT object mul_ff (interpreter *__interp, object __x, object __y);
115-QP_EXPORT object mul_fF (interpreter *__interp, object __x, object __y);
116-QP_EXPORT object mul_FF (interpreter *__interp, object __x, object __y);
110+QP_EXPORT object sub_ff (interpreter *interp, object x, object y);
111+QP_EXPORT object sub_fF (interpreter *interp, object x, object y);
112+QP_EXPORT object sub_FF (interpreter *interp, object x, object y);
117113
118-QP_EXPORT object div_ff (interpreter *__interp, object __x, object __y);
119-QP_EXPORT object div_fF (interpreter *__interp, object __x, object __y);
120-QP_EXPORT object div_Ff (interpreter *__interp, object __x, object __y);
121-QP_EXPORT object div_FF (interpreter *__interp, object __x, object __y);
114+QP_EXPORT object mul_ff (interpreter *interp, object x, object y);
115+QP_EXPORT object mul_fF (interpreter *interp, object x, object y);
116+QP_EXPORT object mul_FF (interpreter *interp, object x, object y);
122117
123-QP_EXPORT object mod_ff (interpreter *__interp, object __x, object __y);
124-QP_EXPORT object mod_fF (interpreter *__interp, object __x, object __y);
125-QP_EXPORT object mod_Ff (interpreter *__interp, object __x, object __y);
126-QP_EXPORT object mod_FF (interpreter *__interp, object __x, object __y);
118+QP_EXPORT object div_ff (interpreter *interp, object x, object y);
119+QP_EXPORT object div_fF (interpreter *interp, object x, object y);
120+QP_EXPORT object div_Ff (interpreter *interp, object x, object y);
121+QP_EXPORT object div_FF (interpreter *interp, object x, object y);
122+
123+QP_EXPORT object mod_ff (interpreter *interp, object x, object y);
124+QP_EXPORT object mod_fF (interpreter *interp, object x, object y);
125+QP_EXPORT object mod_Ff (interpreter *interp, object x, object y);
126+QP_EXPORT object mod_FF (interpreter *interp, object x, object y);
127127
128128 // Comparisons between floating-point objects.
129-QP_EXPORT int cmp_ff (interpreter *__interp, object __x, object __y);
130-QP_EXPORT int cmp_fF (interpreter *__interp, object __x, object __y);
131-QP_EXPORT int cmp_FF (interpreter *__interp, object __x, object __y);
132-QP_EXPORT bool eq_ff (interpreter *__interp, object __x, object __y);
133-QP_EXPORT bool eq_FF (interpreter *__interp, object __x, object __y);
129+QP_EXPORT int cmp_ff (interpreter *interp, object x, object y);
130+QP_EXPORT int cmp_fF (interpreter *interp, object x, object y);
131+QP_EXPORT int cmp_FF (interpreter *interp, object x, object y);
132+QP_EXPORT bool eq_ff (interpreter *interp, object x, object y);
133+QP_EXPORT bool eq_FF (interpreter *interp, object x, object y);
134134
135135 // Mixed arithmetic functions.
136136
137137 #define MIXED_FN(name) \
138-QP_EXPORT object name##_if (interpreter *__interp, object __x, object __y); \
139-QP_EXPORT object name##_fi (interpreter *__interp, object __x, object __y); \
140-QP_EXPORT object name##_iF (interpreter *__interp, object __x, object __y); \
141-QP_EXPORT object name##_Fi (interpreter *__interp, object __x, object __y); \
138+QP_EXPORT object name##_if (interpreter *interp, object x, object y); \
139+QP_EXPORT object name##_fi (interpreter *interp, object x, object y); \
140+QP_EXPORT object name##_iF (interpreter *interp, object x, object y); \
141+QP_EXPORT object name##_Fi (interpreter *interp, object x, object y); \
142142 \
143-QP_EXPORT object name##_If (interpreter *__interp, object __x, object __y); \
144-QP_EXPORT object name##_fI (interpreter *__interp, object __x, object __y); \
145-QP_EXPORT object name##_IF (interpreter *__interp, object __x, object __y); \
146-QP_EXPORT object name##_FI (interpreter *__interp, object __x, object __y)
143+QP_EXPORT object name##_If (interpreter *interp, object x, object y); \
144+QP_EXPORT object name##_fI (interpreter *interp, object x, object y); \
145+QP_EXPORT object name##_IF (interpreter *interp, object x, object y); \
146+QP_EXPORT object name##_FI (interpreter *interp, object x, object y)
147147
148148 MIXED_FN (add);
149149 MIXED_FN (sub);
@@ -153,27 +153,27 @@
153153
154154 #undef MIXED_FN
155155
156-QP_EXPORT object lsh_fi (interpreter *__interp, object __x, object __y);
157-QP_EXPORT object lsh_Fi (interpreter *__interp, object __x, object __y);
158-
159-QP_EXPORT object rsh_fi (interpreter *__interp, object __x, object __y);
160-QP_EXPORT object rsh_Fi (interpreter *__interp, object __x, object __y);
156+QP_EXPORT object lsh_fi (interpreter *interp, object x, object y);
157+QP_EXPORT object lsh_Fi (interpreter *interp, object x, object y);
161158
162-QP_EXPORT int cmp_if (interpreter *__interp, object __x, object __y);
163-QP_EXPORT int cmp_iF (interpreter *__interp, object __x, object __y);
164-QP_EXPORT int cmp_If (interpreter *__interp, object __x, object __y);
165-QP_EXPORT int cmp_IF (interpreter *__interp, object __x, object __y);
159+QP_EXPORT object rsh_fi (interpreter *interp, object x, object y);
160+QP_EXPORT object rsh_Fi (interpreter *interp, object x, object y);
166161
167-QP_EXPORT bool eq_if (interpreter *__interp, object __x, object __y);
168-QP_EXPORT bool eq_If (interpreter *__interp, object __x, object __y);
169-QP_EXPORT bool eq_IF (interpreter *__interp, object __x, object __y);
162+QP_EXPORT int cmp_if (interpreter *interp, object x, object y);
163+QP_EXPORT int cmp_iF (interpreter *interp, object x, object y);
164+QP_EXPORT int cmp_If (interpreter *interp, object x, object y);
165+QP_EXPORT int cmp_IF (interpreter *interp, object x, object y);
166+
167+QP_EXPORT bool eq_if (interpreter *interp, object x, object y);
168+QP_EXPORT bool eq_If (interpreter *interp, object x, object y);
169+QP_EXPORT bool eq_IF (interpreter *interp, object x, object y);
170170
171171 // Additional unary functions.
172172
173-QP_EXPORT object neg_f (interpreter *__interp, object __obj);
174-QP_EXPORT object neg_F (interpreter *__interp, object __obj);
175-QP_EXPORT uint32_t hash_f (interpreter *__interp, object __obj);
176-QP_EXPORT uint32_t hash_F (interpreter *__interp, object __obj);
173+QP_EXPORT object neg_f (interpreter *interp, object obj);
174+QP_EXPORT object neg_F (interpreter *interp, object obj);
175+QP_EXPORT uint32_t hash_f (interpreter *interp, object obj);
176+QP_EXPORT uint32_t hash_F (interpreter *interp, object obj);
177177
178178 // I/O with floats.
179179
@@ -181,23 +181,23 @@
181181 struct io_info;
182182 struct pack_info;
183183
184-QP_EXPORT int write_f (interpreter *__interp,
185- stream *__strm, object __obj, io_info& __info);
186-
187-QP_EXPORT int write_F (interpreter *__interp,
188- stream *__strm, object __obj, io_info& __info);
184+QP_EXPORT int write_f (interpreter *interp,
185+ stream *strm, object obj, io_info& info);
189186
190-QP_EXPORT int64_t pack_f (interpreter *__interp,
191- stream *__strm, object __obj, pack_info& __info);
187+QP_EXPORT int write_F (interpreter *interp,
188+ stream *strm, object obj, io_info& info);
192189
193-QP_EXPORT int pack_F (interpreter *__interp,
194- stream *__strm, object __obj, pack_info& __info);
190+QP_EXPORT int64_t pack_f (interpreter *interp,
191+ stream *strm, object obj, pack_info& info);
195192
196-QP_EXPORT object unpack_f (interpreter *__interp,
197- stream *__strm, pack_info& __info, bool __save);
193+QP_EXPORT int pack_F (interpreter *interp,
194+ stream *strm, object obj, pack_info& info);
198195
199-QP_EXPORT object unpack_F (interpreter *__interp,
200- stream *__strm, pack_info& __info, bool __save);
196+QP_EXPORT object unpack_f (interpreter *interp,
197+ stream *strm, pack_info& info, bool save);
198+
199+QP_EXPORT object unpack_F (interpreter *interp,
200+ stream *strm, pack_info& info, bool save);
201201
202202 // Global objects.
203203 QP_EXPORT object FLT_PINF; // +INF
diff -r cee131b9ae2c -r ebca8eb602d8 function.h
--- a/function.h Thu Mar 26 22:26:35 2020 -0300
+++ b/function.h Fri Mar 27 00:10:43 2020 -0300
@@ -6,7 +6,7 @@
66
77 QP_DECLS_BEGIN
88
9-QP_EXPORT const char* fct_sname (object __fct);
9+QP_EXPORT const char* fct_sname (object fct);
1010
1111 struct function_base : public varobj
1212 {
@@ -22,16 +22,15 @@
2222 int max_argc;
2323 object name;
2424
25- bool test_nargs (interpreter *__interp, uint32_t __n,
26- bool __raise = true) const
25+ bool test_nargs (interpreter *interp, uint32_t n, bool raise = true) const
2726 {
28- if (__n >= (uint32_t)this->min_argc && __n <= (uint32_t)this->max_argc)
27+ if (n >= (uint32_t)this->min_argc && n <= (uint32_t)this->max_argc)
2928 return (true);
30- else if (!__raise)
29+ else if (!raise)
3130 return (false);
3231
33- __interp->raise_nargs (this->name,
34- this->min_argc, this->max_argc, __n);
32+ interp->raise_nargs (this->name,
33+ this->min_argc, this->max_argc, n);
3534 }
3635 };
3736
@@ -65,15 +64,15 @@
6564
6665 int max_stack () const;
6766
68- void copy_into (function *__fp)
67+ void copy_into (function *fp)
6968 {
70- __fp->vo_full |= this->vo_full;
71- __fp->max_sp = this->max_sp;
72- __fp->min_argc = this->min_argc;
73- __fp->max_argc = this->max_argc;
74- __fp->bcode = this->bcode;
75- __fp->vals = this->vals;
76- __fp->env = this->env;
69+ fp->vo_full |= this->vo_full;
70+ fp->max_sp = this->max_sp;
71+ fp->min_argc = this->min_argc;
72+ fp->max_argc = this->max_argc;
73+ fp->bcode = this->bcode;
74+ fp->vals = this->vals;
75+ fp->env = this->env;
7776 }
7877
7978 void local_init ()
@@ -83,117 +82,117 @@
8382 }
8483 };
8584
86-inline function* as_fct (object __obj)
85+inline function* as_fct (object obj)
8786 {
88- return ((function *)unmask (__obj));
87+ return ((function *)unmask (obj));
8988 }
9089
9190 #ifdef QP_ARCH_WIDE
9291
93-inline constexpr bool fct_p (object __obj)
92+inline constexpr bool fct_p (object obj)
9493 {
95- return (itype (__obj) == typecode::FCT);
94+ return (itype (obj) == typecode::FCT);
9695 }
9796
9897 #else
9998
100-inline bool fct_p (object __obj)
99+inline bool fct_p (object obj)
101100 {
102- return (varobj_p (__obj) && as_varobj(__obj)->vo_type == typecode::FCT);
101+ return (varobj_p (obj) && as_varobj(obj)->vo_type == typecode::FCT);
103102 }
104103
105104 #endif
106105
107-inline object& fct_bcode (object __obj)
106+inline object& fct_bcode (object obj)
108107 {
109- return (as_fct(__obj)->bcode);
110-}
111-
112-inline object& fct_vals (object __obj)
113-{
114- return (as_fct(__obj)->vals);
108+ return (as_fct(obj)->bcode);
115109 }
116110
117-inline object& fct_env (object __obj)
111+inline object& fct_vals (object obj)
118112 {
119- return (as_fct(__obj)->env);
113+ return (as_fct(obj)->vals);
120114 }
121115
122-inline native_function* as_native_fct (object __obj)
116+inline object& fct_env (object obj)
123117 {
124- return ((native_function *)unmask (__obj));
118+ return (as_fct(obj)->env);
125119 }
126120
127-inline bool native_fct_p (object __obj)
121+inline native_function* as_native_fct (object obj)
128122 {
129- return (fct_p (__obj) &&
130- as_fct(__obj)->flagged_p (function_base::native_flag));
123+ return ((native_function *)unmask (obj));
131124 }
132125
133-inline object& fct_name (object __obj)
126+inline bool native_fct_p (object obj)
134127 {
135- return (((function_base *)unmask (__obj))->name);
128+ return (fct_p (obj) &&
129+ as_fct(obj)->flagged_p (function_base::native_flag));
130+}
131+
132+inline object& fct_name (object obj)
133+{
134+ return (((function_base *)unmask (obj))->name);
136135 }
137136
138137 // Allocate a function with flags FLAGS.
139-QP_EXPORT object alloc_fct (interpreter *__interp, uint32_t __flags = 0);
138+QP_EXPORT object alloc_fct (interpreter *interp, uint32_t flags = 0);
140139
141140 // Test for function equality.
142-QP_EXPORT bool eq_xx (interpreter *__interp, object __x, object __y);
141+QP_EXPORT bool eq_xx (interpreter *interp, object x, object y);
143142
144143 // Compile the expression EXPR and return a thunk.
145-QP_EXPORT object compile_expr (interpreter *__interp, object __expr);
144+QP_EXPORT object compile_expr (interpreter *interp, object expr);
146145
147146 // Evaluate the expression EXPR.
148-QP_EXPORT object eval (interpreter *__interp, object __expr);
147+QP_EXPORT object eval (interpreter *interp, object expr);
149148
150149 // Return the single macro-expansion of EXPR in environment ENV.
151-QP_EXPORT object macroexp_1 (interpreter *__interp,
152- object __expr, object __env);
150+QP_EXPORT object macroexp_1 (interpreter *interp,
151+ object expr, object env);
153152
154153 // Return the full macro-expansion of EXPR in environment ENV.
155-QP_EXPORT object macroexp (interpreter *__interp,
156- object __expr, object __env);
154+QP_EXPORT object macroexp (interpreter *interp,
155+ object expr, object env);
157156
158157 // Return the single macro-expansion of EXPR in the null environment.
159-QP_EXPORT object macroexp_1 (interpreter *__interp, object __expr);
158+QP_EXPORT object macroexp_1 (interpreter *interp, object expr);
160159
161160 // Return the full macro-expansion of EXPR in the null environment.
162-QP_EXPORT object macroexp (interpreter *__interp, object __expr);
161+QP_EXPORT object macroexp (interpreter *interp, object expr);
163162
164163 // Call function after having pushed it and its N arguments on the stack.
165-QP_EXPORT object call_n (interpreter *__interp, uint32_t __n);
164+QP_EXPORT object call_n (interpreter *interp, uint32_t n);
166165
167166 // Compute the needed stack size for function FCT.
168-QP_EXPORT int fct_stacksize (object __fct);
167+QP_EXPORT int fct_stacksize (object fct);
169168
170169 struct stream;
171170 struct io_info;
172171 struct pack_info;
173172
174173 // Write a function to a stream.
175-QP_EXPORT int write_x (interpreter *__interp,
176- stream *__strm, object __obj, io_info& __info);
174+QP_EXPORT int write_x (interpreter *interp,
175+ stream *strm, object obj, io_info& info);
177176
178177 // Serialize a function in a stream.
179-QP_EXPORT int64_t pack_x (interpreter *__interp,
180- stream *__strm, object __obj, pack_info& __info);
178+QP_EXPORT int64_t pack_x (interpreter *interp,
179+ stream *strm, object obj, pack_info& info);
181180
182181 // Deserialize a function in a stream.
183-QP_EXPORT object unpack_x (interpreter *__interp,
184- stream *__strm, pack_info& __info, bool __save);
182+QP_EXPORT object unpack_x (interpreter *interp,
183+ stream *strm, pack_info& info, bool save);
185184
186185 // Disassemble the function FN and write the instructions to OUT.
187-QP_EXPORT void disasm (interpreter *__interp, object __fn, object __out);
186+QP_EXPORT void disasm (interpreter *interp, object fn, object out);
188187
189188 // Get the builtin index for function named NAME.
190-QP_EXPORT int builtin_idx (interpreter *__interp, const char *__name);
189+QP_EXPORT int builtin_idx (interpreter *interp, const char *name);
191190
192191 // Return the builtin function for NAME.
193-QP_EXPORT object builtin_fct (interpreter *__interp, const char *__name);
192+QP_EXPORT object builtin_fct (interpreter *interp, const char *name);
194193
195194 // Return the builtin function with index IDX.
196-QP_EXPORT object builtin_fct (interpreter *__interp, int __idx);
195+QP_EXPORT object builtin_fct (interpreter *interp, int idx);
197196
198197 // Helper for the implementation of multimethods.
199198 QP_EXPORT object p_meth_ctl (interpreter *interp, object *argv, int argc);
@@ -205,53 +204,53 @@
205204 {
206205 object args[1 + sizeof... (Args)];
207206
208- callvec (Args... __args)
207+ callvec (Args... args)
209208 {
210- object __elems[] = { 0, __args... };
211- for (size_t __ix = 1; __ix < QP_NELEM (__elems); ++__ix)
212- this->args[__ix - 1] = __elems[__ix];
209+ object elems[] = { 0, args... };
210+ for (size_t ix = 1; ix < QP_NELEM (elems); ++ix)
211+ this->args[ix - 1] = elems[ix];
213212 }
214213
215- uint32_t operator() (interpreter *__interp)
214+ uint32_t operator() (interpreter *interp)
216215 {
217- for (size_t __ix = 0; __ix < QP_NELEM (this->args) - 1; ++__ix)
218- __interp->push (this->args[__ix]);
216+ for (size_t ix = 0; ix < QP_NELEM (this->args) - 1; ++ix)
217+ interp->push (this->args[ix]);
219218 return (QP_NELEM (this->args) - 1);
220219 }
221220 };
222221
223222 template <class ...Args>
224-callvec<Args...> make_callvec (Args... __args)
223+callvec<Args...> make_callvec (Args... args)
225224 {
226- return (callvec<Args...> (__args...));
225+ return (callvec<Args...> (args...));
227226 }
228227
229228 template <class Ax>
230-object call_wvec (interpreter *__interp, object __fn, const Ax& __ax)
229+object call_wvec (interpreter *interp, object fn, const Ax& ax)
231230 {
232- __interp->push (__fn);
233- uint32_t __nargs;
231+ interp->push (fn);
232+ uint32_t nargs;
234233
235234 {
236- local_gc_guard __g { __interp };
237- __nargs = __ax() (__interp);
235+ local_gc_guard g { interp };
236+ nargs = ax() (interp);
238237 }
239238
240- return (call_n (__interp, __nargs));
239+ return (call_n (interp, nargs));
241240 }
242241
243242 template <class Ax>
244-object call_wvec (interpreter *__interp,
245- object (*__f) (interpreter *, object *, int), const Ax& __ax)
243+object call_wvec (interpreter *interp,
244+ object (*fn) (interpreter *, object *, int), const Ax& ax)
246245 {
247- uint32_t __nargs;
246+ uint32_t nargs;
248247
249248 {
250- local_gc_guard __g { __interp };
251- __nargs = __ax() (__interp);
249+ local_gc_guard g { interp };
250+ nargs = ax() (interp);
252251 }
253252
254- return (__f (__interp, __interp->stkend - __nargs, __nargs));
253+ return (fn (interp, interp->stkend - nargs, nargs));
255254 }
256255
257256 // Call FN with arguments.
diff -r cee131b9ae2c -r ebca8eb602d8 initop.h
--- a/initop.h Thu Mar 26 22:26:35 2020 -0300
+++ b/initop.h Fri Mar 27 00:10:43 2020 -0300
@@ -17,10 +17,10 @@
1717 this->ops.init_head ();
1818 }
1919
20- inline void add (init_op *__op);
20+ inline void add (init_op *op);
2121
2222 static init_op_list& global_ops ();
23- bool call (interpreter *__interp);
23+ bool call (interpreter *interp);
2424 };
2525
2626 struct init_op
@@ -45,25 +45,25 @@
4545 dlist link;
4646
4747 template <class ...Args>
48- static int call_deps (interpreter *__interp, Args... __args)
48+ static int call_deps (interpreter *interp, Args... args)
4949 {
50- init_op *__deps[] = { __args... };
51- int __ret = result_ok;
50+ init_op *deps[] = { args... };
51+ int ret = result_ok;
5252
53- for (auto __p : __deps)
54- if ((__ret = __p->call (__interp)) != result_ok)
53+ for (auto p : deps)
54+ if ((ret = p->call (interp)) != result_ok)
5555 break;
5656
57- return (__ret);
57+ return (ret);
5858 }
5959
60- init_op (int (*__cb) (interpreter *), const char *__nm) :
61- state (st_init), cb (__cb), name (__nm)
60+ init_op (int (*cb) (interpreter *), const char *nm) :
61+ state (st_init), cb (cb), name (nm)
6262 {
6363 init_op_list::global_ops().add (this);
6464 }
6565
66- int call (interpreter *__interp)
66+ int call (interpreter *interp)
6767 {
6868 if (this->state == st_wip)
6969 return (result_circular);
@@ -71,17 +71,17 @@
7171 return (result_ok);
7272
7373 this->state = st_wip;
74- int __ret = this->cb (__interp);
75- if (__ret == result_ok)
74+ int ret = this->cb (interp);
75+ if (ret == result_ok)
7676 this->state = st_done;
7777
78- return (__ret);
78+ return (ret);
7979 }
8080 };
8181
82-void init_op_list::add (init_op *__op)
82+void init_op_list::add (init_op *op)
8383 {
84- this->ops.add (&__op->link);
84+ this->ops.add (&op->link);
8585 }
8686
8787 QP_DECLS_END
diff -r cee131b9ae2c -r ebca8eb602d8 integer.h
--- a/integer.h Thu Mar 26 22:26:35 2020 -0300
+++ b/integer.h Fri Mar 27 00:10:43 2020 -0300
@@ -7,19 +7,19 @@
77
88 #ifdef QP_ARCH_WIDE
99
10-inline constexpr int as_int (object __obj)
10+inline constexpr int as_int (object obj)
1111 {
12- return ((int)(__obj & 0xffffffffu));
12+ return ((int)(obj & 0xffffffffu));
1313 }
1414
15-inline constexpr object fixint (int __val)
15+inline constexpr object fixint (int val)
1616 {
17- return (ptrtype ((object)(uint32_t)__val, typecode::INT));
17+ return (ptrtype ((object)(uint32_t)val, typecode::INT));
1818 }
1919
20-inline constexpr bool fixint_p (object __obj)
20+inline constexpr bool fixint_p (object obj)
2121 {
22- return (itype (__obj) == typecode::INT);
22+ return (itype (obj) == typecode::INT);
2323 }
2424
2525 // We use the full lower word to store the int.
@@ -27,20 +27,20 @@
2727
2828 #else
2929
30-inline constexpr int as_int (object __obj)
30+inline constexpr int as_int (object obj)
3131 {
32- return ((int)((__obj >> 3) |
33- ((-(__obj >> 31)) & ((1u << 31) | (1u << 30) | (1u << 29)))));
32+ return ((int)((obj >> 3) |
33+ ((-(obj >> 31)) & ((1u << 31) | (1u << 30) | (1u << 29)))));
3434 }
3535
36-inline constexpr object fixint (int __val)
36+inline constexpr object fixint (int val)
3737 {
38- return ((uint32_t)__val << 3);
38+ return ((uint32_t)val << 3);
3939 }
4040
41-inline constexpr bool fixint_p (object __obj)
41+inline constexpr bool fixint_p (object obj)
4242 {
43- return ((__obj & 3) == 0);
43+ return ((obj & 3) == 0);
4444 }
4545
4646 // The 3 lower bits are reserved.
@@ -53,9 +53,9 @@
5353
5454 // Test if an integer can be represented as an immediate value.
5555 template <class T>
56-inline bool fitsfixint_p (T __val)
56+inline bool fitsfixint_p (T val)
5757 {
58- return (__val >= FIXINT_MIN && __val <= FIXINT_MAX);
58+ return (val >= FIXINT_MIN && val <= FIXINT_MAX);
5959 }
6060
6161 struct bigint : public varobj
@@ -67,201 +67,201 @@
6767
6868 static bigint* alloc_raw (int len);
6969
70- static object make (interpreter *__interp, int64_t __qval);
71- static object make (interpreter *__interp, uint64_t __qval);
70+ static object make (interpreter *interp, int64_t qval);
71+ static object make (interpreter *interp, uint64_t qval);
7272
7373 #ifndef QP_ARCH_WIDE
74- static object make (interpreter *__interp, intptr_t __lval)
74+ static object make (interpreter *interp, intptr_t lval)
7575 {
76- return (bigint::make (__interp, (int64_t)__lval));
76+ return (bigint::make (interp, (int64_t)lval));
7777 }
7878
79- static object make (interpreter *__interp, uintptr_t __lval)
79+ static object make (interpreter *interp, uintptr_t lval)
8080 {
81- return (bigint::make (__interp, (uint64_t)__lval));
81+ return (bigint::make (interp, (uint64_t)lval));
8282 }
8383 #endif
8484
85- void local_init (limb_t *__data = nullptr, int __len = 0)
85+ void local_init (limb_t *data = nullptr, int len = 0)
8686 {
87- this->len = __len;
88- this->data = __data;
87+ this->len = len;
88+ this->data = data;
8989 }
9090 };
9191
92-inline bigint* as_bigint (object __obj)
92+inline bigint* as_bigint (object obj)
9393 {
94- return ((bigint *)unmask (__obj));
94+ return ((bigint *)unmask (obj));
9595 }
9696
9797 #ifdef QP_ARCH_WIDE
9898
99-inline constexpr bool bigint_p (object __obj)
99+inline constexpr bool bigint_p (object obj)
100100 {
101- return (itype (__obj) == typecode::BIGINT);
101+ return (itype (obj) == typecode::BIGINT);
102102 }
103103
104104 #else
105105
106-inline bool bigint_p (object __obj)
106+inline bool bigint_p (object obj)
107107 {
108- return (varobj_p (__obj) && as_varobj(__obj)->vo_type == typecode::BIGINT);
108+ return (varobj_p (obj) && as_varobj(obj)->vo_type == typecode::BIGINT);
109109 }
110110
111111 #endif
112112
113113 // Allocate a bigint with LEN limbs.
114-QP_EXPORT object alloc_bigint (interpreter *__interp, int __len);
114+QP_EXPORT object alloc_bigint (interpreter *interp, int len);
115115
116116 // Cast bigint OBJ to an int64 in VAL.
117-QP_EXPORT bool bigint_as (object __obj, int64_t& __val);
117+QP_EXPORT bool bigint_as (object obj, int64_t& val);
118118
119119 template <class T>
120-object intobj (interpreter *__interp, T __val)
120+object intobj (interpreter *interp, T val)
121121 {
122- if (qp_likely (fitsfixint_p (__val)))
123- __interp->retval = fixint (__val);
124- else if (__val < 0)
125- bigint::make (__interp, (int64_t)__val);
122+ if (qp_likely (fitsfixint_p (val)))
123+ interp->retval = fixint (val);
124+ else if (val < 0)
125+ bigint::make (interp, (int64_t)val);
126126 else
127- bigint::make (__interp, (uint64_t)__val);
127+ bigint::make (interp, (uint64_t)val);
128128
129- return (__interp->retval);
129+ return (interp->retval);
130130 }
131131
132132 // Arithmetic operations with integers.
133-QP_EXPORT object add_iI (interpreter *__interp, object __x, object __y);
134-QP_EXPORT object add_II (interpreter *__interp, object __x, object __y);
135-
136-QP_EXPORT object sub_iI (interpreter *__interp, object __x, object __y);
137-QP_EXPORT object sub_II (interpreter *__interp, object __x, object __y);
138-
139-QP_EXPORT object mul_iI (interpreter *__interp, object __x, object __y);
140-QP_EXPORT object mul_II (interpreter *__interp, object __x, object __y);
133+QP_EXPORT object add_iI (interpreter *interp, object x, object y);
134+QP_EXPORT object add_II (interpreter *interp, object x, object y);
141135
142-QP_EXPORT object div_ii (interpreter *__interp, object __x, object __y);
143-QP_EXPORT object div_iI (interpreter *__interp, object __x, object __y);
144-QP_EXPORT object div_Ii (interpreter *__interp, object __x, object __y);
145-QP_EXPORT object div_II (interpreter *__interp, object __x, object __y);
136+QP_EXPORT object sub_iI (interpreter *interp, object x, object y);
137+QP_EXPORT object sub_II (interpreter *interp, object x, object y);
146138
147-QP_EXPORT object idiv_ii (interpreter *__interp, object __x, object __y);
148-QP_EXPORT object idiv_iI (interpreter *__interp, object __x, object __y);
149-QP_EXPORT object idiv_Ii (interpreter *__interp, object __x, object __y);
150-QP_EXPORT object idiv_II (interpreter *__interp, object __x, object __y);
139+QP_EXPORT object mul_iI (interpreter *interp, object x, object y);
140+QP_EXPORT object mul_II (interpreter *interp, object x, object y);
151141
152-QP_EXPORT object mod_ii (interpreter *__interp, object __x, object __y);
153-QP_EXPORT object mod_iI (interpreter *__interp, object __x, object __y);
154-QP_EXPORT object mod_Ii (interpreter *__interp, object __x, object __y);
155-QP_EXPORT object mod_II (interpreter *__interp, object __x, object __y);
142+QP_EXPORT object div_ii (interpreter *interp, object x, object y);
143+QP_EXPORT object div_iI (interpreter *interp, object x, object y);
144+QP_EXPORT object div_Ii (interpreter *interp, object x, object y);
145+QP_EXPORT object div_II (interpreter *interp, object x, object y);
146+
147+QP_EXPORT object idiv_ii (interpreter *interp, object x, object y);
148+QP_EXPORT object idiv_iI (interpreter *interp, object x, object y);
149+QP_EXPORT object idiv_Ii (interpreter *interp, object x, object y);
150+QP_EXPORT object idiv_II (interpreter *interp, object x, object y);
151+
152+QP_EXPORT object mod_ii (interpreter *interp, object x, object y);
153+QP_EXPORT object mod_iI (interpreter *interp, object x, object y);
154+QP_EXPORT object mod_Ii (interpreter *interp, object x, object y);
155+QP_EXPORT object mod_II (interpreter *interp, object x, object y);
156156
157157 // Logical operations with integers.
158-QP_EXPORT object land_iI (interpreter *__interp, object __x, object __y);
159-QP_EXPORT object land_II (interpreter *__interp, object __x, object __y);
160-
161-QP_EXPORT object lor_iI (interpreter *__interp, object __x, object __y);
162-QP_EXPORT object lor_II (interpreter *__interp, object __x, object __y);
158+QP_EXPORT object land_iI (interpreter *interp, object x, object y);
159+QP_EXPORT object land_II (interpreter *interp, object x, object y);
163160
164-QP_EXPORT object xor_iI (interpreter *__interp, object __x, object __y);
165-QP_EXPORT object xor_II (interpreter *__interp, object __x, object __y);
161+QP_EXPORT object lor_iI (interpreter *interp, object x, object y);
162+QP_EXPORT object lor_II (interpreter *interp, object x, object y);
166163
167-QP_EXPORT object lsh_ii (interpreter *__interp, object __x, object __y);
168-QP_EXPORT object lsh_Ii (interpreter *__interp, object __x, object __y);
164+QP_EXPORT object xor_iI (interpreter *interp, object x, object y);
165+QP_EXPORT object xor_II (interpreter *interp, object x, object y);
169166
170-QP_EXPORT object rsh_ii (interpreter *__interp, object __x, object __y);
171-QP_EXPORT object rsh_Ii (interpreter *__interp, object __x, object __y);
167+QP_EXPORT object lsh_ii (interpreter *interp, object x, object y);
168+QP_EXPORT object lsh_Ii (interpreter *interp, object x, object y);
169+
170+QP_EXPORT object rsh_ii (interpreter *interp, object x, object y);
171+QP_EXPORT object rsh_Ii (interpreter *interp, object x, object y);
172172
173173 // Comparisons between integers.
174-QP_EXPORT int cmp_iI (interpreter *__interp, object __x, object __y);
175-QP_EXPORT int cmp_II (interpreter *__interp, object __x, object __y);
176-QP_EXPORT bool eq_II (interpreter *__interp, object __x, object __y);
174+QP_EXPORT int cmp_iI (interpreter *interp, object x, object y);
175+QP_EXPORT int cmp_II (interpreter *interp, object x, object y);
176+QP_EXPORT bool eq_II (interpreter *interp, object x, object y);
177177
178178 // Additional unary functions.
179-QP_EXPORT object neg_I (interpreter *__interp, object __val);
180-QP_EXPORT object not_I (interpreter *__interp, object __val);
181-QP_EXPORT uint32_t hash_I (interpreter *__interp, object __val);
179+QP_EXPORT object neg_I (interpreter *interp, object val);
180+QP_EXPORT object not_I (interpreter *interp, object val);
181+QP_EXPORT uint32_t hash_I (interpreter *interp, object val);
182182
183183 // I/O with integers.
184184 struct stream;
185185 struct io_info;
186186 struct pack_info;
187187
188-QP_EXPORT int write_i (interpreter *__interp,
189- stream *__strm, object __obj, io_info& __info);
190-
191-QP_EXPORT int write_I (interpreter *__interp,
192- stream *__strm, object __obj, io_info& __info);
188+QP_EXPORT int write_i (interpreter *interp,
189+ stream *strm, object obj, io_info& info);
193190
194-QP_EXPORT int64_t pack_i (interpreter *__interp,
195- stream *__strm, object __obj, pack_info& __info);
191+QP_EXPORT int write_I (interpreter *interp,
192+ stream *strm, object obj, io_info& info);
196193
197-QP_EXPORT int64_t pack_I (interpreter *__interp,
198- stream *__strm, object __obj, pack_info& __info);
194+QP_EXPORT int64_t pack_i (interpreter *interp,
195+ stream *strm, object obj, pack_info& info);
199196
200-QP_EXPORT object unpack_i (interpreter *__interp,
201- stream *__strm, pack_info& __info, bool __save);
197+QP_EXPORT int64_t pack_I (interpreter *interp,
198+ stream *strm, object obj, pack_info& info);
202199
203-QP_EXPORT object unpack_I (interpreter *__interp,
204- stream *__strm, pack_info& __info, bool __save);
200+QP_EXPORT object unpack_i (interpreter *interp,
201+ stream *strm, pack_info& info, bool save);
202+
203+QP_EXPORT object unpack_I (interpreter *interp,
204+ stream *strm, pack_info& info, bool save);
205205
206206 // Methods that are worthy of inlining.
207207
208-inline object add_ii (interpreter *__interp, object __x, object __y)
208+inline object add_ii (interpreter *interp, object x, object y)
209209 {
210- intptr_t __r = (intptr_t)as_int (__x) + as_int (__y);
211- return (intobj (__interp, __r));
212-}
213-
214-inline object sub_ii (interpreter *__interp, object __x, object __y)
215-{
216- intptr_t __r = (intptr_t)as_int (__x) - as_int (__y);
217- return (intobj (__interp, __r));
210+ intptr_t r = (intptr_t)as_int (x) + as_int (y);
211+ return (intobj (interp, r));
218212 }
219213
220-inline object neg_i (interpreter *__interp, object __x)
214+inline object sub_ii (interpreter *interp, object x, object y)
221215 {
222- intptr_t __r = -(intptr_t)as_int (__x);
223- return (intobj (__interp, __r));
216+ intptr_t r = (intptr_t)as_int (x) - as_int (y);
217+ return (intobj (interp, r));
224218 }
225219
226-inline object not_i (interpreter *__interp, object __x)
220+inline object neg_i (interpreter *interp, object x)
221+{
222+ intptr_t r = -(intptr_t)as_int (x);
223+ return (intobj (interp, r));
224+}
225+
226+inline object not_i (interpreter *interp, object x)
227227 {
228228 #ifdef QP_ARCH_WIDE
229- return (__interp->retval = __x ^ 0xffffffffu);
229+ qp_return (x ^ 0xffffffffu);
230230 #else
231- return (__interp->retval = __x ^ (0xffffffffu & ~7));
231+ qp_return (x ^ (0xffffffffu & ~7));
232232 #endif
233233 }
234234
235-inline object mul_ii (interpreter *__interp, object __x, object __y)
235+inline object mul_ii (interpreter *interp, object x, object y)
236236 {
237- int64_t __q = (int64_t)as_int (__x) * as_int (__y);
238- return (intobj (__interp, __q));
239-}
240-
241-inline object land_ii (interpreter *__interp, object __x, object __y)
242-{
243- return (__interp->retval = __x & __y);
237+ int64_t q = (int64_t)as_int (x) * as_int (y);
238+ return (intobj (interp, q));
244239 }
245240
246-inline object lor_ii (interpreter *__interp, object __x, object __y)
241+inline object land_ii (interpreter *interp, object x, object y)
247242 {
248- return (__interp->retval = __x | __y);
243+ qp_return (x & y);
249244 }
250245
251-inline object xor_ii (interpreter *__interp, object __x, object __y)
246+inline object lor_ii (interpreter *interp, object x, object y)
252247 {
253- return (__interp->retval = __x ^ __y);
248+ qp_return (x | y);
254249 }
255250
256-inline object cmp_ii (interpreter *, object __x, object __y)
251+inline object xor_ii (interpreter *interp, object x, object y)
257252 {
258- int __v1 = as_int (__x), __v2 = as_int (__y);
259- return (__v1 < __v2 ? -1 : __v1 > __v2);
253+ qp_return (x ^ y);
260254 }
261255
262-inline object hash_i (interpreter *, object __x)
256+inline object cmp_ii (interpreter *, object x, object y)
263257 {
264- return ((uint32_t)as_int (__x));
258+ int v1 = as_int (x), v2 = as_int (y);
259+ return (v1 < v2 ? -1 : v1 > v2);
260+}
261+
262+inline object hash_i (interpreter *, object x)
263+{
264+ return ((uint32_t)as_int (x));
265265 }
266266
267267 QP_DECLS_END
diff -r cee131b9ae2c -r ebca8eb602d8 interp.h
--- a/interp.h Thu Mar 26 22:26:35 2020 -0300
+++ b/interp.h Fri Mar 27 00:10:43 2020 -0300
@@ -31,19 +31,19 @@
3131 interpreter *interp = nullptr;
3232 dlist link;
3333
34- interp_hook (unsigned int __tp,
35- void (*__cb) (interpreter *, void *), void *__arg = nullptr) :
36- type (__tp), cb (__cb), arg (__arg)
34+ interp_hook (unsigned int tp,
35+ void (*cb) (interpreter *, void *), void *arg = nullptr) :
36+ type (tp), cb (cb), arg (arg)
3737 {
3838 }
3939
40- bool attach (interpreter *__interp);
40+ bool attach (interpreter *interp);
4141
4242 bool detach ();
4343
44- void call (interpreter *__interp)
44+ void call (interpreter *interp)
4545 {
46- this->cb (__interp, this->arg);
46+ this->cb (interp, this->arg);
4747 }
4848
4949 ~interp_hook ()
@@ -61,13 +61,13 @@
6161 valref () = delete;
6262 valref (const valref&) = delete;
6363
64- inline valref (interpreter *__interp, object __val);
64+ inline valref (interpreter *interp, object val);
6565
66- valref (valref&& __right)
66+ valref (valref&& right)
6767 {
68- this->link = __right.link;
69- this->value = __right.value;
70- __right.link.init_head ();
68+ this->link = right.link;
69+ this->value = right.value;
70+ right.link.init_head ();
7171 }
7272
7373 object& operator* ()
@@ -157,12 +157,12 @@
157157 this->exc_raised = false;
158158 }
159159
160- void growstk (uint32_t __off);
160+ void growstk (uint32_t off);
161161
162- object* push (object __elem)
162+ object* push (object elem)
163163 {
164164 this->growstk (1);
165- *this->stkend++ = __elem;
165+ *this->stkend++ = elem;
166166 return (this->stkend - 1);
167167 }
168168
@@ -176,9 +176,9 @@
176176 return ((uint32_t)(this->stkend - this->stack));
177177 }
178178
179- void popn (uint32_t __n = 1)
179+ void popn (uint32_t n = 1)
180180 {
181- this->stkend -= __n;
181+ this->stkend -= n;
182182 }
183183
184184 object stktop () const
@@ -186,14 +186,14 @@
186186 return (*(this->stkend - 1));
187187 }
188188
189- void* talloc (size_t __size);
189+ void* talloc (size_t size);
190190
191- void do_call_hooks (unsigned int __type, unsigned int __n);
192- void call_hooks (unsigned int __type)
191+ void do_call_hooks (unsigned int type, unsigned int n);
192+ void call_hooks (unsigned int type)
193193 {
194- unsigned int __n = this->num_hooks[__type];
195- if (qp_unlikely (__n))
196- this->do_call_hooks (__type, __n);
194+ unsigned int n = this->num_hooks[type];
195+ if (qp_unlikely (n))
196+ this->do_call_hooks (type, n);
197197 }
198198
199199 #ifdef QP_NO_THREADS
@@ -213,8 +213,8 @@
213213
214214 #else
215215 bool lock ();
216- void unlock (bool __release = true);
217- bool lock_remote (interpreter *__interp);
216+ void unlock (bool release = true);
217+ bool lock_remote (interpreter *interp);
218218 #endif
219219
220220 void begin_blocking ();
@@ -251,9 +251,9 @@
251251 return (interpreter::self_interp);
252252 }
253253
254- static void set_self (interpreter *__interp)
254+ static void set_self (interpreter *interp)
255255 {
256- interpreter::self_interp = __interp;
256+ interpreter::self_interp = interp;
257257 }
258258
259259 sync_event*& sync_ev ()
@@ -265,39 +265,39 @@
265265
266266 object caller () const;
267267
268- void cleanup_talloc (interp_tbuf *__cbp);
268+ void cleanup_talloc (interp_tbuf *cbp);
269269
270270 uint32_t xrand ();
271271
272- void nargs_msg (char *__buf, int __size,
273- int __min_argc, int __max_argc, int __passed);
274-
275- [[noreturn]] void raise (object __exception);
276-
277- [[noreturn]] void raise (const char *__exctype, const char *__msg);
272+ void nargs_msg (char *buf, int size,
273+ int min_argc, int max_argc, int passed);
278274
279- [[noreturn]] void raise (const char *__exctype, object __msg);
280-
281- [[noreturn]] void raise_nargs (int __min, int __max, int __passed);
275+ [[noreturn]] void raise (object exception);
282276
283- [[noreturn]] void raise_nargs (object __name,
284- int __min, int __max, int __passed);
277+ [[noreturn]] void raise (const char *exctype, const char *msg);
285278
286- [[noreturn]] void raise_oob (int __idx, int __max);
279+ [[noreturn]] void raise (const char *exctype, object msg);
280+
281+ [[noreturn]] void raise_nargs (int min, int max, int passed);
282+
283+ [[noreturn]] void raise_nargs (object name,
284+ int min, int max, int passed);
285+
286+ [[noreturn]] void raise_oob (int idx, int max);
287287
288288 [[noreturn]] void raise_const ();
289289
290290 bool exc_handle (void);
291291
292- void push_frame (object __env, int __nargs, int __off);
292+ void push_frame (object env, int nargs, int off);
293293
294- object dbind (object __sym, object __value);
295- void unbind (uint32_t __n);
296- void unbind (uint32_t __n, object __gen);
294+ object dbind (object sym, object value);
295+ void unbind (uint32_t n);
296+ void unbind (uint32_t n, object gen);
297297
298- object stacktrace (uint32_t __frame);
298+ object stacktrace (uint32_t frame);
299299
300- void set_ev (unsigned int __ev);
300+ void set_ev (unsigned int ev);
301301 void do_handle_evs ();
302302
303303 void handle_evs ()
@@ -316,14 +316,14 @@
316316
317317 virtual void call (interpreter *) = 0;
318318
319- static void hook_cb (interpreter *__interp, void *__arg)
319+ static void hook_cb (interpreter *interp, void *arg)
320320 {
321- ((hook *)__arg)->call (__interp);
321+ ((hook *)arg)->call (interp);
322322 }
323323
324- bool attach (interpreter *__interp)
324+ bool attach (interpreter *interp)
325325 {
326- return (this->base.attach (__interp));
326+ return (this->base.attach (interp));
327327 }
328328
329329 bool detach ()
@@ -331,7 +331,7 @@
331331 return (this->base.detach ());
332332 }
333333
334- hook (unsigned int __tp) : base (__tp, hook_cb, this) {}
334+ hook (unsigned int tp) : base (tp, hook_cb, this) {}
335335 };
336336 };
337337
@@ -343,10 +343,10 @@
343343 int stkrem;
344344 #endif
345345
346- talloc_cleanup (interpreter *__ip) :
347- interp (__ip), tbp (__ip->tbuf)
346+ talloc_cleanup (interpreter *ip) :
347+ interp (ip), tbp (ip->tbuf)
348348 #ifdef QP_HAS_ALLOCA
349- , stkrem (__ip->stkrem)
349+ , stkrem (ip->stkrem)
350350 #endif
351351 {}
352352
@@ -380,12 +380,12 @@
380380 {
381381 bool *swap;
382382
383- evh_guard (interpreter *__interp)
383+ evh_guard (interpreter *interp)
384384 {
385- if (__interp->evh_active)
385+ if (interp->evh_active)
386386 {
387- *(this->swap = &__interp->evh_active) = false;
388- __interp->handle_evs ();
387+ *(this->swap = &interp->evh_active) = false;
388+ interp->handle_evs ();
389389 }
390390 else
391391 this->swap = nullptr;
@@ -409,8 +409,8 @@
409409 {
410410 uint32_t *cntp;
411411
412- local_gc_guard (interpreter *__interp) :
413- evh_guard (__interp), cntp (&__interp->gc_sem)
412+ local_gc_guard (interpreter *interp) :
413+ evh_guard (interp), cntp (&interp->gc_sem)
414414 {
415415 ++*this->cntp;
416416 }
@@ -435,12 +435,12 @@
435435 interpreter *interp;
436436 uint32_t sp;
437437
438- sp_guard (interpreter *__interp, uint32_t __sp) :
439- interp (__interp), sp (__sp)
438+ sp_guard (interpreter *interp, uint32_t sp) :
439+ interp (interp), sp (sp)
440440 {
441441 }
442442
443- sp_guard (interpreter *__interp) : sp_guard (__interp, __interp->stklen ())
443+ sp_guard (interpreter *interp) : sp_guard (interp, interp->stklen ())
444444 {
445445 }
446446
@@ -456,9 +456,9 @@
456456 uint32_t cf;
457457 uint32_t eoff;
458458
459- call_guard (interpreter *__interp, uint32_t __spadj = 0) :
460- sp_guard (__interp, __interp->stklen () - __spadj),
461- cf (__interp->cur_frame), eoff (__interp->exc_offset)
459+ call_guard (interpreter *interp, uint32_t spadj = 0) :
460+ sp_guard (interp, interp->stklen () - spadj),
461+ cf (interp->cur_frame), eoff (interp->exc_offset)
462462 {
463463 }
464464
diff -r cee131b9ae2c -r ebca8eb602d8 io.h
--- a/io.h Thu Mar 26 22:26:35 2020 -0300
+++ b/io.h Fri Mar 27 00:10:43 2020 -0300
@@ -30,7 +30,7 @@
3030 bool unquoted = false;
3131 package *ipkg;
3232
33- reader (interpreter *__interp, object __input, package *__ipkg = nullptr);
33+ reader (interpreter *interp, object input, package *ipkg = nullptr);
3434
3535 bool readable_p () const
3636 {
@@ -38,27 +38,27 @@
3838 }
3939
4040 void take ();
41- void handle_sym (object __pkg, object __name);
41+ void handle_sym (object pkg, object name);
4242
43- bool read_token (schar& __ch, int __digs);
43+ bool read_token (schar& ch, int digs);
4444
4545 void expand ();
4646
47- object getlbl (object __label) const;
48- object* putlbl (object __label);
47+ object getlbl (object label) const;
48+ object* putlbl (object label);
4949
50- bool nextc (schar& __ch);
51- void push_ch (const schar& __ch);
50+ bool nextc (schar& ch);
51+ void push_ch (const schar& ch);
5252 uint32_t peek ();
5353
5454 object read_sexpr ();
55- object read_sexpr (object __label);
56- object read_list (object __label);
57- object read_bq (object __label);
58- object read_comma (object __label);
59- object read_array (object __label);
60- object read_table (object __label);
61- object read_tuple (object __label);
55+ object read_sexpr (object label);
56+ object read_list (object label);
57+ object read_bq (object label);
58+ object read_comma (object label);
59+ object read_array (object label);
60+ object read_table (object label);
61+ object read_tuple (object label);
6262 object read_bvector ();
6363 object read_str ();
6464 object read_char ();
@@ -66,18 +66,18 @@
6666 ~reader ();
6767 };
6868
69-QP_EXPORT object expand_str (interpreter *__interp, object __str);
69+QP_EXPORT object expand_str (interpreter *interp, object str);
7070
71-QP_EXPORT object expand_bq (interpreter *__interp, object __form);
71+QP_EXPORT object expand_bq (interpreter *interp, object form);
7272
73-QP_EXPORT int xwrite (interpreter *__interp, stream *__strm,
74- object __obj, io_info& __info);
73+QP_EXPORT int xwrite (interpreter *interp, stream *strm,
74+ object obj, io_info& info);
7575
7676 inline int
77-xwrite (interpreter *__interp, stream *__strm, object __obj)
77+xwrite (interpreter *interp, stream *strm, object obj)
7878 {
79- io_info __info;
80- return (xwrite (__interp, __strm, __obj, __info));
79+ io_info info;
80+ return (xwrite (interp, strm, obj, info));
8181 }
8282
8383 template <class ...Args>
@@ -86,22 +86,22 @@
8686 local_varobj<string> sf;
8787 callvec<Args...> xargs;
8888
89- sprintf_args (const char *__fmt, Args... __args) : xargs (__args...)
89+ sprintf_args (const char *fmt, Args... args) : xargs (args...)
9090 {
91- this->sf.local_init (__fmt);
91+ this->sf.local_init (fmt);
9292 }
9393
94- uint32_t operator() (interpreter *__interp)
94+ uint32_t operator() (interpreter *interp)
9595 {
96- __interp->push (this->sf.as_obj ());
97- return (1 + this->xargs (__interp));
96+ interp->push (this->sf.as_obj ());
97+ return (1 + this->xargs (interp));
9898 }
9999 };
100100
101101 template <class ...Args>
102-sprintf_args<Args...> make_sprintf_args (const char *__fmt, Args... __args)
102+sprintf_args<Args...> make_sprintf_args (const char *fmt, Args... args)
103103 {
104- return (sprintf_args<Args...> (__fmt, __args...));
104+ return (sprintf_args<Args...> (fmt, args...));
105105 }
106106
107107 #define QP_SPRINTF(Interp, ...) \
@@ -135,9 +135,9 @@
135135
136136 uint32_t size () const;
137137 object* data ();
138- pack_cache (interpreter *__interp);
139- object get (interpreter *__interp, object __key);
140- void put (interpreter *__interp, object __key, object __val);
138+ pack_cache (interpreter *interp);
139+ object get (interpreter *interp, object key);
140+ void put (interpreter *interp, object key, object val);
141141 };
142142
143143 struct pack_info
@@ -148,11 +148,11 @@
148148 pack_cache *cache;
149149 stream *bstream;
150150
151- pack_info (interpreter *__interp, bool __cache);
151+ pack_info (interpreter *interp, bool cache);
152152
153- void add_mapping (interpreter *__interp, object __key, object __val);
154- object get (interpreter *__interp, object __obj);
155- void touch (interpreter *__interp, int __offset);
153+ void add_mapping (interpreter *interp, object key, object val);
154+ object get (interpreter *interp, object obj);
155+ void touch (interpreter *interp, int offset);
156156
157157 ~pack_info ()
158158 {
@@ -164,10 +164,10 @@
164164 {
165165 bool *oldp;
166166
167- eviction_guard (pack_info& __info, bool __use)
167+ eviction_guard (pack_info& info, bool use)
168168 {
169- if (__use && __info.cache->evict)
170- *(this->oldp = &__info.cache->evict) = false;
169+ if (use && info.cache->evict)
170+ *(this->oldp = &info.cache->evict) = false;
171171 else
172172 this->oldp = nullptr;
173173 }
@@ -180,32 +180,32 @@
180180 };
181181 };
182182
183-QP_EXPORT int64_t xpack (interpreter *__interp, stream *__strm,
184- object __obj, pack_info& __info);
183+QP_EXPORT int64_t xpack (interpreter *interp, stream *strm,
184+ object obj, pack_info& info);
185185
186-QP_EXPORT int64_t xpack (interpreter *__interp, stream *__strm,
187- object __obj, object *__map, size_t __nmap);
186+QP_EXPORT int64_t xpack (interpreter *interp, stream *strm,
187+ object obj, object *map, size_t nmap);
188188
189189 template <class ...Args>
190-inline int64_t xpack_with (interpreter *__interp, stream *__strm,
191- object __obj, Args... __args)
190+inline int64_t xpack_with (interpreter *interp, stream *strm,
191+ object obj, Args... args)
192192 {
193- object __tmp[] = { __args..., 0 };
194- return (xpack (__interp, __strm, __obj, __tmp, QP_NELEM (__tmp) - 1));
193+ object tmp[] = { args..., 0 };
194+ return (xpack (interp, strm, obj, tmp, QP_NELEM (tmp) - 1));
195195 }
196196
197-inline int64_t xpack (interpreter *__interp, stream *__strm, object __obj)
197+inline int64_t xpack (interpreter *interp, stream *strm, object obj)
198198 {
199- return (xpack (__interp, __strm, __obj, nullptr, 0));
199+ return (xpack (interp, strm, obj, nullptr, 0));
200200 }
201201
202-QP_EXPORT object xunpack (interpreter *__interp,
203- stream *__strm, pack_info& __info);
202+QP_EXPORT object xunpack (interpreter *interp,
203+ stream *strm, pack_info& info);
204204
205-inline object xunpack (interpreter *__interp, stream *__strm)
205+inline object xunpack (interpreter *interp, stream *strm)
206206 {
207- pack_info __info { __interp, false };
208- return (xunpack (__interp, __strm, __info));
207+ pack_info info { interp, false };
208+ return (xunpack (interp, strm, info));
209209 }
210210
211211 QP_EXPORT init_op init_io;
diff -r cee131b9ae2c -r ebca8eb602d8 memory.h
--- a/memory.h Thu Mar 26 22:26:35 2020 -0300
+++ b/memory.h Fri Mar 27 00:10:43 2020 -0300
@@ -8,33 +8,33 @@
88
99 /* Allocate a block of SIZE bytes, aligned for any type necessary.
1010 * Does NOT register the block (i.e: It wont' be visible to the GC). */
11-QP_EXPORT void* xmalloc (size_t __size);
11+QP_EXPORT void* xmalloc (size_t size);
1212
1313 /* Reallocate a memory block for NSIZE bytes. Like above, this function
1414 * won't make the resulting block GC-visible. */
15-QP_EXPORT void* xrealloc (void *__ptr, size_t __nsize);
15+QP_EXPORT void* xrealloc (void *ptr, size_t nsize);
1616
1717 /* Allocate a varobject, given SIZE, TYPE and MASK, filling the
1818 * header with such data. Does not register the header. */
19-QP_EXPORT void* alloch (size_t __size, int __type, int __mask = TYPE_SHIFT);
19+QP_EXPORT void* alloch (size_t size, int type, int mask = TYPE_SHIFT);
2020
2121 template <class T>
22-T* alloch (int __mask = TYPE_SHIFT)
22+T* alloch (int mask = TYPE_SHIFT)
2323 {
24- return ((T *)alloch (sizeof (T), T::code, __mask));
24+ return ((T *)alloch (sizeof (T), T::code, mask));
2525 }
2626
2727 // Deallocate memory for PTR. Does not unregister the object.
28-QP_EXPORT void xfree (void *__ptr);
28+QP_EXPORT void xfree (void *ptr);
2929
3030 // Register a varobj of SIZE bytes, thus making it visible to the GC.
31-QP_EXPORT void gc_register (interpreter *__interp,
32- varobj *__ptr, size_t __size);
31+QP_EXPORT void gc_register (interpreter *interp,
32+ varobj *ptr, size_t size);
3333
3434 template <class T>
35-void gc_register (interpreter *__interp, T *__ptr)
35+void gc_register (interpreter *interp, T *ptr)
3636 {
37- gc_register (__interp, __ptr, sizeof (*__ptr));
37+ gc_register (interp, ptr, sizeof (*ptr));
3838 }
3939
4040 // Handler for the GC request event.
@@ -44,10 +44,10 @@
4444 QP_EXPORT memmgr* memmgr_alloc ();
4545
4646 // Recycle a memory manager.
47-QP_EXPORT void memmgr_free (memmgr *__mgrp);
47+QP_EXPORT void memmgr_free (memmgr *mgrp);
4848
4949 // Raise an out-of-memory error.
50-[[noreturn]] QP_EXPORT void raise_oom (interpreter *__interp = nullptr);
50+[[noreturn]] QP_EXPORT void raise_oom (interpreter *interp = nullptr);
5151
5252 // Acquire the GC lock.
5353 QP_EXPORT void gc_lock (interpreter *interp);
@@ -58,17 +58,17 @@
5858 inline bool
5959 gc_enable ()
6060 {
61- bool __ret = gc_status ();
61+ bool ret = gc_status ();
6262 gc_status() = true;
63- return (__ret);
63+ return (ret);
6464 }
6565
6666 inline bool
6767 gc_disable ()
6868 {
69- bool __ret = gc_status ();
69+ bool ret = gc_status ();
7070 gc_status() = false;
71- return (__ret);
71+ return (ret);
7272 }
7373
7474 struct gc_guard
@@ -90,11 +90,10 @@
9090 QP_EXPORT void gc_unlock ();
9191
9292 // Perform a garbage collection. Collect all generations if FULL is true.
93-QP_EXPORT void gc (bool __full);
93+QP_EXPORT void gc (bool full);
9494
9595 // Generate a write barrier for object OBJ contained in PARENT.
96-QP_EXPORT void gc_wbarrier (interpreter *__interp,
97- object __parent, object __obj);
96+QP_EXPORT void gc_wbarrier (interpreter *interp, object parent, object obj);
9897
9998 // Initialize the memory subsystem.
10099 QP_EXPORT bool memory_init ();
diff -r cee131b9ae2c -r ebca8eb602d8 quipu.h
--- a/quipu.h Thu Mar 26 22:26:35 2020 -0300
+++ b/quipu.h Fri Mar 27 00:10:43 2020 -0300
@@ -31,9 +31,9 @@
3131 typedef T* type;
3232 static const int code = T::code;
3333
34- static inline type get (object __obj)
34+ static inline type get (object obj)
3535 {
36- return ((type)unmask (__obj));
36+ return ((type)unmask (obj));
3737 }
3838 };
3939
@@ -43,9 +43,9 @@
4343 typedef int type;
4444 static const int code = typecode::INT;
4545
46- static inline type get (object __obj)
46+ static inline type get (object obj)
4747 {
48- return (as_int (__obj));
48+ return (as_int (obj));
4949 }
5050 };
5151
@@ -55,9 +55,9 @@
5555 typedef uint32_t type;
5656 static const int code = typecode::CHAR;
5757
58- static inline type get (object __obj)
58+ static inline type get (object obj)
5959 {
60- return (as_char (__obj));
60+ return (as_char (obj));
6161 }
6262 };
6363
@@ -67,39 +67,39 @@
6767 typedef double type;
6868 static const int code = typecode::FLOAT;
6969
70- static inline type get (object __obj)
70+ static inline type get (object obj)
7171 {
72- return (as_float (__obj));
72+ return (as_float (obj));
7373 }
7474 };
7575
7676 template <class T>
77-typename objtype<T>::type as (object __obj, bool& __got)
77+typename objtype<T>::type as (object obj, bool& got)
7878 {
79- int __tx = objtype<T>::code, __itp = itype (__obj);
79+ int tx = objtype<T>::code, itp = itype (obj);
8080
81- __got = true;
82- if (__tx == __itp || (__tx == typecode::BVECTOR && __itp == typecode::STR))
83- return (objtype<T>::get (__obj));
84- else if (__itp == typecode::INSTANCE)
81+ got = true;
82+ if (tx == itp || (tx == typecode::BVECTOR && itp == typecode::STR))
83+ return (objtype<T>::get (obj));
84+ else if (itp == typecode::INSTANCE)
8585 {
86- object __tmp = builtin_member (__obj);
87- __itp = itype (__tmp);
86+ object tmp = builtin_member (obj);
87+ itp = itype (tmp);
8888
89- if (__tx == __itp ||
90- (__tx == typecode::BVECTOR && __itp == typecode::STR))
91- return (objtype<T>::get (__tmp));
89+ if (tx == itp ||
90+ (tx == typecode::BVECTOR && itp == typecode::STR))
91+ return (objtype<T>::get (tmp));
9292 }
9393
94- __got = false;
94+ got = false;
9595 return (typename objtype<T>::type ());
9696 }
9797
9898 template <class T>
99-typename objtype<T>::type as (object __obj)
99+typename objtype<T>::type as (object obj)
100100 {
101- bool __dummy;
102- return (as<T> (__obj, __dummy));
101+ bool dummy;
102+ return (as<T> (obj, dummy));
103103 }
104104
105105 QP_DECLS_END
diff -r cee131b9ae2c -r ebca8eb602d8 str.h
--- a/str.h Thu Mar 26 22:26:35 2020 -0300
+++ b/str.h Fri Mar 27 00:10:43 2020 -0300
@@ -15,12 +15,12 @@
1515 uint32_t len;
1616 uint32_t hval;
1717
18- static object make (interpreter *__interp, const char *__s);
19- static object make (interpreter *__interp, const char *__s, uint32_t __len);
20- static string* alloc_raw (uint32_t __nb);
18+ static object make (interpreter *interp, const char *s);
19+ static object make (interpreter *interp, const char *s, uint32_t len);
20+ static string* alloc_raw (uint32_t nb);
2121
22- inline void local_init (const void *__ptr);
23- inline void local_init (const void *__ptr, uint32_t __nbytes);
22+ inline void local_init (const void *ptr);
23+ inline void local_init (const void *ptr, uint32_t nbytes);
2424 };
2525
2626 // Max value for a character (as a UTF-32 codepoint).
@@ -28,88 +28,88 @@
2828
2929 #ifdef QP_ARCH_WIDE
3030
31-inline constexpr object charobj (uint32_t __ch)
31+inline constexpr object charobj (uint32_t ch)
3232 {
33- return (ptrtype ((object)(uint32_t)__ch, typecode::CHAR));
33+ return (ptrtype ((object)(uint32_t)ch, typecode::CHAR));
3434 }
3535
36-inline constexpr bool char_p (object __obj)
36+inline constexpr bool char_p (object obj)
3737 {
38- return (itype (__obj) == typecode::CHAR);
38+ return (itype (obj) == typecode::CHAR);
3939 }
4040
41-inline constexpr uint32_t as_char (object __obj)
41+inline constexpr uint32_t as_char (object obj)
4242 {
43- return ((uint32_t)(__obj & 0xffffffffu));
43+ return ((uint32_t)(obj & 0xffffffffu));
4444 }
4545
4646 #else
4747
48-inline constexpr object charobj (uint32_t __ch)
48+inline constexpr object charobj (uint32_t ch)
4949 {
50- return ((__ch << 3) | 1);
50+ return ((ch << 3) | 1);
5151 }
5252
53-inline constexpr uint32_t as_char (object __obj)
53+inline constexpr uint32_t as_char (object obj)
5454 {
55- return ((uint32_t)(__obj >> 3));
55+ return ((uint32_t)(obj >> 3));
5656 }
5757
58-inline constexpr bool char_p (object __obj)
58+inline constexpr bool char_p (object obj)
5959 {
60- return ((__obj & 3) == 1 && as_char (__obj) <= MAX_CHAR);
60+ return ((obj & 3) == 1 && as_char (obj) <= MAX_CHAR);
6161 }
6262
6363 #endif
6464
65-inline string* as_str (object __obj)
65+inline string* as_str (object obj)
6666 {
67- return ((string *)unmask (__obj));
67+ return ((string *)unmask (obj));
6868 }
6969
7070
7171 #ifdef QP_ARCH_WIDE
7272
73-inline constexpr bool str_p (object __obj)
73+inline constexpr bool str_p (object obj)
7474 {
75- return (itype (__obj) == typecode::STR);
75+ return (itype (obj) == typecode::STR);
7676 }
7777
7878 #else
7979
80-inline bool str_p (object __obj)
80+inline bool str_p (object obj)
8181 {
82- return (varobj_p (__obj) && as_varobj(__obj)->vo_type == typecode::STR);
82+ return (varobj_p (obj) && as_varobj(obj)->vo_type == typecode::STR);
8383 }
8484
8585 #endif
8686
8787 inline uint32_t
88-len_s (object __obj)
88+len_s (object obj)
8989 {
90- return (as_str(__obj)->len);
90+ return (as_str(obj)->len);
9191 }
9292
93-inline char* fscpy (void *__dstp, const void *__srcp, int __n)
93+inline char* fscpy (void *dstp, const void *srcp, int n)
9494 {
95- char *__retp = (char *)__dstp;
96- const char *__sp = (const char *)__srcp;
95+ char *retp = (char *)dstp;
96+ const char *sp = (const char *)srcp;
9797
98- switch (__n)
98+ switch (n)
9999 {
100- case 4: *__retp++ = *__sp++;
101- case 3: *__retp++ = *__sp++;
102- case 2: *__retp++ = *__sp++;
103- case 1: *__retp++ = *__sp++;
100+ case 4: *retp++ = *sp++;
101+ case 3: *retp++ = *sp++;
102+ case 2: *retp++ = *sp++;
103+ case 1: *retp++ = *sp++;
104104 }
105105
106- return (__retp);
106+ return (retp);
107107 }
108108
109109 inline const char*
110-str_cdata (object __str)
110+str_cdata (object str)
111111 {
112- return ((const char *)as_str(__str)->data);
112+ return ((const char *)as_str(str)->data);
113113 }
114114
115115 struct stream;
@@ -117,126 +117,121 @@
117117 struct pack_info;
118118
119119 // Allocate a string with room for NBYTES bytes.
120-QP_EXPORT object alloc_str (interpreter *__interp, uint32_t __nbytes);
120+QP_EXPORT object alloc_str (interpreter *interp, uint32_t nbytes);
121121
122122 // Index a string.
123-QP_EXPORT object get_s (interpreter *__interp,
124- object __str, object __idx, object __dfl);
123+QP_EXPORT object get_s (interpreter *interp,
124+ object str, object idx, object dfl);
125125
126126 // Get the subsequence of a string.
127-QP_EXPORT object subseq_s (interpreter *__interp,
128- object __str, object __i1, object __i2);
127+QP_EXPORT object subseq_s (interpreter *interp,
128+ object str, object i1, object i2);
129129
130130 // Write a string to a stream.
131-QP_EXPORT int write_s (interpreter *__interp,
132- stream *__strm, object __obj, io_info& __info);
131+QP_EXPORT int write_s (interpreter *interp,
132+ stream *strm, object obj, io_info& info);
133133
134134 // Write a character to a stream.
135-QP_EXPORT int write_c (interpreter *__interp,
136- stream *__strm, object __obj, io_info& __info);
135+QP_EXPORT int write_c (interpreter *interp,
136+ stream *strm, object obj, io_info& info);
137137
138138 // Serialize a string in a stream.
139-QP_EXPORT int64_t pack_s (interpreter *__interp,
140- stream *__strm, object __obj, pack_info& __info);
139+QP_EXPORT int64_t pack_s (interpreter *interp,
140+ stream *strm, object obj, pack_info& info);
141141
142142 // Serialize a character in a stream.
143-QP_EXPORT int64_t pack_c (interpreter *__interp,
144- stream *__strm, object __obj, pack_info& __info);
143+QP_EXPORT int64_t pack_c (interpreter *interp,
144+ stream *strm, object obj, pack_info& info);
145145
146146 // Deserialize a string from a stream.
147-QP_EXPORT object unpack_s (interpreter *__interp,
148- stream *__strm, pack_info& __info, bool __save);
147+QP_EXPORT object unpack_s (interpreter *interp,
148+ stream *strm, pack_info& info, bool save);
149149
150150 // Deserialize a character from a stream.
151-QP_EXPORT object unpack_c (interpreter *__interp,
152- stream *__strm, pack_info& __info, bool __save);
151+QP_EXPORT object unpack_c (interpreter *interp,
152+ stream *strm, pack_info& info, bool save);
153153
154154 // Concatenate strings STR1 and STR2.
155-QP_EXPORT object add_ss (interpreter *__interp,
156- object __str1, object __str2);
155+QP_EXPORT object add_ss (interpreter *interp,
156+ object str1, object str2);
157157
158158 // Concatenate ARGC strings in ARGV.
159-QP_EXPORT object concat_s (interpreter *__interp, object *__argv, int __argc);
159+QP_EXPORT object concat_s (interpreter *interp, object *argv, int argc);
160160
161161 // Add a character to a string.
162-QP_EXPORT object add_sc (interpreter *__interp,
163- object __str, object __char);
162+QP_EXPORT object add_sc (interpreter *interp, object str, object chr);
164163
165164 // Add a string to a character.
166-QP_EXPORT object add_cs (interpreter *__interp,
167- object __char, object __str);
165+QP_EXPORT object add_cs (interpreter *interp, object chr, object str);
168166
169167 // Add 2 characters together.
170-QP_EXPORT object add_cc (interpreter *__interp,
171- object __ch1, object __ch2);
168+QP_EXPORT object add_cc (interpreter *interp, object ch1, object ch2);
172169
173170 // Multiply a character with an integer.
174-QP_EXPORT object mul_ic (interpreter *__interp,
175- object __ival, object __ch);
171+QP_EXPORT object mul_ic (interpreter *interp, object ival, object ch);
176172
177173 // Multiply a string with an integer.
178-QP_EXPORT object mul_is (interpreter *__interp,
179- object __ival, object __str);
174+QP_EXPORT object mul_is (interpreter *interp, object ival, object str);
180175
181176 // Compute the hashcode of a string.
182-QP_EXPORT uint32_t hash_s (interpreter *__interp, object __obj);
177+QP_EXPORT uint32_t hash_s (interpreter *interp, object obj);
183178
184179 // Reverse a string.
185-QP_EXPORT object reverse_s (interpreter *__interp, object __obj);
180+QP_EXPORT object reverse_s (interpreter *interp, object obj);
186181
187182 // Iterator interface for strings.
188-QP_EXPORT object iter_s (interpreter *__interp, object __obj,
189- object __token, bool __adv);
183+QP_EXPORT object iter_s (interpreter *interp,
184+ object obj, object token, bool adv);
190185
191186 // Get the last character of a string.
192-QP_EXPORT object last_s (interpreter *__interp, object __obj);
187+QP_EXPORT object last_s (interpreter *interp, object obj);
193188
194189 // Skip table for UTF-8 code points.
195190 extern const uint8_t UTF8_SKIP[256];
196191
197192 // Return the byte offset for the IDX'th codepoint in string S.
198-QP_EXPORT uint32_t stridx (const string *__s, uint32_t __idx);
193+QP_EXPORT uint32_t stridx (const string *s, uint32_t idx);
199194
200195 // Get the lower bound of bytes that may be advanced for [S .. S + N)
201-QP_EXPORT uint32_t utf8min (const char *__s, uint32_t __n);
196+QP_EXPORT uint32_t utf8min (const char *s, uint32_t n);
202197
203198 // Compute the codepoint length in *LENP and return the byte length of S.
204-QP_EXPORT uint32_t ustrlen (const void *__s, uint32_t *__lenp);
199+QP_EXPORT uint32_t ustrlen (const void *s, uint32_t *lenp);
205200
206201 // Return the codepoint length of [S .. S + BYTES).
207-QP_EXPORT uint32_t ustrnlen (const void *__s, uint32_t __bytes);
202+QP_EXPORT uint32_t ustrnlen (const void *s, uint32_t bytes);
208203
209204 // Convert the UTF-8 encoded bytes in [S .. S + LEN) to a UTF-32 codepoint.
210-QP_EXPORT uint32_t u8tou32 (const unsigned char *__s, uint32_t __len);
205+QP_EXPORT uint32_t u8tou32 (const unsigned char *s, uint32_t len);
211206
212207 // Convert the UTF-32 codepoint CH to a UTF-8 sequence in BUFP.
213-QP_EXPORT uint32_t u32tou8 (unsigned char *__bufp, uint32_t __ch);
208+QP_EXPORT uint32_t u32tou8 (unsigned char *bufp, uint32_t ch);
214209
215210 // Create a stream from string STR.
216-QP_EXPORT stream* strstream (interpreter *__interp, object __str, int __mode);
211+QP_EXPORT stream* strstream (interpreter *interp, object str, int mode);
217212
218213 // Get the string from stream STRM.
219-QP_EXPORT object sstream_get (interpreter *__interp, stream *__strm);
214+QP_EXPORT object sstream_get (interpreter *interp, stream *strm);
220215
221216 // Format the arguments in ARGV[1 .. ARGC) according to ARGV[0].
222-QP_EXPORT object p_fmt_str (interpreter *__interp, object *argv, int argc);
217+QP_EXPORT object p_fmt_str (interpreter *interp, object *argv, int argc);
223218
224219 // Return the readable representation of character CH.
225-QP_EXPORT const char* chobj_repr (uint32_t __ch);
220+QP_EXPORT const char* chobj_repr (uint32_t ch);
226221
227222 // Local initialization methods.
228223
229-void string::local_init (const void *__ptr)
224+void string::local_init (const void *ptr)
230225 {
231- this->data = (unsigned char *)__ptr;
232- this->nbytes = ustrlen (__ptr, &this->len);
226+ this->data = (unsigned char *)ptr;
227+ this->nbytes = ustrlen (ptr, &this->len);
233228 this->hval = 0;
234229 }
235230
236-void string::local_init (const void *__ptr, uint32_t __nbytes)
231+void string::local_init (const void *ptr, uint32_t nbytes)
237232 {
238- this->data = (unsigned char *)__ptr;
239- this->len = ustrnlen (__ptr, this->nbytes = __nbytes);
233+ this->data = (unsigned char *)ptr;
234+ this->len = ustrnlen (ptr, this->nbytes = nbytes);
240235 this->hval = 0;
241236 }
242237
diff -r cee131b9ae2c -r ebca8eb602d8 stream.h
--- a/stream.h Thu Mar 26 22:26:35 2020 -0300
+++ b/stream.h Fri Mar 27 00:10:43 2020 -0300
@@ -154,7 +154,7 @@
154154 }
155155
156156 // Write NB bytes from SRC to the stream.
157- int write (interpreter *interp, const void *__src, uint32_t __nb);
157+ int write (interpreter *interp, const void *src, uint32_t nb);
158158
159159 template <class T>
160160 int write (interpreter *interp, const T *outp)
@@ -163,18 +163,18 @@
163163 }
164164
165165 // Write a single byte into the stream.
166- int putb (interpreter *interp, int __byte);
166+ int putb (interpreter *interp, int byte);
167167
168168 // Write N times BYTE into the stream.
169- int nputb (interpreter *interp, unsigned int __n, int __byte);
169+ int nputb (interpreter *interp, unsigned int n, int byte);
170170
171171 // Write the unicode character CH to the stream.
172- int putuc (interpreter *interp, uint32_t __ch);
172+ int putuc (interpreter *interp, uint32_t ch);
173173
174174 // Write N times the unicode character CH to the stream.
175- int putnuc (interpreter *interp, unsigned int __n, uint32_t __ch);
175+ int putnuc (interpreter *interp, unsigned int n, uint32_t ch);
176176
177- int wbase (interpreter *interp, int __base);
177+ int wbase (interpreter *interp, int base);
178178
179179 // Read a single byte from the stream without advancing the stream pointer.
180180 int peekb (interpreter *interp);
@@ -183,7 +183,7 @@
183183 int getb (interpreter *interp);
184184
185185 // Read at most NB bytes from the stream into DST.
186- int read (interpreter *interp, void *__dst, uint32_t __nb);
186+ int read (interpreter *interp, void *dst, uint32_t nb);
187187
188188 template <class T>
189189 int read (interpreter *interp, T *outp)
@@ -204,10 +204,10 @@
204204 uint32_t getuc (interpreter *interp);
205205
206206 // Unget LEN characters from S from the stream.
207- bool ungetuc (const unsigned char *__s, int __len);
207+ bool ungetuc (const unsigned char *s, int len);
208208
209209 // Move the stream possition according to OFF and WHENCE.
210- bool seek (interpreter *interp, object __off, int __whence);
210+ bool seek (interpreter *interp, object off, int whence);
211211
212212 // Get current stream position.
213213 object tell (interpreter *interp)
@@ -261,14 +261,14 @@
261261 void unlock (interpreter *inter);
262262 };
263263
264-inline stream* as_stream (object __obj)
264+inline stream* as_stream (object obj)
265265 {
266- return ((stream *)unmask (__obj));
266+ return ((stream *)unmask (obj));
267267 }
268268
269-inline bool stream_p (object __obj)
269+inline bool stream_p (object obj)
270270 {
271- return (itype (__obj) == typecode::STREAM);
271+ return (itype (obj) == typecode::STREAM);
272272 }
273273
274274 // Basic buffer size.
@@ -282,8 +282,8 @@
282282 interpreter *interp;
283283 stream *strmp;
284284
285- stream_guard (interpreter *__ip, stream *__s) :
286- interp (__ip), strmp (__s) {}
285+ stream_guard (interpreter *ip, stream *s) :
286+ interp (ip), strmp (s) {}
287287
288288 stream*& operator* ()
289289 {
@@ -367,15 +367,15 @@
367367 #endif
368368 };
369369
370-QP_EXPORT stream* fstream_open (interpreter *__interp,
371- const char *__path, const char *__mode);
370+QP_EXPORT stream* fstream_open (interpreter *interp,
371+ const char *path, const char *mode);
372372
373-QP_EXPORT bool fstream_truncate (interpreter *__interp,
374- stream *__strm, uint64_t __nsize);
373+QP_EXPORT bool fstream_truncate (interpreter *interp,
374+ stream *strm, uint64_t nsize);
375375
376-QP_EXPORT bool fstream_fstat (stream *__strm, fstream_stat& __out);
376+QP_EXPORT bool fstream_fstat (stream *strm, fstream_stat& out);
377377
378-QP_EXPORT char* fstream_path (const char *__path);
378+QP_EXPORT char* fstream_path (const char *path);
379379
380380 // Init OP for streams.
381381 QP_EXPORT init_op init_streams;
diff -r cee131b9ae2c -r ebca8eb602d8 symbol.h
--- a/symbol.h Thu Mar 26 22:26:35 2020 -0300
+++ b/symbol.h Fri Mar 27 00:10:43 2020 -0300
@@ -43,7 +43,7 @@
4343 intptr_t idx;
4444 uintptr_t tl_idx;
4545
46- static object make_kword (interpreter *__interp, const char *__name);
46+ static object make_kword (interpreter *interp, const char *name);
4747
4848 // Some exported symbols.
4949 static object t;
@@ -56,10 +56,10 @@
5656 static const uint32_t N_SPECFORMS = SF_LAST_NO;
5757 static object fast_global_syms[];
5858
59- static int specform_byname (const void *__name, uint32_t __len);
60- static int specform_byname (const void *__name);
59+ static int specform_byname (const void *name, uint32_t len);
60+ static int specform_byname (const void *name);
6161
62- static uintptr_t alloc_tl_idx (interpreter *__interp);
62+ static uintptr_t alloc_tl_idx (interpreter *interp);
6363 };
6464
6565 struct package : public finobj
@@ -80,11 +80,11 @@
8080 valref symtab;
8181 valref cursym;
8282
83- iterator (interpreter *__interp, object __pkg);
83+ iterator (interpreter *interp, object pkg);
8484
85- iterator (interpreter *__interp, uint32_t __i,
86- object __tab, object __sym) : idx (__i),
87- symtab (__interp, __tab), cursym (__interp, __sym)
85+ iterator (interpreter *interp, uint32_t i,
86+ object tab, object sym) : idx (i),
87+ symtab (interp, tab), cursym (interp, sym)
8888 {
8989 }
9090
@@ -93,10 +93,10 @@
9393
9494 iterator operator++ (int)
9595 {
96- iterator __rv { interpreter::self (),
96+ iterator rv { interpreter::self (),
9797 this->idx, *this->symtab, *this->cursym };
9898 ++*this;
99- return (__rv);
99+ return (rv);
100100 }
101101
102102 object operator* () const
@@ -106,155 +106,155 @@
106106 };
107107 };
108108
109-inline symbol* as_symbol (object __obj)
110-{
111- return ((symbol *)unmask (__obj));
112-}
113-
114-inline package* as_package (object __obj)
109+inline symbol* as_symbol (object obj)
115110 {
116- return ((package *)unmask (__obj));
117-}
118-
119-inline object& symname (object __obj)
120-{
121- return (as_symbol(__obj)->name);
122-}
123-
124-inline object& symval (object __obj)
125-{
126- return (as_symbol(__obj)->value);
111+ return ((symbol *)unmask (obj));
127112 }
128113
129-inline object& sympkg (object __obj)
114+inline package* as_package (object obj)
130115 {
131- return (as_symbol(__obj)->pkg);
132-}
133-
134-inline uintptr_t& symtlidx (object __obj)
135-{
136- return (as_symbol(__obj)->tl_idx);
116+ return ((package *)unmask (obj));
137117 }
138118
139-inline object& symval (interpreter *__interp, object __obj)
119+inline object& symname (object obj)
140120 {
141- symbol *__sp = as_symbol (__obj);
142- return (!__sp->tl_idx || __sp->tl_idx >= __interp->n_tlsyms ||
143- __interp->tl_syms[__sp->tl_idx - 1] == UNBOUND ?
144- __sp->value : __interp->tl_syms[__sp->tl_idx - 1]);
121+ return (as_symbol(obj)->name);
145122 }
146123
147-inline bool symbol_p (object __obj)
124+inline object& symval (object obj)
148125 {
149- return (itype (__obj) == typecode::SYMBOL);
126+ return (as_symbol(obj)->value);
150127 }
151128
152-inline bool package_p (object __obj)
129+inline object& sympkg (object obj)
153130 {
154- return (itype (__obj) == typecode::PKG);
131+ return (as_symbol(obj)->pkg);
132+}
133+
134+inline uintptr_t& symtlidx (object obj)
135+{
136+ return (as_symbol(obj)->tl_idx);
137+}
138+
139+inline object& symval (interpreter *interp, object obj)
140+{
141+ symbol *sp = as_symbol (obj);
142+ return (!sp->tl_idx || sp->tl_idx >= interp->n_tlsyms ||
143+ interp->tl_syms[sp->tl_idx - 1] == UNBOUND ?
144+ sp->value : interp->tl_syms[sp->tl_idx - 1]);
145+}
146+
147+inline bool symbol_p (object obj)
148+{
149+ return (itype (obj) == typecode::SYMBOL);
150+}
151+
152+inline bool package_p (object obj)
153+{
154+ return (itype (obj) == typecode::PKG);
155155 }
156156
157157 QP_EXPORT object root_package;
158158 QP_EXPORT object kword_package;
159159
160-inline bool keyword_p (object __obj)
160+inline bool keyword_p (object obj)
161161 {
162- return (symbol_p (__obj) && sympkg (__obj) == kword_package);
162+ return (symbol_p (obj) && sympkg (obj) == kword_package);
163163 }
164164
165-inline bool nksymbol_p (object __obj)
165+inline bool nksymbol_p (object obj)
166166 {
167- return (symbol_p (__obj) && sympkg (__obj) != kword_package);
167+ return (symbol_p (obj) && sympkg (obj) != kword_package);
168168 }
169169
170170 struct stream;
171171 struct io_info;
172172 struct pack_info;
173173
174-QP_EXPORT object alloc_pkg (interpreter *__interp,
175- object __name, bool __bootstrap = false);
176-
177-QP_EXPORT object alloc_pkg (interpreter *__interp,
178- object __name, const char *__path, uint32_t __path_len);
179-
180-QP_EXPORT object alloc_sym (interpreter *__interp, uint32_t __flags = 0);
181-
182-QP_EXPORT object copy_S (interpreter *__interp, object __obj, bool __deep);
183-
184-QP_EXPORT uint32_t hash_S (interpreter *__interp, object __obj);
174+QP_EXPORT object alloc_pkg (interpreter *interp,
175+ object name, bool bootstrap = false);
185176
186-QP_EXPORT uint32_t hash_P (interpreter *__interp, object __obj);
187-
188-QP_EXPORT object find_sym (interpreter *__interp,
189- object __pkg, object __name);
177+QP_EXPORT object alloc_pkg (interpreter *interp,
178+ object name, const char *path, uint32_t path_len);
190179
191-QP_EXPORT object find_sym (interpreter *__interp,
192- object __pkg, const char *__name);
180+QP_EXPORT object alloc_sym (interpreter *interp, uint32_t flags = 0);
193181
194-QP_EXPORT object find_sym (interpreter *__interp,
195- object __pkg, const char *__name, uint32_t __len);
182+QP_EXPORT object copy_S (interpreter *interp, object obj, bool deep);
196183
197-inline object find_sym (interpreter *__interp, const char *__name)
184+QP_EXPORT uint32_t hash_S (interpreter *interp, object obj);
185+
186+QP_EXPORT uint32_t hash_P (interpreter *interp, object obj);
187+
188+QP_EXPORT object find_sym (interpreter *interp,
189+ object pkg, object name);
190+
191+QP_EXPORT object find_sym (interpreter *interp,
192+ object pkg, const char *name);
193+
194+QP_EXPORT object find_sym (interpreter *interp,
195+ object pkg, const char *name, uint32_t len);
196+
197+inline object find_sym (interpreter *interp, const char *name)
198198 {
199- return (find_sym (__interp, root_package, __name));
199+ return (find_sym (interp, root_package, name));
200200 }
201201
202-inline object find_sym (interpreter *__interp,
203- const char *__name, uint32_t __len)
202+inline object find_sym (interpreter *interp,
203+ const char *name, uint32_t len)
204204 {
205- return (find_sym (__interp, root_package, __name, __len));
205+ return (find_sym (interp, root_package, name, len));
206206 }
207207
208-QP_EXPORT object inherit_sym (interpreter *__interp,
209- object __symbol, object __pkg, bool __locked = false);
208+QP_EXPORT object inherit_sym (interpreter *interp,
209+ object symbol, object pkg, bool locked = false);
210210
211211 struct string;
212212 struct reader;
213213
214-QP_EXPORT object intern (interpreter *__interp, const char *__name,
215- uint32_t __len, package *__pkgp = 0, uint32_t __flags = 0);
216-
217-QP_EXPORT object intern (interpreter *__interp,
218- const char *__name, package *__pkgp = 0, uint32_t __flags = 0);
219-
220-QP_EXPORT object intern (interpreter *__interp,
221- const string *__name, package *__pkgp = 0, uint32_t __flags = 0);
222-
223-QP_EXPORT bool undef (interpreter *__interp,
224- const char *__name, uint32_t __len, package *__pkgp = nullptr);
225-
226-QP_EXPORT bool undef (interpreter *__interp, object __sym);
227-
228-QP_EXPORT object get_P (interpreter *__interp,
229- object __pkg, object __key, object __dfl);
214+QP_EXPORT object intern (interpreter *interp, const char *name,
215+ uint32_t len, package *pkgp = 0, uint32_t flags = 0);
230216
231-QP_EXPORT object nput_P (interpreter *__interp,
232- object __pkg, object __key, object __val);
233-
234-QP_EXPORT int write_S (interpreter* __interp,
235- stream *__strm, object __obj, io_info& __info);
236-
237-QP_EXPORT int write_P (interpreter *__interp,
238- stream *__strm, object __obj, io_info& __info);
217+QP_EXPORT object intern (interpreter *interp,
218+ const char *name, package *pkgp = 0, uint32_t flags = 0);
239219
240-QP_EXPORT int64_t pack_S (interpreter *__interp,
241- stream *__strm, object __obj, pack_info& __info);
220+QP_EXPORT object intern (interpreter *interp,
221+ const string *name, package *pkgp = 0, uint32_t flags = 0);
242222
243-QP_EXPORT int64_t pack_P (interpreter *__interp,
244- stream *__strm, object __obj, pack_info& __info);
223+QP_EXPORT bool undef (interpreter *interp,
224+ const char *name, uint32_t len, package *pkgp = nullptr);
245225
246-QP_EXPORT object unpack_S (interpreter *__interp,
247- stream *__strm, pack_info& __info, bool __save);
226+QP_EXPORT bool undef (interpreter *interp, object sym);
248227
249-QP_EXPORT object unpack_P (interpreter *__interp,
250- stream *__strm, pack_info& __info, bool __save);
228+QP_EXPORT object get_P (interpreter *interp,
229+ object pkg, object key, object dfl);
230+
231+QP_EXPORT object nput_P (interpreter *interp,
232+ object pkg, object key, object val);
233+
234+QP_EXPORT int write_S (interpreter* interp,
235+ stream *strm, object obj, io_info& info);
236+
237+QP_EXPORT int write_P (interpreter *interp,
238+ stream *strm, object obj, io_info& info);
239+
240+QP_EXPORT int64_t pack_S (interpreter *interp,
241+ stream *strm, object obj, pack_info& info);
242+
243+QP_EXPORT int64_t pack_P (interpreter *interp,
244+ stream *strm, object obj, pack_info& info);
245+
246+QP_EXPORT object unpack_S (interpreter *interp,
247+ stream *strm, pack_info& info, bool save);
248+
249+QP_EXPORT object unpack_P (interpreter *interp,
250+ stream *strm, pack_info& info, bool save);
251251
252252 QP_EXPORT object gensym (interpreter *interp, object *argv, int argc);
253253
254-QP_EXPORT object compile_pkg (interpreter *__interp, reader& __rd);
254+QP_EXPORT object compile_pkg (interpreter *interp, reader& rd);
255255
256-QP_EXPORT object import_pkg (interpreter *__interp,
257- object __path, object __name = UNBOUND);
256+QP_EXPORT object import_pkg (interpreter *interp,
257+ object path, object name = UNBOUND);
258258
259259 QP_EXPORT object nzap_P (interpreter *interp, object obj, object key,
260260 uint32_t flags, object fn, object *argv, int argc);
diff -r cee131b9ae2c -r ebca8eb602d8 sysdeps/atomic.h
--- a/sysdeps/atomic.h Thu Mar 26 22:26:35 2020 -0300
+++ b/sysdeps/atomic.h Fri Mar 27 00:10:43 2020 -0300
@@ -15,42 +15,42 @@
1515 (__clang_major__ == 3 && __clang_minor__ >= 8)))
1616
1717 inline atomic_t
18-atomic_add (atomic_t *__ptr, atomic_t __val)
18+atomic_add (atomic_t *ptr, atomic_t val)
1919 {
20- return (__atomic_fetch_add (__ptr, __val, __ATOMIC_ACQ_REL));
20+ return (__atomic_fetch_add (ptr, val, __ATOMIC_ACQ_REL));
2121 }
2222
2323 inline atomic_t
24-atomic_cas (atomic_t *__ptr, atomic_t __exp, atomic_t __nval)
24+atomic_cas (atomic_t *ptr, atomic_t exp, atomic_t nval)
2525 {
26- __atomic_compare_exchange_n (__ptr, &__exp, __nval, 0,
26+ __atomic_compare_exchange_n (ptr, &exp, nval, 0,
2727 __ATOMIC_ACQ_REL, __ATOMIC_RELAXED);
28- return (__exp);
28+ return (exp);
2929 }
3030
3131 inline bool
32-atomic_cas_bool (atomic_t *__ptr, atomic_t __exp, atomic_t __nval)
32+atomic_cas_bool (atomic_t *ptr, atomic_t exp, atomic_t nval)
3333 {
34- return (__atomic_compare_exchange_n (__ptr, &__exp, __nval, 0,
34+ return (__atomic_compare_exchange_n (ptr, &exp, nval, 0,
3535 __ATOMIC_ACQ_REL, __ATOMIC_RELAXED));
3636 }
3737
3838 inline atomic_t
39-atomic_swap (atomic_t *__ptr, atomic_t __val)
39+atomic_swap (atomic_t *ptr, atomic_t val)
4040 {
41- return (__atomic_exchange_n (__ptr, __val, __ATOMIC_ACQ_REL));
41+ return (__atomic_exchange_n (ptr, val, __ATOMIC_ACQ_REL));
4242 }
4343
4444 inline atomic_t
45-atomic_or (atomic_t *__ptr, atomic_t __val)
45+atomic_or (atomic_t *ptr, atomic_t val)
4646 {
47- return (__atomic_fetch_or (__ptr, __val, __ATOMIC_ACQ_REL));
47+ return (__atomic_fetch_or (ptr, val, __ATOMIC_ACQ_REL));
4848 }
4949
5050 inline atomic_t
51-atomic_and (atomic_t *__ptr, atomic_t __val)
51+atomic_and (atomic_t *ptr, atomic_t val)
5252 {
53- return (__atomic_fetch_and (__ptr, __val, __ATOMIC_ACQ_REL));
53+ return (__atomic_fetch_and (ptr, val, __ATOMIC_ACQ_REL));
5454 }
5555
5656 inline void atomic_mfence_acq ()
@@ -72,44 +72,44 @@
7272 defined (__clang__) || defined (__ICC__)
7373
7474 inline atomic_t
75-atomic_add (atomic_t *__ptr, atomic_t __val)
75+atomic_add (atomic_t *ptr, atomic_t val)
7676 {
77- return (__sync_fetch_and_add (__ptr, __val));
77+ return (__sync_fetch_and_add (ptr, val));
7878 }
7979
8080 inline atomic_t
81-atomic_cas (atomic_t *__ptr, atomic_t __exp, atomic_t __nval)
81+atomic_cas (atomic_t *ptr, atomic_t exp, atomic_t nval)
8282 {
83- return (__sync_val_compare_and_swap (__ptr, __exp, __nval));
83+ return (__sync_val_compare_and_swap (ptr, exp, nval));
8484 }
8585
8686 inline bool
87-atomic_cas_bool (atomic_t *__ptr, atomic_t __exp, atomic_t __nval)
87+atomic_cas_bool (atomic_t *ptr, atomic_t exp, atomic_t nval)
8888 {
89- return (__sync_bool_compare_and_swap (__ptr, __exp, __nval));
89+ return (__sync_bool_compare_and_swap (ptr, exp, nval));
9090 }
9191
9292 inline atomic_t
93-atomic_swap (atomic_t *__ptr, atomic_t __val)
93+atomic_swap (atomic_t *ptr, atomic_t val)
9494 {
9595 while (true)
9696 {
97- atomic_t __ret = *__ptr;
98- if (atomic_cas_bool (__ptr, __ret, __val))
99- return (__ret);
97+ atomic_t ret = *ptr;
98+ if (atomic_cas_bool (ptr, ret, val))
99+ return (ret);
100100 }
101101 }
102102
103103 inline atomic_t
104-atomic_or (atomic_t *__ptr, atomic_t __val)
104+atomic_or (atomic_t *ptr, atomic_t val)
105105 {
106- return (__sync_fetch_and_or (__ptr, __val));
106+ return (__sync_fetch_and_or (ptr, val));
107107 }
108108
109109 inline atomic_t
110-atomic_and (atomic_t *__ptr, atomic_t __val)
110+atomic_and (atomic_t *ptr, atomic_t val)
111111 {
112- return (__sync_fetch_and_and (__ptr, __val));
112+ return (__sync_fetch_and_and (ptr, val));
113113 }
114114
115115 inline void atomic_mfence ()
@@ -138,11 +138,11 @@
138138 # if defined (__PIC__) && __GNUC__ < 5
139139
140140 template <class T>
141- bool atomic_casx (T *__ptr, atomic_t __elo, atomic_t __ehi,
142- atomic_t __nlo, atomic_t __nhi)
141+ bool atomic_casx (T *ptr, atomic_t elo, atomic_t ehi,
142+ atomic_t nlo, atomic_t nhi)
143143 {
144- atomic_t __s;
145- char __r;
144+ atomic_t s;
145+ char r;
146146 __asm__ __volatile__
147147 (
148148 "movl %%ebx, %2\n\t"
@@ -151,33 +151,33 @@
151151 "lock; cmpxchg8b (%%edi)\n\t"
152152 "movl %2, %%ebx\n\t"
153153 "setz %1"
154- : "=m" (*__ptr), "=a" (__r), "=m" (__s)
155- : "m" (*__ptr), "d" (__ehi), "a" (__elo),
156- "c" (__nhi), "m" (__nlo)
154+ : "=m" (*ptr), "=a" (r), "=m" (s)
155+ : "m" (*ptr), "d" (ehi), "a" (elo),
156+ "c" (nhi), "m" (nlo)
157157 : "%edi", "memory"
158158 );
159159
160- return ((bool)__r);
160+ return ((bool)r);
161161 }
162162
163163 # else
164164
165165 template <class T>
166- bool atomic_casx (T *__ptr, atomic_t __elo, atomic_t __ehi,
167- atomic_t __nlo, atomic_t __nhi)
166+ bool atomic_casx (T *ptr, atomic_t elo, atomic_t ehi,
167+ atomic_t nlo, atomic_t nhi)
168168 {
169- char __r;
169+ char r;
170170 __asm__ __volatile__
171171 (
172172 "lock; cmpxchg8b %0\n\t"
173173 "setz %1"
174- : "+m" (*__ptr), "=a" (__r)
175- : "d" (__ehi), "a" (__elo),
176- "c" (__nhi), "b" (__nlo)
174+ : "+m" (*ptr), "=a" (r)
175+ : "d" (ehi), "a" (elo),
176+ "c" (nhi), "b" (nlo)
177177 : "memory"
178178 );
179179
180- return ((bool)__r);
180+ return ((bool)r);
181181 }
182182
183183 # endif
@@ -187,14 +187,14 @@
187187 # define QP_HAS_ATOMIC_CASX
188188
189189 template <class T>
190- bool atomic_casx (T *__ptr, atomic_t __elo, atomic_t __ehi,
191- atomic_t __nlo, atomic_t __nhi)
190+ bool atomic_casx (T *ptr, atomic_t elo, atomic_t ehi,
191+ atomic_t nlo, atomic_t nhi)
192192 {
193- uint64_t __exp = ((uint64_t)__ehi << 32) | __elo;
194- uint64_t __nval = ((uint64_t)__nhi << 32) | __nlo;
193+ uint64_t exp = ((uint64_t)ehi << 32) | elo;
194+ uint64_t nval = ((uint64_t)nhi << 32) | nlo;
195195
196- return (__atomic_compare_exchange_n ((uint64_t *)__ptr,
197- &__exp, __nval, 0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED));
196+ return (__atomic_compare_exchange_n ((uint64_t *)ptr,
197+ &exp, nval, 0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED));
198198 }
199199
200200 # elif defined (QP_ARCH_X8664)
@@ -202,21 +202,21 @@
202202 # define QP_HAS_ATOMIC_CASX
203203
204204 template <class T>
205- bool atomic_casx (T *__ptr, atomic_t __elo, atomic_t __ehi,
206- atomic_t __nlo, atomic_t __nhi)
205+ bool atomic_casx (T *ptr, atomic_t elo, atomic_t ehi,
206+ atomic_t nlo, atomic_t nhi)
207207 {
208- char __r;
208+ char r;
209209 __asm__ __volatile__
210210 (
211211 "lock; cmpxchg16b %0\n\t"
212212 "setz %1"
213- : "+m" (*__ptr), "=q" (__r)
214- : "d" (__ehi), "a" (__elo),
215- "c" (__nhi), "b" (__nlo)
213+ : "+m" (*ptr), "=q" (r)
214+ : "d" (ehi), "a" (elo),
215+ "c" (nhi), "b" (nlo)
216216 : "memory"
217217 );
218218
219- return ((bool)__r);
219+ return ((bool)r);
220220 }
221221
222222 # elif defined (QP_ARCH_ARM32) && ((!defined (__thumb__) || \
@@ -228,34 +228,34 @@
228228 # define QP_HAS_ATOMIC_CASX
229229
230230 template <class T>
231- bool atomic_casx (T *__ptr, atomic_t __elo, atomic_t __ehi,
232- atomic_t __nlo, atomic_t __nhi)
231+ bool atomic_casx (T *ptr, atomic_t elo, atomic_t ehi,
232+ atomic_t nlo, atomic_t nhi)
233233 {
234- uint64_t __qv = ((uint64_t)__ehi << 32) | __elo;
235- uint64_t __nv = ((uint64_t)__nhi << 32) | __nlo;
234+ uint64_t qv = ((uint64_t)ehi << 32) | elo;
235+ uint64_t nv = ((uint64_t)nhi << 32) | nlo;
236236
237237 while (true)
238238 {
239- uint64_t __tmp;
239+ uint64_t tmp;
240240 __asm__ __volatile__
241241 (
242242 "ldrexd %0, %H0, [%1]"
243- : "=&r" (__tmp) : "r" (__ptr)
243+ : "=&r" (tmp) : "r" (ptr)
244244 );
245245
246- if (__tmp != __qv)
246+ if (tmp != qv)
247247 return (false);
248248
249- int __r;
249+ int r;
250250 __asm__ __volatile__
251251 (
252252 "strexd %0, %3, %H3, [%2]"
253- : "=&r" (__r), "+m" (*__ptr)
254- : "r" (__ptr), "r" (__nv)
253+ : "=&r" (r), "+m" (*ptr)
254+ : "r" (ptr), "r" (nv)
255255 : "cc"
256256 );
257257
258- if (__r == 0)
258+ if (r == 0)
259259 return (true);
260260 }
261261 }
@@ -265,31 +265,31 @@
265265 # define QP_HAS_ATOMIC_CASX
266266
267267 template <class T>
268- bool atomic_casx (T *__ptr, atomic_t __elo, atomic_t __ehi,
269- atomic_t __nlo, atomic_t __nhi)
268+ bool atomic_casx (T *ptr, atomic_t elo, atomic_t ehi,
269+ atomic_t nlo, atomic_t nhi)
270270 {
271271 while (true)
272272 {
273- atomic_t __t1, __t2;
273+ atomic_t t1, t2;
274274 __asm__ __volatile__
275275 (
276276 "ldaxp %0, %1, %2"
277- : "=&r" (__t1), "=&r" (__t2)
278- : "Q" (*__ptr)
277+ : "=&r" (t1), "=&r" (t2)
278+ : "Q" (*ptr)
279279 );
280280
281- if (__t1 != __elo || __t2 != __ehi)
281+ if (t1 != elo || t2 != ehi)
282282 return (false);
283283
284- int __r;
284+ int r;
285285 __asm__ __volatile__
286286 (
287287 "stxp %w0, %2, %3, %1"
288- : "=&r" (__r), "=Q" (*__ptr)
289- : "r" (__nlo), "r" (__nhi)
288+ : "=&r" (r), "=Q" (*ptr)
289+ : "r" (nlo), "r" (nhi)
290290 );
291291
292- if (__r == 0)
292+ if (r == 0)
293293 return (true);
294294 }
295295 }
diff -r cee131b9ae2c -r ebca8eb602d8 table.h
--- a/table.h Thu Mar 26 22:26:35 2020 -0300
+++ b/table.h Fri Mar 27 00:10:43 2020 -0300
@@ -24,11 +24,11 @@
2424 valref vec;
2525 int idx;
2626
27- iterator (interpreter *__interp, object __table);
27+ iterator (interpreter *interp, object table);
2828
29- iterator (interpreter *__interp, const iterator& __right) :
30- c_key (__interp, *__right.c_key), c_val (__interp, *__right.c_val),
31- vec (__interp, *__right.vec), idx (__right.idx)
29+ iterator (interpreter *interp, const iterator& right) :
30+ c_key (interp, *right.c_key), c_val (interp, *right.c_val),
31+ vec (interp, *right.vec), idx (right.idx)
3232 {
3333 }
3434
@@ -52,14 +52,14 @@
5252 };
5353 };
5454
55-inline table* as_table (object __obj)
55+inline table* as_table (object obj)
5656 {
57- return ((table *)unmask (__obj));
57+ return ((table *)unmask (obj));
5858 }
5959
60-inline bool table_p (object __obj)
60+inline bool table_p (object obj)
6161 {
62- return (itype (__obj) == typecode::TABLE);
62+ return (itype (obj) == typecode::TABLE);
6363 }
6464
6565 struct stream;
@@ -69,47 +69,47 @@
6969 /* Allocate a table that uses EQFN for key lookups and HASHFN
7070 * to compute hash codes. NIL may be used for both, in which
7171 * case, an appropiate default will be used. */
72-QP_EXPORT object alloc_table (interpreter *__interp,
73- object __eqfn, object __hashfn);
72+QP_EXPORT object alloc_table (interpreter *interp,
73+ object eqfn, object hashfn);
7474
7575 /* Get the value associated to key KEY in table TAB. If not found,
7676 * return DFL. MTSAFE specifies whether we should use a multi-thread
7777 * safe routine or not. */
78-QP_EXPORT object table_get (interpreter *__interp,
79- object __tab, object __key, object __dfl, bool __mtsafe);
78+QP_EXPORT object table_get (interpreter *interp,
79+ object tab, object key, object dfl, bool mtsafe);
8080
8181 /* Associate value VAL to key KEY in table TAB. MTSAFE is used in
8282 * the same manner as with 'table_get'. Returns true if the key was
8383 * not present, false otherwise. */
84-QP_EXPORT bool table_put (interpreter *__interp,
85- object __tab, object __key, object __val, bool __mtsafe);
84+QP_EXPORT bool table_put (interpreter *interp,
85+ object tab, object key, object val, bool mtsafe);
8686
8787 /* Remove the entry with KEY in table TAB and return the value that was
8888 * associated to it, or DFL, if they key was not present. MTSAFE is used in
8989 * the same manner as with the rest of the API. */
90-QP_EXPORT object table_pop (interpreter *__interp,
91- object __tab, object __key, object __dfl, bool __mtsafe);
90+QP_EXPORT object table_pop (interpreter *interp,
91+ object tab, object key, object dfl, bool mtsafe);
9292
9393 /* Clear the table TAB. MTSAFE is used in the same manner as
9494 * with 'table_get'. */
95-QP_EXPORT void table_clr (interpreter *__interp,
96- object __tab, bool __mtsafe);
95+QP_EXPORT void table_clr (interpreter *interp,
96+ object tab, bool mtsafe);
9797
9898 /* Shortcuts for the above, where the MTSAFE parameter is deduced
9999 * from the number of running threads. */
100100
101-QP_EXPORT object nput_u (interpreter *__interp,
102- object __tab, object __key, object __val);
103-
104-QP_EXPORT object get_u (interpreter *__interp,
105- object __tab, object __key, object __dfl);
101+QP_EXPORT object nput_u (interpreter *interp,
102+ object tab, object key, object val);
106103
107-QP_EXPORT object npop_u (interpreter *__interp,
108- object __tab, object __key, object __dfl);
104+QP_EXPORT object get_u (interpreter *interp,
105+ object tab, object key, object dfl);
109106
110-inline void table_clr (interpreter *__interp, object __tab)
107+QP_EXPORT object npop_u (interpreter *interp,
108+ object tab, object key, object dfl);
109+
110+inline void table_clr (interpreter *interp, object tab)
111111 {
112- table_clr (__interp, __tab, !singlethr_p ());
112+ table_clr (interp, tab, !singlethr_p ());
113113 }
114114
115115 // Mutate the value associated to a key inside a table.
@@ -117,28 +117,28 @@
117117 uint32_t flags, object fn, object *argv, int argc);
118118
119119 // Fetch the number of items in table TAB.
120-QP_EXPORT uint32_t len_u (object __tab);
120+QP_EXPORT uint32_t len_u (object tab);
121121
122122 // Return the hashcode for the table TAB.
123-QP_EXPORT uint32_t hash_u (interpreter *__interp, object __tab);
123+QP_EXPORT uint32_t hash_u (interpreter *interp, object tab);
124124
125125 // Copy a table.
126-QP_EXPORT object copy_u (interpreter *__interp, object __obj, bool __deep);
126+QP_EXPORT object copy_u (interpreter *interp, object obj, bool deep);
127127
128-QP_EXPORT object iter_u (interpreter *__interp, object __obj,
129- object __token, bool __adv);
128+QP_EXPORT object iter_u (interpreter *interp,
129+ object obj, object token, bool adv);
130130
131131 // Write a table to a stream.
132-QP_EXPORT int write_u (interpreter *__interp,
133- stream *__strm, object __obj, io_info& __info);
132+QP_EXPORT int write_u (interpreter *interp,
133+ stream *strm, object obj, io_info& info);
134134
135135 // Serialize a table to a stream.
136-QP_EXPORT int64_t pack_u (interpreter *__interp,
137- stream *__strm, object __obj, pack_info& __info);
136+QP_EXPORT int64_t pack_u (interpreter *interp,
137+ stream *strm, object obj, pack_info& info);
138138
139139 // Deserialize a table from a stream.
140-QP_EXPORT object unpack_u (interpreter *__interp,
141- stream *__strm, pack_info& __info, bool __save);
140+QP_EXPORT object unpack_u (interpreter *interp,
141+ stream *strm, pack_info& info, bool save);
142142
143143 // Init OP for tables.
144144 QP_EXPORT init_op init_tables;
diff -r cee131b9ae2c -r ebca8eb602d8 thread.h
--- a/thread.h Thu Mar 26 22:26:35 2020 -0300
+++ b/thread.h Fri Mar 27 00:10:43 2020 -0300
@@ -18,25 +18,25 @@
1818 // Lightweight locks for internal use.
1919
2020 // Initialize lightweight lock LOCKP.
21-inline void lwlock_init (atomic_t *__lockp)
21+inline void lwlock_init (atomic_t *lockp)
2222 {
23- *__lockp = 0;
23+ *lockp = 0;
2424 }
2525
2626 // Grab the lightweight lock LOCKP.
27-extern void lwlock_grab (interpreter *__interp, atomic_t *__lockp);
27+extern void lwlock_grab (interpreter *interp, atomic_t *lockp);
2828
2929 // Grab the lightweight lock LOCKP, waiting up to TIMEOUT.
30-extern bool lwlock_grab (interpreter *__interp,
31- atomic_t *__lockp, double __timeout);
30+extern bool lwlock_grab (interpreter *interp,
31+ atomic_t *lockp, double timeout);
3232
3333 // Drop the lightweight lock LOCKP.
34-extern void lwlock_drop (atomic_t *__lockp);
34+extern void lwlock_drop (atomic_t *lockp);
3535
3636 // Try to grab the lightweight lock LOCKP.
37-inline bool lwlock_trygrab (atomic_t *__lockp)
37+inline bool lwlock_trygrab (atomic_t *lockp)
3838 {
39- return (atomic_cas_bool (__lockp, 0, 1));
39+ return (atomic_cas_bool (lockp, 0, 1));
4040 }
4141
4242 struct lwlock_guard
@@ -100,9 +100,9 @@
100100 this->seq = 0;
101101 }
102102
103- int wait (interpreter *__interp, atomic_t *__lk,
104- double *__timeout = nullptr);
105- void wake (bool __wake_all);
103+ int wait (interpreter *interp, atomic_t *lk,
104+ double *timeout = nullptr);
105+ void wake (bool wake_all);
106106 };
107107
108108 struct lock : public varobj
@@ -117,11 +117,11 @@
117117 uint32_t lock_cnt;
118118
119119 void init (bool recursive_p);
120- int grab (interpreter *__interp);
121- int grab (interpreter *__interp, object __timeout, bool __absolute);
122- int trygrab (interpreter *__interp);
123- int drop (interpreter *__interp);
124- void force_release (interpreter *__interp);
120+ int grab (interpreter *interp);
121+ int grab (interpreter *interp, object timeout, bool absolute);
122+ int trygrab (interpreter *interp);
123+ int drop (interpreter *interp);
124+ void force_release (interpreter *interp);
125125 };
126126
127127 struct condvar : public varobj
@@ -129,13 +129,13 @@
129129 raw_condvar base;
130130 static const int code = typecode::CONDVAR;
131131
132- int wait (interpreter *__interp, object __lk);
133- int wait (interpreter *__interp, object __lk,
134- object __timeout, bool __abs);
132+ int wait (interpreter *interp, object lk);
133+ int wait (interpreter *interp, object lk,
134+ object timeout, bool abs);
135135
136- void wake (interpreter *, bool __wake_all)
136+ void wake (interpreter *, bool wake_all)
137137 {
138- this->base.wake (__wake_all);
138+ this->base.wake (wake_all);
139139 }
140140 };
141141
@@ -204,36 +204,36 @@
204204 }
205205 };
206206
207-inline lock* as_lock (object __obj)
207+inline lock* as_lock (object obj)
208208 {
209- return ((lock *)unmask (__obj));
210-}
211-
212-inline bool lock_p (object __obj)
213-{
214- return (itype (__obj) == typecode::LOCK);
209+ return ((lock *)unmask (obj));
215210 }
216211
217-QP_EXPORT object alloc_lock (interpreter *__interp, bool __recursive_p);
218-
219-inline condvar* as_condvar (object __obj)
212+inline bool lock_p (object obj)
220213 {
221- return ((condvar *)unmask (__obj));
214+ return (itype (obj) == typecode::LOCK);
222215 }
223216
224-inline bool condvar_p (object __obj)
217+QP_EXPORT object alloc_lock (interpreter *interp, bool recursive_p);
218+
219+inline condvar* as_condvar (object obj)
225220 {
226- return (itype (__obj) == typecode::CONDVAR);
221+ return ((condvar *)unmask (obj));
227222 }
228223
229-inline thread* as_thread (object __obj)
224+inline bool condvar_p (object obj)
230225 {
231- return ((thread *)unmask (__obj));
226+ return (itype (obj) == typecode::CONDVAR);
232227 }
233228
234-inline bool thread_p (object __obj)
229+inline thread* as_thread (object obj)
235230 {
236- return (itype (__obj) == typecode::THREAD);
231+ return ((thread *)unmask (obj));
232+}
233+
234+inline bool thread_p (object obj)
235+{
236+ return (itype (obj) == typecode::THREAD);
237237 }
238238
239239 QP_EXPORT dlist all_threads;
diff -r cee131b9ae2c -r ebca8eb602d8 tuple.h
--- a/tuple.h Thu Mar 26 22:26:35 2020 -0300
+++ b/tuple.h Fri Mar 27 00:10:43 2020 -0300
@@ -16,15 +16,15 @@
1616
1717 struct iterator
1818 {
19- iterator (interpreter *__interp, object __tuple);
20- iterator (interpreter *__interp) : node (__interp, UNBOUND)
19+ iterator (interpreter *interp, object tup);
20+ iterator (interpreter *interp) : node (interp, UNBOUND)
2121 {
2222 }
2323
24- iterator (interpreter *__interp, const iterator& __right) :
25- iterator (__interp)
24+ iterator (interpreter *interp, const iterator& right) :
25+ iterator (interp)
2626 {
27- this->reset (*__right.node);
27+ this->reset (*right.node);
2828 }
2929
3030 bool valid ();
@@ -34,30 +34,30 @@
3434
3535 object operator* () const;
3636
37- void reset (object __node)
37+ void reset (object node)
3838 {
39- *this->node = __node;
39+ *this->node = node;
4040 }
4141
42- static iterator make (interpreter *__interp, object __node)
42+ static iterator make (interpreter *interp, object node)
4343 {
44- iterator __rv { __interp };
45- __rv.reset (__node);
46- return (__rv);
44+ iterator rv { interp };
45+ rv.reset (node);
46+ return (rv);
4747 }
4848
4949 valref node;
5050 };
5151 };
5252
53-inline tuple* as_tuple (object __obj)
53+inline tuple* as_tuple (object obj)
5454 {
55- return ((tuple *)unmask (__obj));
55+ return ((tuple *)unmask (obj));
5656 }
5757
58-inline bool tuple_p (object __obj)
58+inline bool tuple_p (object obj)
5959 {
60- return (itype (__obj) == typecode::TUPLE);
60+ return (itype (obj) == typecode::TUPLE);
6161 }
6262
6363 struct stream;
@@ -65,88 +65,88 @@
6565 struct pack_info;
6666
6767 // Allocate a tuple using TST as the comparator.
68-QP_EXPORT object alloc_tuple (interpreter *__interp, object __tst);
68+QP_EXPORT object alloc_tuple (interpreter *interp, object tst);
6969
70-/* Get the key that compares equal to KEY in tuple TUPLE. If not
70+/* Get the key that compares equal to KEY in tuple TUP. If not
7171 * present, return DFL. MTSAFE specifies whether we should use a
7272 * multi-thread safe routine or not. */
73-QP_EXPORT object tuple_get (interpreter *__interp,
74- object __tuple, object __key, object __dfl, bool __mtsafe);
73+QP_EXPORT object tuple_get (interpreter *interp,
74+ object tup, object key, object dfl, bool mtsafe);
7575
76-/* Insert key KEY in tuple TUPLE. MTSAFE is used in the same manner
76+/* Insert key KEY in tuple TUP. MTSAFE is used in the same manner
7777 * as with 'tuple_get'. */
78-QP_EXPORT bool tuple_put (interpreter *__interp,
79- object __tuple, object __key, bool __mtsafe);
78+QP_EXPORT bool tuple_put (interpreter *interp,
79+ object tup, object key, bool mtsafe);
8080
81-/* Remove the key that compares equal to KEY in tuple TUPLE,
81+/* Remove the key that compares equal to KEY in tuple TUP,
8282 * and return it. If not present, return DFL. MTSAFE is used in
8383 * the same manner as with the rest of the API. */
84-QP_EXPORT object tuple_pop (interpreter *__interp,
85- object __tuple, object __key, object __dfl, bool __mtsafe);
84+QP_EXPORT object tuple_pop (interpreter *interp,
85+ object tup, object key, object dfl, bool mtsafe);
8686
8787 /* Shortcuts for the above, where the MTSAFE parameter is deduced
8888 * from the number of running threads. */
8989
90-QP_EXPORT object get_o (interpreter *__interp,
91- object __tuple, object __key, object __dfl);
92-
93-QP_EXPORT object nput_o (interpreter *__interp,
94- object __tuple, object __key, object __val);
90+QP_EXPORT object get_o (interpreter *interp,
91+ object tup, object key, object dfl);
9592
96-QP_EXPORT object npop_o (interpreter *__interp,
97- object __tuple, object __key, object __dfl);
93+QP_EXPORT object nput_o (interpreter *interp,
94+ object tup, object key, object val);
9895
99-// Fetch the number of elements in tuple TUPLE.
100-QP_EXPORT uint32_t len_o (object __tuple);
96+QP_EXPORT object npop_o (interpreter *interp,
97+ object tup, object key, object dfl);
10198
102-// Compute the hashcode for the tuple OBJ.
103-QP_EXPORT uint32_t hash_o (interpreter *__interp, object __obj);
99+// Fetch the number of elements in tuple TUP.
100+QP_EXPORT uint32_t len_o (object tup);
101+
102+// Compute the hashcode for the tuple TUP.
103+QP_EXPORT uint32_t hash_o (interpreter *interp, object tup);
104104
105105 // Iterator interface for tuples.
106-QP_EXPORT object iter_o (interpreter *__interp, object __obj,
107- object __token, bool __adv);
106+QP_EXPORT object iter_o (interpreter *interp,
107+ object obj, object token, bool adv);
108108
109109 // Write a tuple to a stream.
110-QP_EXPORT int write_o (interpreter *__interp,
111- stream *__strm, object __tuple, io_info& __info);
110+QP_EXPORT int write_o (interpreter *interp,
111+ stream *strm, object tup, io_info& info);
112112
113113 // Serialize a tuple in a stream.
114-QP_EXPORT int64_t pack_o (interpreter *__interp,
115- stream *__strm, object __obj, pack_info& __info);
114+QP_EXPORT int64_t pack_o (interpreter *interp,
115+ stream *strm, object tup, pack_info& info);
116116
117117 // Deserialize a tuple from a stream.
118-QP_EXPORT object unpack_o (interpreter *__interp,
119- stream *__strm, pack_info& __info, bool __save);
118+QP_EXPORT object unpack_o (interpreter *interp,
119+ stream *strm, pack_info& info, bool save);
120120
121121 // Copy a tuple.
122-QP_EXPORT object copy_o (interpreter *__interp, object __obj, bool __deep);
122+QP_EXPORT object copy_o (interpreter *interp, object tup, bool deep);
123123
124124 // Clear a tuple.
125-QP_EXPORT void tuple_clr (interpreter *__interp, object __tuple);
125+QP_EXPORT void tuple_clr (interpreter *interp, object tup);
126126
127127 // Mutate a key inside a tuple.
128-QP_EXPORT object nzap_o (interpreter *interp, object obj, object key,
128+QP_EXPORT object nzap_o (interpreter *interp, object tup, object key,
129129 uint32_t flags, object fn, object *argv, int argc);
130130
131131 // Compute the union of tuples TUPLE1 and TUPLE2.
132-QP_EXPORT object tuple_union (interpreter *__interp,
133- object __tuple1, object __tuple2);
132+QP_EXPORT object tuple_union (interpreter *interp,
133+ object tuple1, object tuple2);
134134
135135 // Compute the intersection of tuples TUPLE1 and TUPLE2.
136-QP_EXPORT object tuple_intersect (interpreter *__interp,
137- object __tuple1, object __tuple2);
136+QP_EXPORT object tuple_intersect (interpreter *interp,
137+ object tuple1, object tuple2);
138138
139139 // Compute the difference of tuples TUPLE1 and TUPLE2.
140-QP_EXPORT object tuple_diff (interpreter *__interp,
141- object __tuple1, object __tuple2);
140+QP_EXPORT object tuple_diff (interpreter *interp,
141+ object tuple1, object tuple2);
142142
143143 // Compute the symmetric difference of tuples TUPLE1 and TUPLE2.
144-QP_EXPORT object tuple_symdiff (interpreter *__interp,
145- object __tuple1, object __tuple2);
144+QP_EXPORT object tuple_symdiff (interpreter *interp,
145+ object tuple1, object tuple2);
146146
147-// Return the nearest element to KEY in TUPLE.
148-QP_EXPORT object tuple_nearest (interpreter *__interp, object __tuple,
149- object __key, object *__pred = nullptr, object *__succ = nullptr);
147+// Return the nearest element to KEY in TUP.
148+QP_EXPORT object tuple_nearest (interpreter *interp, object tup,
149+ object key, object *pred = nullptr, object *succ = nullptr);
150150
151151 QP_DECLS_END
152152
diff -r cee131b9ae2c -r ebca8eb602d8 types.h
--- a/types.h Thu Mar 26 22:26:35 2020 -0300
+++ b/types.h Fri Mar 27 00:10:43 2020 -0300
@@ -22,10 +22,10 @@
2222 valref slots;
2323 uint32_t idx;
2424
25- slotdef_iter (interpreter *__interp, object __inst);
25+ slotdef_iter (interpreter *interp, object inst);
2626
27- slotdef_iter (interpreter *__interp, const slotdef_iter& __right) :
28- slots (__interp, *__right.slots), idx (__right.idx)
27+ slotdef_iter (interpreter *interp, const slotdef_iter& right) :
28+ slots (interp, *right.slots), idx (right.idx)
2929 {
3030 }
3131
@@ -41,19 +41,19 @@
4141 };
4242 };
4343
44-inline instance* as_instance (object __obj)
44+inline instance* as_instance (object obj)
4545 {
46- return ((instance *)unmask (__obj));
46+ return ((instance *)unmask (obj));
4747 }
4848
49-inline bool instance_p (object __obj)
49+inline bool instance_p (object obj)
5050 {
51- return (itype (__obj) == typecode::INSTANCE);
51+ return (itype (obj) == typecode::INSTANCE);
5252 }
5353
54-inline bool typespec_p (object __obj)
54+inline bool typespec_p (object obj)
5555 {
56- return (instance_p (__obj) && as_instance(__obj)->tspec != UNBOUND);
56+ return (instance_p (obj) && as_instance(obj)->tspec != UNBOUND);
5757 }
5858
5959 struct stream;
@@ -61,51 +61,51 @@
6161 struct pack_info;
6262
6363 // Return the type of OBJ.
64-QP_EXPORT object type (object __obj);
64+QP_EXPORT object type (object obj);
6565
6666 // Create a new typespec from NAME, PARENTS and SLOTDEFS.
67-QP_EXPORT object type (interpreter *__interp,
68- object __name, object __parents, object __slotdefs);
67+QP_EXPORT object type (interpreter *interp,
68+ object name, object parents, object slotdefs);
6969
7070 // Return the type-name of OBJ as a symbol.
71-QP_EXPORT object type_name (object __obj);
71+QP_EXPORT object type_name (object obj);
7272
7373 // Return the inherited builtin member in OBJ.
74-QP_EXPORT object builtin_member (object __obj);
74+QP_EXPORT object builtin_member (object obj);
7575
7676 // Allocate an instance from a typespec and arguments.
7777 QP_EXPORT object alloc_inst (interpreter *interp,
7878 object xtype, object *argv, int argc);
7979
8080 // Get the value for slot NAME in instance INST.
81-QP_EXPORT object get_w (interpreter *__interp,
82- object __inst, object __name, object __dfl);
81+QP_EXPORT object get_w (interpreter *interp,
82+ object inst, object name, object dfl);
8383
8484 // Set the value for slot NAME in instance INST to VAL.
85-QP_EXPORT object nput_w (interpreter *__interp,
86- object __inst, object __name, object __va);
85+QP_EXPORT object nput_w (interpreter *interp,
86+ object inst, object name, object va);
8787
8888 // Test if OBJ is of type TYPE.
89-QP_EXPORT int instanceof (object __obj, object __type);
89+QP_EXPORT int instanceof (object obj, object type);
9090
9191 // Test if T1 is a subtype of T2.
92-QP_EXPORT int subtype_p (object __t1, object __t2);
92+QP_EXPORT int subtype_p (object t1, object t2);
9393
9494 // Mutate a slot in an instance.
95-QP_EXPORT object nzap_w (interpreter *__interp, object __inst, object __name,
96- uint32_t __flags, object __fn, object *__argv, int __argc);
95+QP_EXPORT object nzap_w (interpreter *interp, object inst, object name,
96+ uint32_t flags, object fn, object *argv, int argc);
9797
9898 // Write an instance to a stream.
99-QP_EXPORT int write_w (interpreter *__interp, stream *__strm,
100- object __obj, io_info& __info);
99+QP_EXPORT int write_w (interpreter *interp,
100+ stream *strm, object obj, io_info& info);
101101
102102 // Serialize an instance in a stream.
103-QP_EXPORT int64_t pack_w (interpreter *__interp,
104- stream *__strm, object __obj, pack_info& __info);
103+QP_EXPORT int64_t pack_w (interpreter *interp,
104+ stream *strm, object obj, pack_info& info);
105105
106106 // Deserialize an instance from a stream.
107-QP_EXPORT object unpack_w (interpreter *__interp,
108- stream *__strm, pack_info& __info, bool __save);
107+QP_EXPORT object unpack_w (interpreter *interp,
108+ stream *strm, pack_info& info, bool save);
109109
110110 // Init OP for types.
111111 QP_EXPORT init_op init_types;
Show on old repository browser