Experimental stuffs with bracket syntax

src/core/compile.c

@@ -438,6 +438,15 @@ static JanetSlot janetc_array(JanetFopts opts, Janet x) {
             JOP_MAKE_ARRAY);
 }
 
+static JanetSlot janetc_tuple(JanetFopts opts, Janet x) {
+    JanetCompiler *c = opts.compiler;
+    const Janet *t = janet_unwrap_tuple(x);
+    return janetc_maker(opts,
+	    janetc_toslots(c, t, janet_tuple_length(t)),
+            JOP_MAKE_TUPLE);
+}
+
+
 static JanetSlot janetc_tablector(JanetFopts opts, Janet x, int op) {
     JanetCompiler *c = opts.compiler;
     return janetc_maker(opts,
@@ -547,6 +556,8 @@ JanetSlot janetc_value(JanetFopts opts, Janet x) {
                     /* Empty tuple is tuple literal */
                     if (janet_tuple_length(tup) == 0) {
                         ret = janetc_cslot(x);
+		    } else if (janet_tuple_flag(tup) == 1) { // [] tuples are not function call
+		        ret = janetc_tuple(opts, x);
                     } else {
                         JanetSlot head = janetc_value(subopts, tup[0]);
                         subopts.flags = JANET_FUNCTION | JANET_CFUNCTION;

src/core/core.janet

@@ -440,12 +440,12 @@
 (defmacro for
   "Do a c style for loop for side effects. Returns nil."
   [binding start end & body]
-  (apply loop [tuple binding :range [tuple start end]] body))
+  (apply loop (tuple binding :range (tuple start end)) body))
 
 (defmacro each
   "Loop over each value in ind. Returns nil."
   [binding ind & body]
-  (apply loop [tuple binding :in ind] body))
+  (apply loop (tuple binding :in ind) body))
 
 (defmacro coro
   "A wrapper for making fibers. Same as (fiber/new (fn [&] ...body))."
@@ -778,8 +778,8 @@
   [x & forms]
   (defn fop [last n]
     (def [h t] (if (= :tuple (type n))
-                 [tuple (get n 0) (array/slice n 1)]
+                 (tuple (get n 0) (array/slice n 1))
-                 [tuple n @[]]))
+                 (tuple n @[])))
     (def parts (array/concat @[h last] t))
     (tuple/slice parts 0))
   (reduce fop x forms))
@@ -791,8 +791,8 @@
   [x & forms]
   (defn fop [last n]
     (def [h t] (if (= :tuple (type n))
-                 [tuple (get n 0) (array/slice n 1)]
+                 (tuple (get n 0) (array/slice n 1))
-                 [tuple n @[]]))
+                 (tuple n @[])))
     (def parts (array/concat @[h] t @[last]))
     (tuple/slice parts 0))
   (reduce fop x forms))
@@ -806,8 +806,8 @@
   [x & forms]
   (defn fop [last n]
     (def [h t] (if (= :tuple (type n))
-                 [tuple (get n 0) (array/slice n 1)]
+                 (tuple (get n 0) (array/slice n 1))
-                 [tuple n @[]]))
+                 (tuple n @[])))
     (def sym (gensym))
     (def parts (array/concat @[h sym] t))
     ~(let [,sym ,last] (if ,sym ,(tuple/slice parts 0))))
@@ -822,8 +822,8 @@
   [x & forms]
   (defn fop [last n]
     (def [h t] (if (= :tuple (type n))
-                 [tuple (get n 0) (array/slice n 1)]
+                 (tuple (get n 0) (array/slice n 1))
-                 [tuple n @[]]))
+                 (tuple n @[])))
     (def sym (gensym))
     (def parts (array/concat @[h] t @[sym]))
     ~(let [,sym ,last] (if ,sym ,(tuple/slice parts 0))))

src/core/parse.c

@@ -342,6 +342,15 @@ static Janet close_tuple(JanetParser *p, JanetParseState *state) {
     return janet_wrap_tuple(janet_tuple_end(ret));
 }
 
+static Janet close_ltuple(JanetParser *p, JanetParseState *state) {
+    Janet *ret = janet_tuple_begin(state->argn);
+    janet_tuple_flag(ret)=1;
+    for (int32_t i = state->argn - 1; i >= 0; i--)
+        ret[i] = p->args[--p->argcount];
+    return janet_wrap_tuple(janet_tuple_end(ret));
+}
+
+
 static Janet close_array(JanetParser *p, JanetParseState *state) {
     JanetArray *array = janet_array(state->argn);
     for (int32_t i = state->argn - 1; i >= 0; i--)
@@ -486,7 +495,11 @@ static int root(JanetParser *p, JanetParseState *state, uint8_t c) {
                     if (state->flags & PFLAG_ATSYM) {
                         ds = close_array(p, state);
                     } else {
+		      if (c == ']') {
+			ds = close_ltuple(p, state);
+		      } else {
                         ds = close_tuple(p, state);
+		      }
                     }
                 } else if (c == '}' && (state->flags & PFLAG_CURLYBRACKETS)) {
                     if (state->argn & 1) {

src/core/tuple.c

@@ -31,11 +31,12 @@
  * which should be filled with Janets. The memory will not be collected until
  * janet_tuple_end is called. */
 Janet *janet_tuple_begin(int32_t length) {
-    char *data = janet_gcalloc(JANET_MEMORY_TUPLE, 4 * sizeof(int32_t) + length * sizeof(Janet));
+    char *data = janet_gcalloc(JANET_MEMORY_TUPLE, 5 * sizeof(int32_t) + length * sizeof(Janet));
-    Janet *tuple = (Janet *)(data + (4 * sizeof(int32_t)));
+    Janet *tuple = (Janet *)(data + (5 * sizeof(int32_t)));
     janet_tuple_length(tuple) = length;
     janet_tuple_sm_start(tuple) = -1;
     janet_tuple_sm_end(tuple) = -1;
+    janet_tuple_flag(tuple) = 0;
     return tuple;
 }
 

src/include/janet/janet.h

@@ -980,11 +980,12 @@ JANET_API void janet_buffer_push_u32(JanetBuffer *buffer, uint32_t x);
 JANET_API void janet_buffer_push_u64(JanetBuffer *buffer, uint64_t x);
 
 /* Tuple */
-#define janet_tuple_raw(t) ((int32_t *)(t) - 4)
+#define janet_tuple_raw(t) ((int32_t *)(t) - 5)
 #define janet_tuple_length(t) (janet_tuple_raw(t)[0])
 #define janet_tuple_hash(t) ((janet_tuple_raw(t)[1]))
 #define janet_tuple_sm_start(t) ((janet_tuple_raw(t)[2]))
 #define janet_tuple_sm_end(t) ((janet_tuple_raw(t)[3]))
+#define janet_tuple_flag(t) ((janet_tuple_raw(t)[4]))
 JANET_API Janet *janet_tuple_begin(int32_t length);
 JANET_API const Janet *janet_tuple_end(Janet *tuple);
 JANET_API const Janet *janet_tuple_n(const Janet *values, int32_t n);