ndtypes 0.2.0dev5 → 0.2.0dev6

data/ext/ruby_ndtypes/ndtypes/libndtypes/io.c

@@ -58,6 +58,7 @@ ndt_type_keyword(const ndt_t *t)
     case FixedDim: return "fixed";
     case VarDim: return "var";
 
+    case Array: return "array";
     case Ref: return "ref";
 
     case ScalarKind: return "ScalarKind";
@@ -88,18 +89,20 @@ ndt_type_keyword(const ndt_t *t)
     case Uint64: return "uint64";
 
     case FloatKind: return "FloatKind";
+    case BFloat16: return "bfloat16";
     case Float16: return "float16";
     case Float32: return "float32";
     case Float64: return "float64";
 
     case ComplexKind: return "ComplexKind";
+    case BComplex32: return "bcomplex32";
     case Complex32: return "complex32";
     case Complex64: return "complex64";
     case Complex128: return "complex128";
 
     case Module: case Function:
-    case SymbolicDim: case EllipsisDim:
-    case Tuple: case Record:
+    case VarDimElem: case SymbolicDim: case EllipsisDim:
+    case Tuple: case Record: case Union:
     case Nominal: case Constr:
     case Typevar:
         return "not a keyword";
@@ -121,11 +124,14 @@ ndt_type_name(const ndt_t *t)
 
     case FixedDim: return "FixedDim";
     case VarDim: return "VarDim";
+    case VarDimElem: return "VarDimElem";
     case SymbolicDim: return "SymbolicDim";
     case EllipsisDim: return "EllipsisDim";
 
+    case Array: return "Array";
     case Tuple: return "Tuple";
     case Record: return "Record";
+    case Union: return "Union";
     case Ref: return "Ref";
     case Constr: return "Constr";
     case Nominal: return "Nominal";
@@ -158,11 +164,13 @@ ndt_type_name(const ndt_t *t)
     case Uint64: return "Uint64";
 
     case FloatKind: return "FloatKind";
+    case BFloat16: return "BFloat16";
     case Float16: return "Float16";
     case Float32: return "Float32";
     case Float64: return "Float64";
 
     case ComplexKind: return "ComplexKind";
+    case BComplex32: return "BComplex32";
     case Complex32: return "Complex32";
     case Complex64: return "Complex64";
     case Complex128: return "Complex128";
@@ -385,6 +393,39 @@ record_fields(buf_t *buf, const ndt_t *t, int d, ndt_context_t *ctx)
     return 0;
 }
 
+static int
+union_fields(buf_t *buf, const ndt_t *t, int d, ndt_context_t *ctx)
+{
+    int64_t i;
+    int n;
+
+    assert(t->tag == Union);
+
+    for (i = 0; i < t->Union.ntags; i++) {
+        if (i >= 1) {
+            if (d >= 0) {
+                n = ndt_snprintf(ctx, buf, "|\n");
+                if (n < 0) return -1;
+
+                n = indent(ctx, buf, d);
+                if (n < 0) return -1;
+            }
+            else {
+                n = ndt_snprintf(ctx, buf, " | ");
+                if (n < 0) return -1;
+            }
+        }
+
+        n = ndt_snprintf(ctx, buf, "%s of ", t->Union.tags[i]);
+        if (n < 0) return -1;
+
+        n = datashape(buf, t->Union.types[i], d, ctx);
+        if (n < 0) return -1;
+    }
+
+    return 0;
+}
+
 static int
 variadic_flag(buf_t *buf, enum ndt_variadic flag, ndt_context_t *ctx)
 {
@@ -440,7 +481,7 @@ value(buf_t *buf, const ndt_value_t *mem, ndt_context_t *ctx)
 }
 
 static int
-categorical(buf_t *buf, ndt_value_t *mem, int64_t ntypes, ndt_context_t *ctx)
+categorical(buf_t *buf, const ndt_value_t *mem, int64_t ntypes, ndt_context_t *ctx)
 {
     int64_t i;
     int n;
@@ -540,6 +581,10 @@ datashape(buf_t *buf, const ndt_t *t, int d, ndt_context_t *ctx)
             return datashape(buf, t->VarDim.type, d, ctx);
         }
 
+        case VarDimElem: {
+            return datashape(buf, t->VarDimElem.type, d, ctx);
+        }
+
         case SymbolicDim: {
             n = ndt_snprintf(ctx, buf, "%s", t->SymbolicDim.tag==RequireC ? "C[" : "");
             if (n < 0) return -1;
@@ -563,8 +608,17 @@ datashape(buf_t *buf, const ndt_t *t, int d, ndt_context_t *ctx)
             n = ndt_snprintf(ctx, buf, "%s", t->EllipsisDim.tag==RequireF ? "F[" : "");
             if (n < 0) return -1;
 
-            n = ndt_snprintf(ctx, buf, "%s... * ",
-                    t->EllipsisDim.name ? t->EllipsisDim.name : "");
+            if (t->EllipsisDim.name) {
+                if (strcmp(t->EllipsisDim.name, "array") == 0) {
+                    n = ndt_snprintf(ctx, buf, "array... of ");
+                }
+                else {
+                    n = ndt_snprintf(ctx, buf, "%s... * ", t->EllipsisDim.name);
+                }
+            }
+            else {
+                n = ndt_snprintf(ctx, buf, "... * ");
+            }
             if (n < 0) return -1;
 
             n = datashape(buf, t->EllipsisDim.type, d, ctx);
@@ -573,6 +627,13 @@ datashape(buf_t *buf, const ndt_t *t, int d, ndt_context_t *ctx)
             return ndt_snprintf(ctx, buf, "%s", t->EllipsisDim.tag==RequireNA ? "" : "]");
         }
 
+        case Array: {
+            n = ndt_snprintf(ctx, buf, "array of ");
+            if (n < 0) return -1;
+
+            return datashape(buf, t->Array.type, d, ctx);
+        }
+
         case Tuple: {
             n = ndt_snprintf(ctx, buf, "(");
             if (n < 0) return -1;
@@ -626,6 +687,32 @@ datashape(buf_t *buf, const ndt_t *t, int d, ndt_context_t *ctx)
             return ndt_snprintf(ctx, buf, "}");
         }
 
+        case Union: {
+            assert(t->Union.ntags > 0);
+
+            n = ndt_snprintf(ctx, buf, "[");
+            if (n < 0) return -1;
+
+            if (d >= 0) {
+                n = ndt_snprintf(ctx, buf, "\n");
+                if (n < 0) return -1;
+                n = indent(ctx, buf, d+2);
+                if (n < 0) return -1;
+            }
+
+            n = union_fields(buf, t, d+2, ctx);
+            if (n < 0) return -1;
+
+            if (d >= 0) {
+                n = ndt_snprintf(ctx, buf, "\n");
+                if (n < 0) return -1;
+                n = indent(ctx, buf, d);
+                if (n < 0) return -1;
+            }
+
+            return ndt_snprintf(ctx, buf, "]");
+        }
+
         case Ref: {
             n = ndt_snprintf(ctx, buf, "ref(");
             if (n < 0) return -1;
@@ -709,9 +796,9 @@ datashape(buf_t *buf, const ndt_t *t, int d, ndt_context_t *ctx)
         case UnsignedKind:
         case Uint8: case Uint16: case Uint32: case Uint64:
         case FloatKind:
-        case Float16: case Float32: case Float64:
+        case BFloat16: case Float16: case Float32: case Float64:
         case ComplexKind:
-        case Complex32: case Complex64: case Complex128:
+        case BComplex32: case Complex32: case Complex64: case Complex128:
         case FixedStringKind:
         case FixedBytesKind:
         case String:
@@ -938,6 +1025,42 @@ ast_record_fields(buf_t *buf, const ndt_t *t, int d, ndt_context_t *ctx)
     return 0;
 }
 
+static int
+ast_union_fields(buf_t *buf, const ndt_t *t, int d, ndt_context_t *ctx)
+{
+    int64_t i;
+    int n;
+
+    assert(t->tag == Union);
+
+    for (i = 0; i < t->Union.ntags; i++) {
+        if (i >= 1) {
+            n = ndt_snprintf(ctx, buf, ",\n");
+            if (n < 0) return -1;
+        }
+
+        n = ndt_snprintf_d(ctx, buf, d, "UnionMember(\n");
+        if (n < 0) return -1;
+
+        n = ndt_snprintf_d(ctx, buf, d+2, "tag='%s',\n", t->Union.tags[i]);
+        if (n < 0) return -1;
+
+        n = ndt_snprintf_d(ctx, buf, d+2, "type=");
+        if (n < 0) return -1;
+
+        n = ast_datashape(buf, t->Union.types[i], d+5+2, 1, ctx);
+        if (n < 0) return -1;
+
+        n = ndt_snprintf(ctx, buf, "%s\n", ndt_is_concrete(t) ? "," : "");
+        if (n < 0) return -1;
+
+        n = ndt_snprintf_d(ctx, buf, d, ")");
+        if (n < 0) return -1;
+    }
+
+    return 0;
+}
+
 static int
 ast_variadic_flag(buf_t *buf, enum ndt_variadic flag, int d, ndt_context_t *ctx)
 {
@@ -983,7 +1106,7 @@ ast_value(buf_t *buf, const ndt_value_t *mem, ndt_context_t *ctx)
 }
 
 static int
-ast_categorical(buf_t *buf, ndt_value_t *mem, int64_t ntypes, ndt_context_t *ctx)
+ast_categorical(buf_t *buf, const ndt_value_t *mem, int64_t ntypes, ndt_context_t *ctx)
 {
     int64_t i;
     int n;
@@ -1066,10 +1189,11 @@ ast_datashape(buf_t *buf, const ndt_t *t, int d, int cont, ndt_context_t *ctx)
             return ndt_snprintf_d(ctx, buf, d, ")");
         }
 
-        case VarDim: {
+        case VarDim: case VarDimElem: {
             int i;
 
-            n = ndt_snprintf_d(ctx, buf, cont ? 0 : d, "VarDim(\n");
+            n = ndt_snprintf_d(ctx, buf, cont ? 0 : d, "%s(\n",
+                               ndt_type_name(t));
             if (n < 0) return -1;
 
             n = ast_datashape(buf, t->VarDim.type, d+2, 0, ctx);
@@ -1079,13 +1203,19 @@ ast_datashape(buf_t *buf, const ndt_t *t, int d, int cont, ndt_context_t *ctx)
             if (n < 0) return -1;
 
             if (ndt_is_concrete(t)) {
+                if (t->tag == VarDimElem) {
+                    n = ndt_snprintf_d(ctx, buf, d+2, "index=%" PRIi64 ",\n",
+                                       t->VarDimElem.index);
+                    if (n < 0) return -1;
+                }
+
                 n = ndt_snprintf_d(ctx, buf, d+2, "offsets=[");
                 if (n < 0) return -1;
 
-                for (i = 0; i < t->Concrete.VarDim.noffsets; i++) {
+                for (i = 0; i < t->Concrete.VarDim.offsets->n; i++) {
                     n = ndt_snprintf(ctx, buf, "%" PRIi32 "%s",
-                                     t->Concrete.VarDim.offsets[i],
-                                     i==t->Concrete.VarDim.noffsets-1 ? "" : ", ");
+                                     t->Concrete.VarDim.offsets->v[i],
+                                     i==t->Concrete.VarDim.offsets->n-1 ? "" : ", ");
                     if (n < 0) return -1;
                 }
 
@@ -1155,6 +1285,28 @@ ast_datashape(buf_t *buf, const ndt_t *t, int d, int cont, ndt_context_t *ctx)
             return ndt_snprintf_d(ctx, buf, d, ")");
         }
 
+        case Array: {
+            n = ndt_snprintf_d(ctx, buf, cont ? 0 : d, "Array(\n");
+            if (n < 0) return -1;
+
+            n = ndt_snprintf_d(ctx, buf, d+2, "itemsize=%" PRIi64 ",\n",
+                               t->Array.itemsize);
+
+            n = ndt_snprintf_d(ctx, buf, d+2, "type=");
+            if (n < 0) return -1;
+
+            n = ast_datashape(buf, t->Array.type, d+5+2, 1, ctx);
+            if (n < 0) return -1;
+
+            n = ndt_snprintf(ctx, buf, ",\n");
+            if (n < 0) return -1;
+
+            n = ast_common_attributes_with_newline(buf, t, d+2, ctx);
+            if (n < 0) return -1;
+
+            return ndt_snprintf_d(ctx, buf, d, ")");
+        }
+
         case Tuple: {
             n = ndt_snprintf_d(ctx, buf, cont ? 0 : d, "Tuple(\n");
             if (n < 0) return -1;
@@ -1205,6 +1357,24 @@ ast_datashape(buf_t *buf, const ndt_t *t, int d, int cont, ndt_context_t *ctx)
             return ndt_snprintf_d(ctx, buf, d, ")");
         }
 
+        case Union: {
+            assert(t->Union.ntags > 0);
+
+            n = ndt_snprintf_d(ctx, buf, cont ? 0 : d, "Union(\n");
+            if (n < 0) return -1;
+
+            n = ast_union_fields(buf, t, d+2, ctx);
+            if (n < 0) return -1;
+
+            n = ndt_snprintf(ctx, buf, ",\n");
+            if (n < 0) return -1;
+
+            n = ast_common_attributes_with_newline(buf, t, d+2, ctx);
+            if (n < 0) return -1;
+
+            return ndt_snprintf_d(ctx, buf, d, ")");
+        }
+
         case Ref: {
             n = ndt_snprintf_d(ctx, buf, cont ? 0 : d, "Ref(\n");
             if (n < 0) return -1;
@@ -1362,9 +1532,9 @@ ast_datashape(buf_t *buf, const ndt_t *t, int d, int cont, ndt_context_t *ctx)
         case UnsignedKind:
         case Uint8: case Uint16: case Uint32: case Uint64:
         case FloatKind:
-        case Float16: case Float32: case Float64:
+        case BFloat16: case Float16: case Float32: case Float64:
         case ComplexKind:
-        case Complex32: case Complex64: case Complex128:
+        case BComplex32: case Complex32: case Complex64: case Complex128:
         case FixedStringKind: case FixedBytesKind:
         case String:
             n = ndt_snprintf_d(ctx, buf, cont ? 0 : d, "%s(", ndt_type_name(t));

data/ext/ruby_ndtypes/ndtypes/libndtypes/lexer.c

@@ -592,8 +592,8 @@ static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner );
 	yyg->yy_hold_char = *yy_cp; \
 	*yy_cp = '\0'; \
 	yyg->yy_c_buf_p = yy_cp;
-#define YY_NUM_RULES 67
-#define YY_END_OF_BUFFER 68
+#define YY_NUM_RULES 71
+#define YY_END_OF_BUFFER 72
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -601,33 +601,34 @@ struct yy_trans_info
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
-static const flex_int16_t yy_accept[227] =
+static const flex_int16_t yy_accept[237] =
     {   0,
-        0,    0,   68,   66,   64,   63,   63,   52,   66,   65,
-       66,   53,   66,   43,   44,   49,   41,   66,   66,   61,
-       61,   42,   55,   50,   56,   51,   58,   58,   58,   58,
-       58,   58,   58,   47,   48,   59,   57,   57,   57,   57,
-       57,   57,   57,   57,   57,   45,   54,   46,    0,   60,
-        0,   65,    0,    0,    0,    0,   61,   61,   40,    0,
-       62,   62,   61,    0,    0,    0,    0,   61,   58,   58,
-       58,   58,   58,   35,   58,   58,   58,   59,   57,   57,
-       57,   57,   57,   57,   57,   57,   57,   57,   57,   57,
-       57,   57,   57,    0,   39,    0,   62,   61,   61,    2,
-
-       58,   58,   58,   58,   58,   58,   57,   57,   57,   57,
-       57,   57,   57,   57,   36,   57,   57,   57,   38,   57,
-        0,   58,   58,   58,   58,   58,   58,    5,   57,   57,
-       27,   57,   57,   57,   57,   57,   57,    7,   57,   57,
-       57,   57,    4,    1,   58,   58,   16,   58,   58,   58,
-       29,   57,   57,   37,   57,    8,    9,   10,   57,   57,
-       57,   57,   57,   57,   12,   57,   58,   58,   58,    3,
-        6,   58,   57,   57,   57,   57,   57,   57,   24,   26,
-       28,   13,   14,   15,   57,   20,   58,   58,   58,   57,
-       57,   57,   57,   17,   18,   19,   25,   58,   58,   11,
-
-       57,   57,   57,   57,   57,   57,   58,   58,   57,   57,
-       21,   22,   57,   57,   32,   58,   57,   23,   57,   57,
-       30,   34,   33,   57,   31,    0
+        0,    0,   72,   70,   68,   67,   67,   56,   70,   69,
+       70,   57,   70,   47,   48,   53,   45,   70,   70,   65,
+       65,   46,   59,   54,   60,   55,   62,   62,   62,   62,
+       62,   51,   52,   63,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   49,   58,   50,    0,   64,
+        0,   69,    0,    0,    0,    0,   65,   65,   44,    0,
+       66,   66,   65,    0,    0,    0,    0,   65,   62,   62,
+       62,   37,   62,   63,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   61,   42,   61,   61,   61,
+       61,   61,   61,   61,    0,   43,    0,   66,   65,   65,
+
+        2,   62,   62,   61,   61,   61,   61,   61,   61,   61,
+       61,   61,   61,   61,   38,   61,   61,   61,   61,   61,
+       40,   61,    0,   62,   62,   61,   61,   61,    5,   61,
+       61,   29,   61,   61,   61,   61,   61,   61,    7,   61,
+       61,   61,   61,   61,   61,    4,    1,   62,   62,   41,
+       61,   61,   31,   61,   61,   39,   16,    8,    9,   10,
+       61,   61,   61,   61,   61,   61,   61,   12,   61,   61,
+       62,   62,    3,   61,   61,   61,   61,   61,   61,   61,
+       61,   26,    6,   28,   30,   13,   14,   15,   61,   61,
+       62,   62,   61,   61,   61,   21,   61,   61,   18,   19,
+
+       20,   27,   61,   62,   62,   61,   17,   61,   61,   61,
+       61,   61,   61,   11,   62,   62,   61,   61,   61,   23,
+       24,   61,   61,   34,   62,   22,   61,   25,   61,   61,
+       32,   36,   35,   61,   33,    0
     } ;
 
 static const YY_CHAR yy_ec[256] =
@@ -638,14 +639,14 @@ static const YY_CHAR yy_ec[256] =
         1,    2,    5,    6,    7,    1,    8,    9,   10,   11,
        12,   13,   14,   15,   16,   17,    1,   18,   19,   20,
        21,   22,   23,   24,   23,   25,   26,   27,    1,   28,
-       29,   30,   31,    1,   32,   33,   34,   35,   36,   37,
-       38,   38,   38,   38,   38,   38,   38,   39,   40,   38,
-       38,   38,   41,   38,   42,   38,   38,   43,   38,   38,
-       44,   45,   46,    1,   47,    1,   48,   49,   50,   51,
-
-       52,   53,   54,   55,   56,   57,   57,   58,   59,   60,
-       61,   62,   57,   63,   64,   65,   66,   67,   57,   68,
-       69,   70,   71,   72,   73,    1,    1,    1,    1,    1,
+       29,   30,   31,    1,   32,   33,   34,   34,   35,   36,
+       37,   37,   37,   37,   37,   37,   37,   38,   39,   37,
+       37,   37,   40,   37,   37,   37,   37,   41,   37,   37,
+       42,   43,   44,    1,   45,    1,   46,   47,   48,   49,
+
+       50,   51,   52,   53,   54,   55,   55,   56,   57,   58,
+       59,   60,   55,   61,   62,   63,   64,   65,   55,   66,
+       67,   68,   69,   70,   71,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -662,132 +663,135 @@ static const YY_CHAR yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static const YY_CHAR yy_meta[74] =
+static const YY_CHAR yy_meta[72] =
     {   0,
         1,    1,    2,    3,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    4,    1,    4,    5,    6,    6,    6,
         6,    6,    6,    6,    6,    6,    1,    1,    1,    7,
-        1,    8,    8,    8,    8,    9,    8,   10,   10,   10,
-       10,   10,   10,    1,    1,    1,   10,    8,    8,    8,
-        8,    9,    8,   10,   10,   10,   10,   10,   10,   10,
-       10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
-        1,    1,    1
+        1,    8,    8,    8,    9,    8,   10,   10,   10,   10,
+       10,    1,    1,    1,   10,    8,    8,    8,    8,    9,
+        8,   10,   10,   10,   10,   10,   10,   10,   10,   10,
+       10,   10,   10,   10,   10,   10,   10,   10,    1,    1,
+        1
     } ;
 
-static const flex_int16_t yy_base[238] =
+static const flex_int16_t yy_base[248] =
     {   0,
-        0,    0,  371,  372,  372,  372,  372,  372,   68,    0,
-      320,  372,   65,  372,  372,  372,  372,   59,   61,   97,
-       73,  372,  372,  372,  372,  372,  309,    0,  307,   35,
-      335,   38,  306,  372,  372,    0,    0,   31,   47,   40,
-      305,  312,   41,  307,   51,  372,  372,  372,   97,  372,
-        0,    0,  301,   91,    0,  148,    0,   94,  372,  344,
-       91,   92,   86,  342,   91,  157,    0,    0,    0,  290,
-      299,  289,  295,    0,  307,  300,  289,    0,    0,  291,
-      286,  285,  301,  289,  279,  285,  280,  291,  273,  279,
-      281,  277,  283,  287,  372,  164,  173,  182,    0,    0,
-
-      275,  284,  287,  276,  273,  276,  273,  278,  277,  265,
-      265,  274,  277,  188,    0,  272,  267,  257,    0,  268,
-      264,  255,  261,  242,  254,  245,  240,    0,  229,  225,
-        0,  212,  218,  194,  232,  235,  232,    0,  188,  205,
-      191,  195,    0,  372,  197,   91,    0,  185,  196,  186,
-        0,  184,  192,  196,  129,    0,    0,    0,  179,  176,
-      186,  215,  218,  215,    0,  171,  167,  165,  168,    0,
-        0,  180,  168,  162,   92,  205,  208,  205,    0,    0,
-        0,    0,    0,    0,  163,    0,  160,  161,  172,  166,
-      136,  152,  153,    0,    0,    0,    0,  165,  159,    0,
-
-      161,  190,  188,  142,   98,   99,   97,   99,  104,  126,
-        0,    0,   93,   83,    0,   84,   77,    0,   70,   71,
-        0,    0,    0,   50,    0,  372,  257,  267,  277,  283,
+        0,    0,  379,  380,  380,  380,  380,  380,   66,    0,
+      330,  380,   63,  380,  380,  380,  380,   57,   59,   93,
+       72,  380,  380,  380,  380,  380,  319,    0,  322,  343,
+      326,  380,  380,    0,  312,   72,   40,    0,   34,  314,
+      320,  320,   37,   38,   49,  380,  380,  380,   92,  380,
+        0,    0,  310,   84,    0,  142,    0,   86,  380,  351,
+       90,   91,  110,  349,   88,  159,    0,    0,    0,  299,
+      299,    0,  318,    0,    0,  302,  303,  305,  301,  296,
+      295,  311,  299,  289,  295,  290,    0,  301,   77,  290,
+      292,  287,  287,  293,  297,  380,  166,  175,  184,    0,
+
+        0,  295,  288,  297,  285,  282,  284,  289,  288,  276,
+      276,  285,  288,  190,    0,  275,  282,  277,  267,  275,
+        0,  279,  277,  277,  279,  257,  263,  276,    0,  257,
+      264,    0,  257,  263,  244,  278,  277,  272,    0,  230,
+      229,  225,  211,  197,  207,    0,  380,   97,  195,    0,
+      199,  191,    0,  194,  202,  206,  123,    0,    0,    0,
+      188,  199,  184,  194,  221,  224,  221,    0,  179,  183,
+      173,  176,    0,  188,  218,  175,  169,   86,  210,  213,
+      210,    0,    0,    0,    0,    0,    0,    0,  170,  180,
+      166,  167,  161,  202,  171,  134,  157,  160,    0,    0,
+
+        0,    0,  171,  169,  163,  192,    0,  164,  190,  155,
+      152,  110,  111,    0,  109,  112,  137,  110,  129,    0,
+        0,  100,   92,    0,   86,    0,   68,    0,   43,   43,
+        0,    0,    0,   45,    0,  380,  257,  267,  277,  283,
       286,  290,  295,  300,  305,  311,  312
     } ;
 
-static const flex_int16_t yy_def[238] =
+static const flex_int16_t yy_def[248] =
     {   0,
-      226,    1,  226,  226,  226,  226,  226,  226,  227,  228,
-      226,  226,  229,  226,  226,  226,  226,  230,  226,  226,
-      231,  226,  226,  226,  226,  226,  232,  232,  232,  232,
-      232,  232,  232,  226,  226,  233,  234,  234,  234,  234,
-      234,  234,  234,  234,  234,  226,  226,  226,  227,  226,
-      227,  228,  226,  229,  229,  226,   20,  231,  226,  226,
-      235,  235,   20,   63,  236,  226,  237,   58,  232,  232,
-      232,  232,  232,  232,  232,  232,  232,  233,  234,  234,
-      234,  234,  234,  234,  234,  234,  234,  234,  234,  234,
-      234,  234,  234,  226,  226,  226,  226,  226,  237,  232,
-
-      232,  232,  232,  232,  232,  232,  234,  234,  234,  234,
-      234,  234,  234,  234,  234,  234,  234,  234,  234,  234,
-      226,  232,  232,  232,  232,  232,  232,  234,  234,  234,
-      234,  234,  234,  234,  234,  234,  234,  234,  234,  234,
-      234,  234,  234,  226,  232,  232,  232,  232,  232,  232,
-      234,  234,  234,  234,  234,  234,  234,  234,  234,  234,
-      234,  234,  234,  234,  234,  234,  232,  232,  232,  232,
-      232,  232,  234,  234,  234,  234,  234,  234,  234,  234,
-      234,  234,  234,  234,  234,  232,  232,  232,  232,  234,
-      234,  234,  234,  234,  234,  234,  234,  232,  232,  232,
-
-      234,  234,  234,  234,  234,  234,  232,  232,  234,  234,
-      234,  234,  234,  234,  232,  232,  234,  234,  234,  234,
-      232,  234,  234,  234,  234,    0,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226
+      236,    1,  236,  236,  236,  236,  236,  236,  237,  238,
+      236,  236,  239,  236,  236,  236,  236,  240,  236,  236,
+      241,  236,  236,  236,  236,  236,  242,  242,  242,  242,
+      242,  236,  236,  243,  244,  244,  244,  244,  244,  244,
+      244,  244,  244,  244,  244,  236,  236,  236,  237,  236,
+      237,  238,  236,  239,  239,  236,   20,  241,  236,  236,
+      245,  245,   20,   63,  246,  236,  247,   58,  242,  242,
+      242,  242,  242,  243,  244,  244,  244,  244,  244,  244,
+      244,  244,  244,  244,  244,  244,  244,  244,  244,  244,
+      244,  244,  244,  244,  236,  236,  236,  236,  236,  247,
+
+      242,  242,  242,  244,  244,  244,  244,  244,  244,  244,
+      244,  244,  244,  244,  244,  244,  244,  244,  244,  244,
+      244,  244,  236,  242,  242,  244,  244,  244,  244,  244,
+      244,  244,  244,  244,  244,  244,  244,  244,  244,  244,
+      244,  244,  244,  244,  244,  244,  236,  242,  242,  244,
+      244,  244,  244,  244,  244,  244,  244,  244,  244,  244,
+      244,  244,  244,  244,  244,  244,  244,  244,  244,  244,
+      242,  242,  242,  244,  244,  244,  244,  244,  244,  244,
+      244,  244,  244,  244,  244,  244,  244,  244,  244,  244,
+      242,  242,  244,  244,  244,  244,  244,  244,  244,  244,
+
+      244,  244,  244,  242,  242,  244,  244,  244,  244,  244,
+      244,  244,  244,  244,  242,  242,  244,  244,  244,  244,
+      244,  244,  244,  242,  242,  244,  244,  244,  244,  244,
+      242,  244,  244,  244,  244,    0,  236,  236,  236,  236,
+      236,  236,  236,  236,  236,  236,  236
     } ;
 
-static const flex_int16_t yy_nxt[446] =
+static const flex_int16_t yy_nxt[452] =
     {   0,
         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
        14,   15,   16,    4,   17,   18,   19,   20,   21,   21,
        21,   21,   21,   21,   21,   21,   22,   23,   24,   25,
-       26,   27,   28,   29,   28,   28,   30,   28,   31,   28,
-       32,   33,   28,   34,    4,   35,   36,   37,   38,   39,
-       37,   37,   40,   37,   37,   41,   37,   37,   37,   37,
-       37,   37,   42,   43,   37,   44,   45,   37,   37,   37,
-       46,   47,   48,   50,   50,   56,   57,   60,   61,   61,
-       61,   61,   61,   61,   61,   61,   61,   75,   59,   62,
-       72,   80,   73,   76,   82,   85,   89,   86,   92,   81,
-
-       50,   83,   50,  225,   96,   90,   96,   84,   65,   55,
-       62,   93,   51,   62,   63,   64,   64,   64,   64,   64,
-       64,   64,   64,  168,   65,  226,   65,   65,  226,   65,
-      224,  169,   65,  223,  222,   55,   66,  221,  220,   67,
-      192,   51,   65,   65,  219,   65,  226,  176,   65,  177,
-      218,  217,  178,  226,  202,  193,  203,   66,  216,  204,
-      215,  214,  213,  212,   67,   61,   61,   61,   61,   61,
-       61,   61,   61,   61,   98,   98,   98,   98,   98,   98,
-       98,   97,   97,   97,   97,   97,   97,   97,   97,   97,
-       97,   97,   97,   97,   97,   97,   97,   97,   97,   98,
-
-       98,   98,   98,   98,   98,   98,  135,  211,  136,  210,
-      209,  137,  138,  162,  208,  163,  207,  206,  164,  165,
-      205,  201,  200,  199,  198,  197,  196,  195,  194,  191,
-      190,  189,  188,  187,  186,  185,  184,  183,  182,  181,
-      180,  179,  175,  174,  173,  172,  171,  170,  167,  139,
-      161,  160,  159,  158,  157,  156,  166,   49,  155,   49,
-       49,   49,   49,   49,   49,   49,   49,   52,  154,  153,
-       52,   52,   52,   52,   52,   52,   52,   54,  152,   54,
+       26,   27,   28,   28,   28,   29,   28,   30,   28,   31,
+       28,   32,    4,   33,   34,   35,   36,   37,   38,   38,
+       39,   38,   38,   40,   38,   38,   38,   38,   41,   38,
+       42,   43,   38,   44,   45,   38,   38,   38,   46,   47,
+       48,   50,   50,   56,   57,   60,   61,   61,   61,   61,
+       61,   61,   61,   61,   61,   81,   59,   84,   62,   85,
+       89,   91,   82,   50,   93,   92,  235,   50,   83,   90,
+
+      234,   97,   62,   97,  233,   55,   65,   94,   51,   62,
+       63,   64,   64,   64,   64,   64,   64,   64,   64,   77,
+       65,   65,   78,  232,   65,   65,   55,   65,  116,  171,
+       79,   66,  197,   67,   51,   65,  172,  231,   80,   65,
+       65,  179,   65,  180,  117,  230,  181,  198,  236,  229,
+      236,   66,  209,  228,  210,  227,  226,  211,   67,   61,
+       61,   61,   61,   61,   61,   61,   61,   61,  236,  225,
+      224,  223,  222,  221,  220,  236,   99,   99,   99,   99,
+       99,   99,   99,   98,   98,   98,   98,   98,   98,   98,
+       98,   98,   98,   98,   98,   98,   98,   98,   98,   98,
+
+       98,   99,   99,   99,   99,   99,   99,   99,  136,  219,
+      137,  218,  217,  138,  139,  165,  216,  166,  215,  214,
+      167,  168,  213,  212,  208,  207,  206,  205,  204,  203,
+      202,  201,  200,  199,  196,  195,  194,  193,  192,  191,
+      190,  189,  188,  187,  186,  185,  184,  183,  182,  140,
+      178,  177,  176,  175,  174,  173,  169,   49,  170,   49,
+       49,   49,   49,   49,   49,   49,   49,   52,  164,  163,
+       52,   52,   52,   52,   52,   52,   52,   54,  162,   54,
        54,   54,   54,   54,   54,   54,   54,   58,   58,   58,
-       68,   68,  151,  150,   68,   69,  149,   69,   69,   69,
+       68,   68,  161,  160,   68,   69,  159,   69,   69,   69,
 
-       78,  148,   78,   78,   78,   79,  147,   79,   79,   79,
-       61,  146,  145,   61,   97,  144,   97,   99,  143,   99,
-       99,  142,  141,  140,  134,  133,  132,  131,  130,  129,
+       74,  158,   74,   74,   74,   75,  157,   75,   75,   75,
+       61,  156,  155,   61,   98,  154,   98,  100,  153,  100,
+      100,  152,  151,  150,  149,  148,  147,  146,  145,  144,
+      143,  142,  141,  135,  134,  133,  132,  131,  130,  129,
       128,  127,  126,  125,  124,  123,  122,  121,  120,  119,
-      118,  117,  116,  115,  114,  113,  112,  111,  110,  109,
-      108,  107,  106,  105,  104,  103,  102,  101,  100,   64,
-       95,   94,   91,   88,   87,   77,   74,   71,   70,   53,
-      226,    3,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226
+      118,  115,  114,  113,  112,  111,  110,  109,  108,  107,
+      106,  105,  104,  103,  102,  101,   64,   96,   95,   88,
+       87,   86,   76,   73,   72,   71,   70,   53,  236,    3,
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+      236
     } ;
 
-static const flex_int16_t yy_chk[446] =
+static const flex_int16_t yy_chk[452] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -796,57 +800,58 @@ static const flex_int16_t yy_chk[446] =
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    9,   13,   18,   18,   19,   19,   19,
-       19,   19,   19,   19,   19,   19,   19,   32,   18,   21,
-       30,   38,   30,   32,   39,   40,   43,   40,   45,   38,
-
-       54,   39,   49,  224,   65,   43,   65,   39,   21,   13,
-       58,   45,    9,   20,   20,   20,   20,   20,   20,   20,
-       20,   20,   20,  146,   21,   63,   61,   62,   63,   58,
-      220,  146,   20,  219,  217,   54,   20,  216,  214,   20,
-      175,   49,   61,   62,  213,   58,   63,  155,   20,  155,
-      210,  209,  155,   63,  191,  175,  191,   20,  208,  191,
-      207,  206,  205,  204,   20,   56,   56,   56,   56,   56,
-       56,   56,   56,   56,   66,   66,   66,   66,   66,   66,
-       66,   96,   96,   96,   96,   96,   96,   96,   96,   96,
-       97,   97,   97,   97,   97,   97,   97,   97,   97,   98,
-
-       98,   98,   98,   98,   98,   98,  114,  203,  114,  202,
-      201,  114,  114,  142,  199,  142,  198,  193,  142,  142,
-      192,  190,  189,  188,  187,  185,  178,  177,  176,  174,
-      173,  172,  169,  168,  167,  166,  164,  163,  162,  161,
-      160,  159,  154,  153,  152,  150,  149,  148,  145,  114,
-      141,  140,  139,  137,  136,  135,  142,  227,  134,  227,
-      227,  227,  227,  227,  227,  227,  227,  228,  133,  132,
-      228,  228,  228,  228,  228,  228,  228,  229,  130,  229,
-      229,  229,  229,  229,  229,  229,  229,  230,  230,  230,
-      231,  231,  129,  127,  231,  232,  126,  232,  232,  232,
-
-      233,  125,  233,  233,  233,  234,  124,  234,  234,  234,
-      235,  123,  122,  235,  236,  121,  236,  237,  120,  237,
-      237,  118,  117,  116,  113,  112,  111,  110,  109,  108,
-      107,  106,  105,  104,  103,  102,  101,   94,   93,   92,
-       91,   90,   89,   88,   87,   86,   85,   84,   83,   82,
-       81,   80,   77,   76,   75,   73,   72,   71,   70,   64,
-       60,   53,   44,   42,   41,   33,   31,   29,   27,   11,
-        3,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
-      226,  226,  226,  226,  226
+        1,    9,   13,   18,   18,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   19,   37,   18,   39,   21,   39,
+       43,   44,   37,   54,   45,   44,  234,   49,   37,   43,
+
+      230,   65,   58,   65,  229,   13,   21,   45,    9,   20,
+       20,   20,   20,   20,   20,   20,   20,   20,   20,   36,
+       58,   21,   36,  227,   61,   62,   54,   20,   89,  148,
+       36,   20,  178,   20,   49,   58,  148,  225,   36,   61,
+       62,  157,   20,  157,   89,  223,  157,  178,   63,  222,
+       63,   20,  196,  219,  196,  218,  217,  196,   20,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   63,  216,
+      215,  213,  212,  211,  210,   63,   66,   66,   66,   66,
+       66,   66,   66,   97,   97,   97,   97,   97,   97,   97,
+       97,   97,   98,   98,   98,   98,   98,   98,   98,   98,
+
+       98,   99,   99,   99,   99,   99,   99,   99,  114,  209,
+      114,  208,  206,  114,  114,  144,  205,  144,  204,  203,
+      144,  144,  198,  197,  195,  194,  193,  192,  191,  190,
+      189,  181,  180,  179,  177,  176,  175,  174,  172,  171,
+      170,  169,  167,  166,  165,  164,  163,  162,  161,  114,
+      156,  155,  154,  152,  151,  149,  144,  237,  145,  237,
+      237,  237,  237,  237,  237,  237,  237,  238,  143,  142,
+      238,  238,  238,  238,  238,  238,  238,  239,  141,  239,
+      239,  239,  239,  239,  239,  239,  239,  240,  240,  240,
+      241,  241,  140,  138,  241,  242,  137,  242,  242,  242,
+
+      243,  136,  243,  243,  243,  244,  135,  244,  244,  244,
+      245,  134,  133,  245,  246,  131,  246,  247,  130,  247,
+      247,  128,  127,  126,  125,  124,  123,  122,  120,  119,
+      118,  117,  116,  113,  112,  111,  110,  109,  108,  107,
+      106,  105,  104,  103,  102,   95,   94,   93,   92,   91,
+       90,   88,   86,   85,   84,   83,   82,   81,   80,   79,
+       78,   77,   76,   73,   71,   70,   64,   60,   53,   42,
+       41,   40,   35,   31,   30,   29,   27,   11,    3,  236,
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+      236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
+      236
     } ;
 
 /* Table of booleans, true if rule could match eol. */
-static const flex_int32_t yy_rule_can_match_eol[68] =
+static const flex_int32_t yy_rule_can_match_eol[72] =
     {   0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 1, 0, 0, 0, 0,     };
+    0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,     };
 
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
@@ -938,9 +943,9 @@ yyfree(void *ptr, yyscan_t yyscanner)
     ndt_free(ptr);
 }
 
-#line 941 "lexer.c"
+#line 946 "lexer.c"
 #define YY_NO_INPUT 1
-#line 943 "lexer.c"
+#line 948 "lexer.c"
 
 #define INITIAL 0
 
@@ -1223,7 +1228,7 @@ YY_DECL
 #line 127 "lexer.l"
 
 
-#line 1226 "lexer.c"
+#line 1231 "lexer.c"
 
 	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
 		{
@@ -1250,13 +1255,13 @@ yy_match:
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 227 )
+				if ( yy_current_state >= 237 )
 					yy_c = yy_meta[yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
 			++yy_cp;
 			}
-		while ( yy_current_state != 226 );
+		while ( yy_current_state != 236 );
 		yy_cp = yyg->yy_last_accepting_cpos;
 		yy_current_state = yyg->yy_last_accepting_state;
 
@@ -1381,260 +1386,280 @@ YY_RULE_SETUP
 case 17:
 YY_RULE_SETUP
 #line 160 "lexer.l"
-{ return FLOAT16; }
+{ return BFLOAT16; }
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
 #line 161 "lexer.l"
-{ return FLOAT32; }
+{ return FLOAT16; }
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
 #line 162 "lexer.l"
-{ return FLOAT64; }
+{ return FLOAT32; }
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 164 "lexer.l"
-{ return COMPLEX_KIND; }
+#line 163 "lexer.l"
+{ return FLOAT64; }
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
 #line 165 "lexer.l"
-{ return COMPLEX32; }
+{ return COMPLEX_KIND; }
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
 #line 166 "lexer.l"
-{ return COMPLEX64; }
+{ return BCOMPLEX32; }
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
 #line 167 "lexer.l"
-{ return COMPLEX128; }
+{ return COMPLEX32; }
 	YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 169 "lexer.l"
-{ return INTPTR; }
+#line 168 "lexer.l"
+{ return COMPLEX64; }
 	YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 170 "lexer.l"
-{ return UINTPTR; }
+#line 169 "lexer.l"
+{ return COMPLEX128; }
 	YY_BREAK
 case 26:
 YY_RULE_SETUP
 #line 171 "lexer.l"
-{ return SIZE; }
+{ return INTPTR; }
 	YY_BREAK
 case 27:
 YY_RULE_SETUP
 #line 172 "lexer.l"
-{ return CHAR; }
+{ return UINTPTR; }
 	YY_BREAK
 case 28:
 YY_RULE_SETUP
 #line 173 "lexer.l"
-{ return STRING; }
+{ return SIZE; }
 	YY_BREAK
 case 29:
 YY_RULE_SETUP
 #line 174 "lexer.l"
-{ return BYTES; }
+{ return CHAR; }
 	YY_BREAK
 case 30:
 YY_RULE_SETUP
-#line 176 "lexer.l"
-{ return FIXED_STRING_KIND; }
+#line 175 "lexer.l"
+{ return STRING; }
 	YY_BREAK
 case 31:
 YY_RULE_SETUP
-#line 177 "lexer.l"
-{ return FIXED_STRING; }
+#line 176 "lexer.l"
+{ return BYTES; }
 	YY_BREAK
 case 32:
 YY_RULE_SETUP
-#line 179 "lexer.l"
-{ return FIXED_BYTES_KIND; }
+#line 178 "lexer.l"
+{ return FIXED_STRING_KIND; }
 	YY_BREAK
 case 33:
 YY_RULE_SETUP
-#line 180 "lexer.l"
-{ return FIXED_BYTES; }
+#line 179 "lexer.l"
+{ return FIXED_STRING; }
 	YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 182 "lexer.l"
-{ return CATEGORICAL; }
+#line 181 "lexer.l"
+{ return FIXED_BYTES_KIND; }
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
-#line 183 "lexer.l"
-{ return NA; }
+#line 182 "lexer.l"
+{ return FIXED_BYTES; }
 	YY_BREAK
 case 36:
 YY_RULE_SETUP
-#line 185 "lexer.l"
-{ return REF; }
+#line 184 "lexer.l"
+{ return CATEGORICAL; }
 	YY_BREAK
 case 37:
 YY_RULE_SETUP
-#line 187 "lexer.l"
-{ return FIXED; }
+#line 185 "lexer.l"
+{ return NA; }
 	YY_BREAK
 case 38:
 YY_RULE_SETUP
-#line 188 "lexer.l"
-{ return VAR; }
+#line 187 "lexer.l"
+{ return REF; }
 	YY_BREAK
 case 39:
 YY_RULE_SETUP
-#line 190 "lexer.l"
-{ return ELLIPSIS; }
+#line 189 "lexer.l"
+{ return FIXED; }
 	YY_BREAK
 case 40:
 YY_RULE_SETUP
-#line 191 "lexer.l"
-{ return RARROW; }
+#line 190 "lexer.l"
+{ return VAR; }
 	YY_BREAK
 case 41:
 YY_RULE_SETUP
-#line 192 "lexer.l"
-{ return COMMA; }
+#line 191 "lexer.l"
+{ return ARRAY; }
 	YY_BREAK
 case 42:
 YY_RULE_SETUP
 #line 193 "lexer.l"
-{ return COLON; }
+{ return OF; }
 	YY_BREAK
 case 43:
 YY_RULE_SETUP
-#line 194 "lexer.l"
-{ return LPAREN; }
+#line 195 "lexer.l"
+{ return ELLIPSIS; }
 	YY_BREAK
 case 44:
 YY_RULE_SETUP
-#line 195 "lexer.l"
-{ return RPAREN; }
+#line 196 "lexer.l"
+{ return RARROW; }
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
-#line 196 "lexer.l"
-{ return LBRACE; }
+#line 197 "lexer.l"
+{ return COMMA; }
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
-#line 197 "lexer.l"
-{ return RBRACE; }
+#line 198 "lexer.l"
+{ return COLON; }
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
-#line 198 "lexer.l"
-{ return LBRACK; }
+#line 199 "lexer.l"
+{ return LPAREN; }
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
-#line 199 "lexer.l"
-{ return RBRACK; }
+#line 200 "lexer.l"
+{ return RPAREN; }
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
-#line 200 "lexer.l"
-{ return STAR; }
+#line 201 "lexer.l"
+{ return LBRACE; }
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
-#line 201 "lexer.l"
-{ return EQUAL; }
+#line 202 "lexer.l"
+{ return RBRACE; }
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
-#line 202 "lexer.l"
-{ return QUESTIONMARK; }
+#line 203 "lexer.l"
+{ return LBRACK; }
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
-#line 203 "lexer.l"
-{ return BANG; }
+#line 204 "lexer.l"
+{ return RBRACK; }
 	YY_BREAK
 case 53:
 YY_RULE_SETUP
-#line 204 "lexer.l"
-{ return AMPERSAND; }
+#line 205 "lexer.l"
+{ return STAR; }
 	YY_BREAK
 case 54:
 YY_RULE_SETUP
-#line 205 "lexer.l"
-{ return BAR; }
+#line 206 "lexer.l"
+{ return EQUAL; }
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
-#line 206 "lexer.l"
-{ return LESS; }
+#line 207 "lexer.l"
+{ return QUESTIONMARK; }
 	YY_BREAK
 case 56:
 YY_RULE_SETUP
-#line 207 "lexer.l"
-{ return GREATER; }
+#line 208 "lexer.l"
+{ return BANG; }
 	YY_BREAK
 case 57:
 YY_RULE_SETUP
 #line 209 "lexer.l"
-{ yylval->string = ndt_strdup(yytext, ctx); if (yylval->string == NULL) return ERRTOKEN; return NAME_LOWER; }
+{ return AMPERSAND; }
 	YY_BREAK
 case 58:
 YY_RULE_SETUP
 #line 210 "lexer.l"
-{ yylval->string = ndt_strdup(yytext, ctx); if (yylval->string == NULL) return ERRTOKEN; return NAME_UPPER; }
+{ return BAR; }
 	YY_BREAK
 case 59:
 YY_RULE_SETUP
 #line 211 "lexer.l"
-{ yylval->string = ndt_strdup(yytext, ctx); if (yylval->string == NULL) return ERRTOKEN; return NAME_OTHER; }
+{ return LESS; }
 	YY_BREAK
 case 60:
 YY_RULE_SETUP
-#line 213 "lexer.l"
-{ yylval->string = mk_stringlit(yytext, ctx); if (yylval->string == NULL) return ERRTOKEN; return STRINGLIT; }
+#line 212 "lexer.l"
+{ return GREATER; }
 	YY_BREAK
 case 61:
 YY_RULE_SETUP
 #line 214 "lexer.l"
-{ yylval->string = ndt_strdup(yytext, ctx); if (yylval->string == NULL) return ERRTOKEN; return INTEGER; }
+{ yylval->string = ndt_strdup(yytext, ctx); if (yylval->string == NULL) return ERRTOKEN; return NAME_LOWER; }
 	YY_BREAK
 case 62:
 YY_RULE_SETUP
 #line 215 "lexer.l"
-{ yylval->string = ndt_strdup(yytext, ctx); if (yylval->string == NULL) return ERRTOKEN; return FLOATNUMBER; }
+{ yylval->string = ndt_strdup(yytext, ctx); if (yylval->string == NULL) return ERRTOKEN; return NAME_UPPER; }
 	YY_BREAK
 case 63:
-/* rule 63 can match eol */
 YY_RULE_SETUP
-#line 217 "lexer.l"
-{ yycolumn = 1; }
+#line 216 "lexer.l"
+{ yylval->string = ndt_strdup(yytext, ctx); if (yylval->string == NULL) return ERRTOKEN; return NAME_OTHER; }
 	YY_BREAK
 case 64:
 YY_RULE_SETUP
 #line 218 "lexer.l"
-{} /* ignore */
+{ yylval->string = mk_stringlit(yytext, ctx); if (yylval->string == NULL) return ERRTOKEN; return STRINGLIT; }
 	YY_BREAK
 case 65:
 YY_RULE_SETUP
 #line 219 "lexer.l"
-{} /* ignore */
+{ yylval->string = ndt_strdup(yytext, ctx); if (yylval->string == NULL) return ERRTOKEN; return INTEGER; }
 	YY_BREAK
 case 66:
 YY_RULE_SETUP
 #line 220 "lexer.l"
-{ return ERRTOKEN; }
+{ yylval->string = ndt_strdup(yytext, ctx); if (yylval->string == NULL) return ERRTOKEN; return FLOATNUMBER; }
 	YY_BREAK
 case 67:
+/* rule 67 can match eol */
 YY_RULE_SETUP
 #line 222 "lexer.l"
+{ yycolumn = 1; }
+	YY_BREAK
+case 68:
+YY_RULE_SETUP
+#line 223 "lexer.l"
+{} /* ignore */
+	YY_BREAK
+case 69:
+YY_RULE_SETUP
+#line 224 "lexer.l"
+{} /* ignore */
+	YY_BREAK
+case 70:
+YY_RULE_SETUP
+#line 225 "lexer.l"
+{ return ERRTOKEN; }
+	YY_BREAK
+case 71:
+YY_RULE_SETUP
+#line 227 "lexer.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 1637 "lexer.c"
+#line 1662 "lexer.c"
 case YY_STATE_EOF(INITIAL):
 	yyterminate();
 
@@ -1934,7 +1959,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 227 )
+			if ( yy_current_state >= 237 )
 				yy_c = yy_meta[yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
@@ -1963,11 +1988,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 227 )
+		if ( yy_current_state >= 237 )
 			yy_c = yy_meta[yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-	yy_is_jam = (yy_current_state == 226);
+	yy_is_jam = (yy_current_state == 236);
 
 	(void)yyg;
 	return yy_is_jam ? 0 : yy_current_state;
@@ -2768,6 +2793,6 @@ static int yy_flex_strlen (const char * s , yyscan_t yyscanner)
 
 #define YYTABLES_NAME "yytables"
 
-#line 222 "lexer.l"
+#line 227 "lexer.l"