ndtypes 0.2.0dev5 → 0.2.0dev6

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

@@ -193,7 +193,7 @@ ndt_aligned_calloc(uint16_t alignment, int64_t size)
     uintptr = (uintptr_t)ptr;
     aligned = uintptr + extra;
     if (aligned < uintptr) {
-        free(ptr);
+        ndt_free(ptr);
         return NULL;
     }
 

data/ext/ruby_ndtypes/ndtypes/libndtypes/compat/Makefile

@@ -0,0 +1,73 @@
+
+CC = gcc
+LD = gcc
+
+CONFIGURE_CFLAGS = -I.. -Wall -Wextra -std=c11 -pedantic -O2 -g
+NDT_CFLAGS = $(strip $(CONFIGURE_CFLAGS) $(CFLAGS))
+NDT_CFLAGS_SHARED = $(NDT_CFLAGS) -fPIC
+
+CONFIGURE_COV_CFLAGS = -I.. -Wall -Wextra -std=c11 -pedantic -O0 -g -fno-inline -fprofile-arcs -ftest-coverage
+ifeq ($(MAKECMDGOALS), coverage)
+  NDT_CFLAGS = $(strip $(CONFIGURE_COV_CFLAGS) $(CFLAGS))
+endif
+
+
+OBJS = bpgrammar.o bplexer.o import.o export.o
+SHARED_OBJS = .objs/bpgrammar.o .objs/bplexer.o .objs/import.o .objs/export.o
+
+
+default: $(OBJS) $(SHARED_OBJS)
+
+
+bpgrammar.o:\
+Makefile bpgrammar.c bpgrammar.h bplexer.h ../ndtypes.h ../seq.h
+	$(CC) $(NDT_CFLAGS) -c bpgrammar.c
+
+.objs/bpgrammar.o:\
+Makefile bpgrammar.c bpgrammar.h bplexer.h ../ndtypes.h ../seq.h
+	$(CC) $(NDT_CFLAGS_SHARED) -c bpgrammar.c -o .objs/bpgrammar.o
+
+bplexer.o:\
+Makefile bplexer.c bpgrammar.h bplexer.h
+	$(CC) $(NDT_CFLAGS) -c bplexer.c
+
+.objs/bplexer.o:\
+Makefile bplexer.c bpgrammar.h bplexer.h
+	$(CC) $(NDT_CFLAGS_SHARED) -c bplexer.c -o .objs/bplexer.o
+
+import.o:\
+Makefile import.c bpgrammar.h bplexer.h ../ndtypes.h ../seq.h
+	$(CC) $(NDT_CFLAGS) -c import.c
+
+.objs/import.o:\
+Makefile import.c bpgrammar.h bplexer.h ../ndtypes.h ../seq.h
+	$(CC) $(NDT_CFLAGS_SHARED) -c import.c -o .objs/import.o
+
+export.o:\
+Makefile export.c bpgrammar.h bplexer.h ../ndtypes.h ../seq.h
+	$(CC) $(NDT_CFLAGS) -c export.c
+
+.objs/export.o:\
+Makefile export.c bpgrammar.h bplexer.h ../ndtypes.h ../seq.h
+	$(CC) $(NDT_CFLAGS_SHARED) -c export.c -o .objs/export.o
+
+
+# Without these, GNU make automatically builds the parser.
+%.c: %.y
+%.c: %.l
+
+parser: FORCE
+	bison -Wall -o bpgrammar.c -pndt_bp --defines=bpgrammar.h bpgrammar.y
+	flex -o bplexer.c -Pndt_bp --header-file=bplexer.h bplexer.l
+
+
+FORCE:
+
+clean: FORCE
+	rm -f *.o *.so *.gch *.gcda *.gcno *.gcov *.dyn *.dpi *.lock
+	cd .objs && rm -f *.o *.so *.gch *.gcda *.gcno *.gcov *.dyn *.dpi *.lock
+
+distclean: clean
+	rm -f Makefile
+
+

data/ext/ruby_ndtypes/ndtypes/libndtypes/compat/bpgrammar.c

@@ -1,8 +1,9 @@
-/* A Bison parser, made by GNU Bison 3.0.4.  */
+/* A Bison parser, made by GNU Bison 3.3.  */
 
 /* Bison implementation for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 Free Software Foundation,
+   Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -40,11 +41,14 @@
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
 
+/* Undocumented macros, especially those whose name start with YY_,
+   are private implementation details.  Do not rely on them.  */
+
 /* Identify Bison output.  */
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "3.0.4"
+#define YYBISON_VERSION "3.3"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -67,8 +71,8 @@
 #define yynerrs         ndt_bpnerrs
 
 
-/* Copy the first part of user declarations.  */
-#line 1 "bpgrammar.y" /* yacc.c:339  */
+/* First part of user prologue.  */
+#line 1 "bpgrammar.y" /* yacc.c:337  */
 
 /*
  * BSD 3-Clause License
@@ -108,7 +112,7 @@
 
 
 void
-yyerror(YYLTYPE *loc, yyscan_t scanner, ndt_t **ast, ndt_context_t *ctx,
+yyerror(YYLTYPE *loc, yyscan_t scanner, const ndt_t **ast, ndt_context_t *ctx,
         const char *msg)
 {
     (void)scanner;
@@ -138,13 +142,13 @@ add_uint16(uint16_t a, uint16_t b, ndt_context_t *ctx)
     return c;
 }
 
-static ndt_t *
+static const ndt_t *
 primitive_native(char dtype, ndt_context_t *ctx)
 {
     switch (dtype) {
     case '?': return ndt_primitive(Bool, 0, ctx);
 
-    case 'c': return ndt_char(Ascii, ctx);
+    case 'c': return ndt_char(Ascii, false, ctx);
     case 'b': return ndt_primitive(Int8, 0, ctx);
     case 'B': return ndt_primitive(Uint8, 0, ctx);
 
@@ -175,13 +179,13 @@ primitive_native(char dtype, ndt_context_t *ctx)
     }
 }
 
-static ndt_t *
+static const ndt_t *
 primitive_fixed(char dtype, uint32_t flags, ndt_context_t *ctx)
 {
     switch (dtype) {
     case '?': return ndt_primitive(Bool, flags, ctx);
 
-    case 'c': return ndt_char(Ascii, ctx);
+    case 'c': return ndt_char(Ascii, false, ctx);
     case 'b': return ndt_primitive(Int8, flags, ctx);
     case 'B': return ndt_primitive(Uint8, flags, ctx);
 
@@ -210,7 +214,7 @@ primitive_fixed(char dtype, uint32_t flags, ndt_context_t *ctx)
     }
 }
 
-static ndt_t *
+static const ndt_t *
 make_dtype(char modifier, char dtype, ndt_context_t *ctx)
 {
     switch (modifier) {
@@ -231,7 +235,7 @@ make_dtype(char modifier, char dtype, ndt_context_t *ctx)
     }
 }
 
-static ndt_t *
+static const ndt_t *
 make_fixed_bytes(char *v, ndt_context_t *ctx)
 {
     uint16_opt_t align = {None, 0};
@@ -251,13 +255,13 @@ make_fixed_bytes(char *v, ndt_context_t *ctx)
         return NULL;
     }
 
-    return ndt_fixed_bytes(datasize, align, ctx);
+    return ndt_fixed_bytes(datasize, align, false, ctx);
 }
 
-static ndt_t *
-make_dimensions(ndt_string_seq_t *seq, ndt_t *type, ndt_context_t *ctx)
+static const ndt_t *
+make_dimensions(ndt_string_seq_t *seq, const ndt_t *type, ndt_context_t *ctx)
 {
-    ndt_t *t;
+    const ndt_t *t;
     int64_t shape;
     int64_t i;
 
@@ -265,18 +269,21 @@ make_dimensions(ndt_string_seq_t *seq, ndt_t *type, ndt_context_t *ctx)
         ndt_err_format(ctx, NDT_ValueError,
             "number of dimensions must be between 1 and %d", NDT_MAX_DIM);
         ndt_string_seq_del(seq);
-        ndt_del(type);
+        ndt_decref(type);
         return NULL;
     }
 
+
     for (i=seq->len-1, t=type; i>=0; i--, type=t) {
         shape = ndt_strtoll(seq->ptr[i], 0, INT_MAX, ctx);
         if (ndt_err_occurred(ctx)) {
             ndt_string_seq_del(seq);
+            ndt_decref(type);
             return NULL;
         }
 
         t = ndt_fixed_dim(type, shape, INT64_MAX, ctx);
+        ndt_decref(type);
         if (t == NULL) {
             ndt_string_seq_del(seq);
             return NULL;
@@ -289,27 +296,32 @@ make_dimensions(ndt_string_seq_t *seq, ndt_t *type, ndt_context_t *ctx)
 }
 
 static ndt_field_t *
-make_field(char *name, ndt_t *type, uint16_t padding, ndt_context_t *ctx)
+make_field(char *name, const ndt_t *type, uint16_t padding, ndt_context_t *ctx)
 {
     uint16_opt_t align = {None, 0};
     uint16_opt_t pack = {None, 0};
     uint16_opt_t pad = {Some, 0};
+    ndt_field_t *f;
 
     pad.Some = padding;
-    return ndt_field(name, type, align, pack, pad, ctx);
+    f = ndt_field(name, type, align, pack, pad, ctx);
+    ndt_decref(type);
+    return f;
 }
 
-static ndt_t *
+static const ndt_t *
 make_record(ndt_field_seq_t *fields, ndt_context_t *ctx)
 {
     uint16_opt_t align = {None, 0};
     uint16_opt_t pack = {None, 0};
-    ndt_t *t;
+    const ndt_t *t;
     int64_t i;
 
     fields = ndt_field_seq_finalize(fields);
     if (fields == NULL) {
-        return ndt_record(Nonvariadic, NULL, 0, align, pack, ctx);
+        t = ndt_record(Nonvariadic, NULL, 0, align, pack, false, ctx);
+        ndt_field_seq_del(fields);
+        return t;
     }
 
     assert(fields->len >= 1);
@@ -326,18 +338,19 @@ make_record(ndt_field_seq_t *fields, ndt_context_t *ctx)
         fields->ptr[i].Concrete.explicit_align = true;
     }
 
-    t = ndt_record(Nonvariadic, fields->ptr, fields->len, align, pack, ctx);
-    ndt_free(fields);
+    t = ndt_record(Nonvariadic, fields->ptr, fields->len, align, pack, false, ctx);
+    ndt_field_seq_del(fields);
 
     return t;
 }
 
 static ndt_type_seq_t *
-broadcast_seq_new(ndt_t *type, ndt_context_t *ctx)
+broadcast_seq_new(const ndt_t *type, ndt_context_t *ctx)
 {
     ndt_t *t;
 
-    t = ndt_ellipsis_dim(NULL, type, ctx);
+    t = (ndt_t *)ndt_ellipsis_dim(NULL, type, ctx);
+    ndt_decref(type);
     if (t == NULL) {
         return NULL;
     }
@@ -346,11 +359,12 @@ broadcast_seq_new(ndt_t *type, ndt_context_t *ctx)
 }
 
 static ndt_type_seq_t *
-broadcast_seq_append(ndt_type_seq_t *seq, ndt_t *type, ndt_context_t *ctx)
+broadcast_seq_append(ndt_type_seq_t *seq, const ndt_t *type, ndt_context_t *ctx)
 {
     ndt_t *t;
 
-    t = ndt_ellipsis_dim(NULL, type, ctx);
+    t = (ndt_t *)ndt_ellipsis_dim(NULL, type, ctx);
+    ndt_decref(type);
     if (t == NULL) {
         ndt_type_seq_del(seq);
         return NULL;
@@ -359,13 +373,16 @@ broadcast_seq_append(ndt_type_seq_t *seq, ndt_t *type, ndt_context_t *ctx)
     return ndt_type_seq_append(seq, t, ctx);
 }
 
-#line 363 "bpgrammar.c" /* yacc.c:339  */
-
+#line 377 "bpgrammar.c" /* yacc.c:337  */
 # ifndef YY_NULLPTR
-#  if defined __cplusplus && 201103L <= __cplusplus
-#   define YY_NULLPTR nullptr
+#  if defined __cplusplus
+#   if 201103L <= __cplusplus
+#    define YY_NULLPTR nullptr
+#   else
+#    define YY_NULLPTR 0
+#   endif
 #  else
-#   define YY_NULLPTR 0
+#   define YY_NULLPTR ((void*)0)
 #  endif
 # endif
 
@@ -389,7 +406,7 @@ broadcast_seq_append(ndt_type_seq_t *seq, ndt_t *type, ndt_context_t *ctx)
 extern int ndt_bpdebug;
 #endif
 /* "%code requires" blocks.  */
-#line 292 "bpgrammar.y" /* yacc.c:355  */
+#line 302 "bpgrammar.y" /* yacc.c:352  */
 
   #include <ctype.h>
   #include <assert.h>
@@ -400,7 +417,7 @@ extern int ndt_bpdebug;
   #define YY_TYPEDEF_YY_SCANNER_T
   typedef void * yyscan_t;
 
-#line 404 "bpgrammar.c" /* yacc.c:355  */
+#line 421 "bpgrammar.c" /* yacc.c:352  */
 
 /* Token type.  */
 #ifndef YYTOKENTYPE
@@ -435,9 +452,9 @@ extern int ndt_bpdebug;
 
 union YYSTYPE
 {
-#line 325 "bpgrammar.y" /* yacc.c:355  */
+#line 335 "bpgrammar.y" /* yacc.c:352  */
 
-    ndt_t *ndt;
+    const ndt_t *ndt;
     ndt_field_t *field;
     ndt_field_seq_t *field_seq;
     ndt_string_seq_t *string_seq;
@@ -446,7 +463,7 @@ union YYSTYPE
     unsigned char uchar;
     uint16_t uint16;
 
-#line 450 "bpgrammar.c" /* yacc.c:355  */
+#line 467 "bpgrammar.c" /* yacc.c:352  */
 };
 
 typedef union YYSTYPE YYSTYPE;
@@ -470,21 +487,19 @@ struct YYLTYPE
 
 
 
-int ndt_bpparse (yyscan_t scanner, ndt_t **ast, ndt_context_t *ctx);
+int ndt_bpparse (yyscan_t scanner, const ndt_t **ast, ndt_context_t *ctx);
 /* "%code provides" blocks.  */
-#line 303 "bpgrammar.y" /* yacc.c:355  */
+#line 313 "bpgrammar.y" /* yacc.c:352  */
 
   #define YY_DECL extern int ndt_bplexfunc(YYSTYPE *yylval_param, YYLTYPE *yylloc_param, yyscan_t yyscanner, ndt_context_t *ctx)
   extern int ndt_bplexfunc(YYSTYPE *, YYLTYPE *, yyscan_t, ndt_context_t *);
-  void yyerror(YYLTYPE *loc, yyscan_t scanner, ndt_t **ast, ndt_context_t *ctx, const char *msg);
+  void yyerror(YYLTYPE *loc, yyscan_t scanner, const  ndt_t **ast, ndt_context_t *ctx, const char *msg);
 
-#line 482 "bpgrammar.c" /* yacc.c:355  */
+#line 499 "bpgrammar.c" /* yacc.c:352  */
 
 #endif /* !YY_NDT_BP_BPGRAMMAR_H_INCLUDED  */
 
-/* Copy the second part of user declarations.  */
 
-#line 488 "bpgrammar.c" /* yacc.c:358  */
 
 #ifdef short
 # undef short
@@ -505,13 +520,13 @@ typedef signed char yytype_int8;
 #ifdef YYTYPE_UINT16
 typedef YYTYPE_UINT16 yytype_uint16;
 #else
-typedef unsigned short int yytype_uint16;
+typedef unsigned short yytype_uint16;
 #endif
 
 #ifdef YYTYPE_INT16
 typedef YYTYPE_INT16 yytype_int16;
 #else
-typedef short int yytype_int16;
+typedef short yytype_int16;
 #endif
 
 #ifndef YYSIZE_T
@@ -523,7 +538,7 @@ typedef short int yytype_int16;
 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 #  define YYSIZE_T size_t
 # else
-#  define YYSIZE_T unsigned int
+#  define YYSIZE_T unsigned
 # endif
 #endif
 
@@ -559,15 +574,6 @@ typedef short int yytype_int16;
 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
 #endif
 
-#if !defined _Noreturn \
-     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
-# if defined _MSC_VER && 1200 <= _MSC_VER
-#  define _Noreturn __declspec (noreturn)
-# else
-#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
-# endif
-#endif
-
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
 # define YYUSE(E) ((void) (E))
@@ -575,7 +581,7 @@ typedef short int yytype_int16;
 # define YYUSE(E) /* empty */
 #endif
 
-#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
     _Pragma ("GCC diagnostic push") \
@@ -739,16 +745,16 @@ union yyalloc
 /* YYNSTATES -- Number of states.  */
 #define YYNSTATES  42
 
-/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
-   by yylex, with out-of-bounds checking.  */
 #define YYUNDEFTOK  2
 #define YYMAXUTOK   276
 
+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, with out-of-bounds checking.  */
 #define YYTRANSLATE(YYX)                                                \
-  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+  ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
-   as returned by yylex, without out-of-bounds checking.  */
+   as returned by yylex.  */
 static const yytype_uint8 yytranslate[] =
 {
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -785,9 +791,9 @@ static const yytype_uint8 yytranslate[] =
   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   379,   379,   382,   383,   384,   387,   388,   391,   392,
-     393,   396,   399,   400,   403,   406,   409,   410,   413,   414,
-     415,   416,   417,   418,   421,   422,   425,   426
+       0,   389,   389,   392,   393,   394,   397,   398,   401,   402,
+     403,   406,   409,   410,   413,   416,   419,   420,   423,   424,
+     425,   426,   427,   428,   431,   432,   435,   436
 };
 #endif
 
@@ -932,22 +938,22 @@ static const yytype_uint8 yyr2[] =
 
 #define YYRECOVERING()  (!!yyerrstatus)
 
-#define YYBACKUP(Token, Value)                                  \
-do                                                              \
-  if (yychar == YYEMPTY)                                        \
-    {                                                           \
-      yychar = (Token);                                         \
-      yylval = (Value);                                         \
-      YYPOPSTACK (yylen);                                       \
-      yystate = *yyssp;                                         \
-      goto yybackup;                                            \
-    }                                                           \
-  else                                                          \
-    {                                                           \
-      yyerror (&yylloc, scanner, ast, ctx, YY_("syntax error: cannot back up")); \
-      YYERROR;                                                  \
-    }                                                           \
-while (0)
+#define YYBACKUP(Token, Value)                                    \
+  do                                                              \
+    if (yychar == YYEMPTY)                                        \
+      {                                                           \
+        yychar = (Token);                                         \
+        yylval = (Value);                                         \
+        YYPOPSTACK (yylen);                                       \
+        yystate = *yyssp;                                         \
+        goto yybackup;                                            \
+      }                                                           \
+    else                                                          \
+      {                                                           \
+        yyerror (&yylloc, scanner, ast, ctx, YY_("syntax error: cannot back up")); \
+        YYERROR;                                                  \
+      }                                                           \
+  while (0)
 
 /* Error token number */
 #define YYTERROR        1
@@ -1006,10 +1012,10 @@ do {                                            \
 /* Print *YYLOCP on YYO.  Private, do not rely on its existence. */
 
 YY_ATTRIBUTE_UNUSED
-static unsigned
+static int
 yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
 {
-  unsigned res = 0;
+  int res = 0;
   int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
   if (0 <= yylocp->first_line)
     {
@@ -1052,15 +1058,15 @@ do {                                                                      \
 } while (0)
 
 
-/*----------------------------------------.
-| Print this symbol's value on YYOUTPUT.  |
-`----------------------------------------*/
+/*-----------------------------------.
+| Print this symbol's value on YYO.  |
+`-----------------------------------*/
 
 static void
-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, yyscan_t scanner, ndt_t **ast, ndt_context_t *ctx)
+yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, yyscan_t scanner, const ndt_t **ast, ndt_context_t *ctx)
 {
-  FILE *yyo = yyoutput;
-  YYUSE (yyo);
+  FILE *yyoutput = yyo;
+  YYUSE (yyoutput);
   YYUSE (yylocationp);
   YYUSE (scanner);
   YYUSE (ast);
@@ -1069,26 +1075,26 @@ yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvalue
     return;
 # ifdef YYPRINT
   if (yytype < YYNTOKENS)
-    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+    YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
 # endif
   YYUSE (yytype);
 }
 
 
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
+/*---------------------------.
+| Print this symbol on YYO.  |
+`---------------------------*/
 
 static void
-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, yyscan_t scanner, ndt_t **ast, ndt_context_t *ctx)
+yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, yyscan_t scanner, const ndt_t **ast, ndt_context_t *ctx)
 {
-  YYFPRINTF (yyoutput, "%s %s (",
+  YYFPRINTF (yyo, "%s %s (",
              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
 
-  YY_LOCATION_PRINT (yyoutput, *yylocationp);
-  YYFPRINTF (yyoutput, ": ");
-  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, scanner, ast, ctx);
-  YYFPRINTF (yyoutput, ")");
+  YY_LOCATION_PRINT (yyo, *yylocationp);
+  YYFPRINTF (yyo, ": ");
+  yy_symbol_value_print (yyo, yytype, yyvaluep, yylocationp, scanner, ast, ctx);
+  YYFPRINTF (yyo, ")");
 }
 
 /*------------------------------------------------------------------.
@@ -1120,9 +1126,9 @@ do {                                                            \
 `------------------------------------------------*/
 
 static void
-yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, yyscan_t scanner, ndt_t **ast, ndt_context_t *ctx)
+yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, yyscan_t scanner, const ndt_t **ast, ndt_context_t *ctx)
 {
-  unsigned long int yylno = yyrline[yyrule];
+  unsigned long yylno = yyrline[yyrule];
   int yynrhs = yyr2[yyrule];
   int yyi;
   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
@@ -1133,7 +1139,7 @@ yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule
       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
       yy_symbol_print (stderr,
                        yystos[yyssp[yyi + 1 - yynrhs]],
-                       &(yyvsp[(yyi + 1) - (yynrhs)])
+                       &yyvsp[(yyi + 1) - (yynrhs)]
                        , &(yylsp[(yyi + 1) - (yynrhs)])                       , scanner, ast, ctx);
       YYFPRINTF (stderr, "\n");
     }
@@ -1237,7 +1243,10 @@ yytnamerr (char *yyres, const char *yystr)
           case '\\':
             if (*++yyp != '\\')
               goto do_not_strip_quotes;
-            /* Fall through.  */
+            else
+              goto append;
+
+          append:
           default:
             if (yyres)
               yyres[yyn] = *yyp;
@@ -1255,7 +1264,7 @@ yytnamerr (char *yyres, const char *yystr)
   if (! yyres)
     return yystrlen (yystr);
 
-  return yystpcpy (yyres, yystr) - yyres;
+  return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres);
 }
 # endif
 
@@ -1333,10 +1342,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
                 yyarg[yycount++] = yytname[yyx];
                 {
                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
-                  if (! (yysize <= yysize1
-                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+                    yysize = yysize1;
+                  else
                     return 2;
-                  yysize = yysize1;
                 }
               }
         }
@@ -1348,6 +1357,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
       case N:                               \
         yyformat = S;                       \
       break
+    default: /* Avoid compiler warnings. */
       YYCASE_(0, YY_("syntax error"));
       YYCASE_(1, YY_("syntax error, unexpected %s"));
       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
@@ -1359,9 +1369,10 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
 
   {
     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
-    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+    if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
+      yysize = yysize1;
+    else
       return 2;
-    yysize = yysize1;
   }
 
   if (*yymsg_alloc < yysize)
@@ -1400,7 +1411,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
 `-----------------------------------------------*/
 
 static void
-yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, yyscan_t scanner, ndt_t **ast, ndt_context_t *ctx)
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, yyscan_t scanner, const ndt_t **ast, ndt_context_t *ctx)
 {
   YYUSE (yyvaluep);
   YYUSE (yylocationp);
@@ -1414,79 +1425,78 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   switch (yytype)
     {
-          case 20: /* INTEGER  */
-#line 374 "bpgrammar.y" /* yacc.c:1257  */
+    case 20: /* INTEGER  */
+#line 384 "bpgrammar.y" /* yacc.c:1257  */
       { ndt_free(((*yyvaluep).string)); }
-#line 1421 "bpgrammar.c" /* yacc.c:1257  */
+#line 1432 "bpgrammar.c" /* yacc.c:1257  */
         break;
 
     case 21: /* NAME  */
-#line 374 "bpgrammar.y" /* yacc.c:1257  */
+#line 384 "bpgrammar.y" /* yacc.c:1257  */
       { ndt_free(((*yyvaluep).string)); }
-#line 1427 "bpgrammar.c" /* yacc.c:1257  */
+#line 1438 "bpgrammar.c" /* yacc.c:1257  */
         break;
 
     case 23: /* input  */
-#line 369 "bpgrammar.y" /* yacc.c:1257  */
-      { ndt_del(((*yyvaluep).ndt)); }
-#line 1433 "bpgrammar.c" /* yacc.c:1257  */
+#line 379 "bpgrammar.y" /* yacc.c:1257  */
+      { ndt_decref(((*yyvaluep).ndt)); }
+#line 1444 "bpgrammar.c" /* yacc.c:1257  */
         break;
 
     case 24: /* datatype  */
-#line 369 "bpgrammar.y" /* yacc.c:1257  */
-      { ndt_del(((*yyvaluep).ndt)); }
-#line 1439 "bpgrammar.c" /* yacc.c:1257  */
+#line 379 "bpgrammar.y" /* yacc.c:1257  */
+      { ndt_decref(((*yyvaluep).ndt)); }
+#line 1450 "bpgrammar.c" /* yacc.c:1257  */
         break;
 
     case 25: /* dimensions  */
-#line 372 "bpgrammar.y" /* yacc.c:1257  */
+#line 382 "bpgrammar.y" /* yacc.c:1257  */
       { ndt_string_seq_del(((*yyvaluep).string_seq)); }
-#line 1445 "bpgrammar.c" /* yacc.c:1257  */
+#line 1456 "bpgrammar.c" /* yacc.c:1257  */
         break;
 
     case 26: /* dtype  */
-#line 369 "bpgrammar.y" /* yacc.c:1257  */
-      { ndt_del(((*yyvaluep).ndt)); }
-#line 1451 "bpgrammar.c" /* yacc.c:1257  */
+#line 379 "bpgrammar.y" /* yacc.c:1257  */
+      { ndt_decref(((*yyvaluep).ndt)); }
+#line 1462 "bpgrammar.c" /* yacc.c:1257  */
         break;
 
     case 27: /* record  */
-#line 369 "bpgrammar.y" /* yacc.c:1257  */
-      { ndt_del(((*yyvaluep).ndt)); }
-#line 1457 "bpgrammar.c" /* yacc.c:1257  */
+#line 379 "bpgrammar.y" /* yacc.c:1257  */
+      { ndt_decref(((*yyvaluep).ndt)); }
+#line 1468 "bpgrammar.c" /* yacc.c:1257  */
         break;
 
     case 28: /* field_seq  */
-#line 371 "bpgrammar.y" /* yacc.c:1257  */
+#line 381 "bpgrammar.y" /* yacc.c:1257  */
       { ndt_field_seq_del(((*yyvaluep).field_seq)); }
-#line 1463 "bpgrammar.c" /* yacc.c:1257  */
+#line 1474 "bpgrammar.c" /* yacc.c:1257  */
         break;
 
     case 29: /* field  */
-#line 370 "bpgrammar.y" /* yacc.c:1257  */
+#line 380 "bpgrammar.y" /* yacc.c:1257  */
       { ndt_field_del(((*yyvaluep).field)); }
-#line 1469 "bpgrammar.c" /* yacc.c:1257  */
+#line 1480 "bpgrammar.c" /* yacc.c:1257  */
         break;
 
     case 30: /* function  */
-#line 369 "bpgrammar.y" /* yacc.c:1257  */
-      { ndt_del(((*yyvaluep).ndt)); }
-#line 1475 "bpgrammar.c" /* yacc.c:1257  */
+#line 379 "bpgrammar.y" /* yacc.c:1257  */
+      { ndt_decref(((*yyvaluep).ndt)); }
+#line 1486 "bpgrammar.c" /* yacc.c:1257  */
         break;
 
     case 31: /* dtype_seq  */
-#line 373 "bpgrammar.y" /* yacc.c:1257  */
+#line 383 "bpgrammar.y" /* yacc.c:1257  */
       { ndt_type_seq_del(((*yyvaluep).type_seq)); }
-#line 1481 "bpgrammar.c" /* yacc.c:1257  */
+#line 1492 "bpgrammar.c" /* yacc.c:1257  */
         break;
 
     case 33: /* repeat  */
-#line 374 "bpgrammar.y" /* yacc.c:1257  */
+#line 384 "bpgrammar.y" /* yacc.c:1257  */
       { ndt_free(((*yyvaluep).string)); }
-#line 1487 "bpgrammar.c" /* yacc.c:1257  */
+#line 1498 "bpgrammar.c" /* yacc.c:1257  */
         break;
 
-
       default:
         break;
     }
@@ -1501,7 +1511,7 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio
 `----------*/
 
 int
-yyparse (yyscan_t scanner, ndt_t **ast, ndt_context_t *ctx)
+yyparse (yyscan_t scanner, const ndt_t **ast, ndt_context_t *ctx)
 {
 /* The lookahead symbol.  */
 int yychar;
@@ -1591,7 +1601,7 @@ YYLTYPE yylloc = yyloc_default;
   yychar = YYEMPTY; /* Cause a token to be read.  */
 
 /* User initialization code.  */
-#line 315 "bpgrammar.y" /* yacc.c:1429  */
+#line 325 "bpgrammar.y" /* yacc.c:1431  */
 {
    yylloc.first_line = 1;
    yylloc.first_column = 1;
@@ -1599,27 +1609,35 @@ YYLTYPE yylloc = yyloc_default;
    yylloc.last_column = 1;
 }
 
-#line 1603 "bpgrammar.c" /* yacc.c:1429  */
+#line 1613 "bpgrammar.c" /* yacc.c:1431  */
   yylsp[0] = yylloc;
   goto yysetstate;
 
+
 /*------------------------------------------------------------.
-| yynewstate -- Push a new state, which is found in yystate.  |
+| yynewstate -- push a new state, which is found in yystate.  |
 `------------------------------------------------------------*/
- yynewstate:
+yynewstate:
   /* In all cases, when you get here, the value and location stacks
      have just been pushed.  So pushing a state here evens the stacks.  */
   yyssp++;
 
- yysetstate:
-  *yyssp = yystate;
+
+/*--------------------------------------------------------------------.
+| yynewstate -- set current state (the top of the stack) to yystate.  |
+`--------------------------------------------------------------------*/
+yysetstate:
+  *yyssp = (yytype_int16) yystate;
 
   if (yyss + yystacksize - 1 <= yyssp)
+#if !defined yyoverflow && !defined YYSTACK_RELOCATE
+    goto yyexhaustedlab;
+#else
     {
       /* Get the current used size of the three stacks, in elements.  */
-      YYSIZE_T yysize = yyssp - yyss + 1;
+      YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1);
 
-#ifdef yyoverflow
+# if defined yyoverflow
       {
         /* Give user a chance to reallocate the stack.  Use copies of
            these so that the &'s don't force the real ones into
@@ -1637,15 +1655,11 @@ YYLTYPE yylloc = yyloc_default;
                     &yyvs1, yysize * sizeof (*yyvsp),
                     &yyls1, yysize * sizeof (*yylsp),
                     &yystacksize);
-
-        yyls = yyls1;
         yyss = yyss1;
         yyvs = yyvs1;
+        yyls = yyls1;
       }
-#else /* no yyoverflow */
-# ifndef YYSTACK_RELOCATE
-      goto yyexhaustedlab;
-# else
+# else /* defined YYSTACK_RELOCATE */
       /* Extend the stack our own way.  */
       if (YYMAXDEPTH <= yystacksize)
         goto yyexhaustedlab;
@@ -1662,23 +1676,23 @@ YYLTYPE yylloc = yyloc_default;
         YYSTACK_RELOCATE (yyss_alloc, yyss);
         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
         YYSTACK_RELOCATE (yyls_alloc, yyls);
-#  undef YYSTACK_RELOCATE
+# undef YYSTACK_RELOCATE
         if (yyss1 != yyssa)
           YYSTACK_FREE (yyss1);
       }
 # endif
-#endif /* no yyoverflow */
 
       yyssp = yyss + yysize - 1;
       yyvsp = yyvs + yysize - 1;
       yylsp = yyls + yysize - 1;
 
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
-                  (unsigned long int) yystacksize));
+                  (unsigned long) yystacksize));
 
       if (yyss + yystacksize - 1 <= yyssp)
         YYABORT;
     }
+#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
 
   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
@@ -1687,11 +1701,11 @@ YYLTYPE yylloc = yyloc_default;
 
   goto yybackup;
 
+
 /*-----------.
 | yybackup.  |
 `-----------*/
 yybackup:
-
   /* Do appropriate processing given the current state.  Read a
      lookahead token if we need one and don't already have one.  */
 
@@ -1764,7 +1778,7 @@ yydefault:
 
 
 /*-----------------------------.
-| yyreduce -- Do a reduction.  |
+| yyreduce -- do a reduction.  |
 `-----------------------------*/
 yyreduce:
   /* yyn is the number of a rule to reduce with.  */
@@ -1780,169 +1794,170 @@ yyreduce:
      GCC warning that YYVAL may be used uninitialized.  */
   yyval = yyvsp[1-yylen];
 
-  /* Default location.  */
+  /* Default location. */
   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+  yyerror_range[1] = yyloc;
   YY_REDUCE_PRINT (yyn);
   switch (yyn)
     {
         case 2:
-#line 379 "bpgrammar.y" /* yacc.c:1646  */
+#line 389 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.ndt) = (yyvsp[-1].ndt);  *ast = (yyval.ndt); YYACCEPT; }
-#line 1792 "bpgrammar.c" /* yacc.c:1646  */
+#line 1807 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 3:
-#line 382 "bpgrammar.y" /* yacc.c:1646  */
+#line 392 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.ndt) = make_dimensions((yyvsp[-2].string_seq), (yyvsp[0].ndt), ctx); if ((yyval.ndt) == NULL) YYABORT; }
-#line 1798 "bpgrammar.c" /* yacc.c:1646  */
+#line 1813 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 4:
-#line 383 "bpgrammar.y" /* yacc.c:1646  */
+#line 393 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.ndt) = (yyvsp[0].ndt); }
-#line 1804 "bpgrammar.c" /* yacc.c:1646  */
+#line 1819 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 5:
-#line 384 "bpgrammar.y" /* yacc.c:1646  */
+#line 394 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.ndt) = (yyvsp[0].ndt); }
-#line 1810 "bpgrammar.c" /* yacc.c:1646  */
+#line 1825 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 6:
-#line 387 "bpgrammar.y" /* yacc.c:1646  */
+#line 397 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.string_seq) = ndt_string_seq_new((yyvsp[0].string), ctx); if ((yyval.string_seq) == NULL) YYABORT; }
-#line 1816 "bpgrammar.c" /* yacc.c:1646  */
+#line 1831 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 7:
-#line 388 "bpgrammar.y" /* yacc.c:1646  */
+#line 398 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.string_seq) = ndt_string_seq_append((yyvsp[-2].string_seq), (yyvsp[0].string), ctx); if ((yyval.string_seq) == NULL) YYABORT; }
-#line 1822 "bpgrammar.c" /* yacc.c:1646  */
+#line 1837 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 8:
-#line 391 "bpgrammar.y" /* yacc.c:1646  */
+#line 401 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.ndt) = make_dtype((yyvsp[-1].uchar), (yyvsp[0].uchar), ctx); if ((yyval.ndt) == NULL) YYABORT; }
-#line 1828 "bpgrammar.c" /* yacc.c:1646  */
+#line 1843 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 9:
-#line 392 "bpgrammar.y" /* yacc.c:1646  */
+#line 402 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.ndt) = make_fixed_bytes((yyvsp[-1].string), ctx); if ((yyval.ndt) == NULL) YYABORT; }
-#line 1834 "bpgrammar.c" /* yacc.c:1646  */
+#line 1849 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 10:
-#line 393 "bpgrammar.y" /* yacc.c:1646  */
+#line 403 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.ndt) = (yyvsp[0].ndt); }
-#line 1840 "bpgrammar.c" /* yacc.c:1646  */
+#line 1855 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 11:
-#line 396 "bpgrammar.y" /* yacc.c:1646  */
+#line 406 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.ndt) = make_record((yyvsp[-1].field_seq), ctx); if ((yyval.ndt) == NULL) YYABORT; }
-#line 1846 "bpgrammar.c" /* yacc.c:1646  */
+#line 1861 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 12:
-#line 399 "bpgrammar.y" /* yacc.c:1646  */
+#line 409 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.field_seq) = ndt_field_seq_new((yyvsp[0].field), ctx); if ((yyval.field_seq) == NULL) YYABORT; }
-#line 1852 "bpgrammar.c" /* yacc.c:1646  */
+#line 1867 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 13:
-#line 400 "bpgrammar.y" /* yacc.c:1646  */
+#line 410 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.field_seq) = ndt_field_seq_append((yyvsp[-1].field_seq), (yyvsp[0].field), ctx); if ((yyval.field_seq) == NULL) YYABORT; }
-#line 1858 "bpgrammar.c" /* yacc.c:1646  */
+#line 1873 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 14:
-#line 403 "bpgrammar.y" /* yacc.c:1646  */
+#line 413 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.field) = make_field((yyvsp[-2].string), (yyvsp[-4].ndt), (yyvsp[0].uint16), ctx); if ((yyval.field) == NULL) YYABORT; }
-#line 1864 "bpgrammar.c" /* yacc.c:1646  */
+#line 1879 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 15:
-#line 406 "bpgrammar.y" /* yacc.c:1646  */
+#line 416 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.ndt) = mk_function((yyvsp[-2].type_seq), (yyvsp[0].type_seq), ctx); if ((yyval.ndt) == NULL) YYABORT; }
-#line 1870 "bpgrammar.c" /* yacc.c:1646  */
+#line 1885 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 16:
-#line 409 "bpgrammar.y" /* yacc.c:1646  */
+#line 419 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.type_seq) = broadcast_seq_new((yyvsp[0].ndt), ctx); if ((yyval.type_seq) == NULL) YYABORT; }
-#line 1876 "bpgrammar.c" /* yacc.c:1646  */
+#line 1891 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 17:
-#line 410 "bpgrammar.y" /* yacc.c:1646  */
+#line 420 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.type_seq) = broadcast_seq_append((yyvsp[-1].type_seq), (yyvsp[0].ndt), ctx); if ((yyval.type_seq) == NULL) YYABORT; }
-#line 1882 "bpgrammar.c" /* yacc.c:1646  */
+#line 1897 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 18:
-#line 413 "bpgrammar.y" /* yacc.c:1646  */
+#line 423 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.uchar) = '@'; }
-#line 1888 "bpgrammar.c" /* yacc.c:1646  */
+#line 1903 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 19:
-#line 414 "bpgrammar.y" /* yacc.c:1646  */
+#line 424 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.uchar) = '@'; }
-#line 1894 "bpgrammar.c" /* yacc.c:1646  */
+#line 1909 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 20:
-#line 415 "bpgrammar.y" /* yacc.c:1646  */
+#line 425 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.uchar) = '='; }
-#line 1900 "bpgrammar.c" /* yacc.c:1646  */
+#line 1915 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 21:
-#line 416 "bpgrammar.y" /* yacc.c:1646  */
+#line 426 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.uchar) = '<'; }
-#line 1906 "bpgrammar.c" /* yacc.c:1646  */
+#line 1921 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 22:
-#line 417 "bpgrammar.y" /* yacc.c:1646  */
+#line 427 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.uchar) = '>'; }
-#line 1912 "bpgrammar.c" /* yacc.c:1646  */
+#line 1927 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 23:
-#line 418 "bpgrammar.y" /* yacc.c:1646  */
+#line 428 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.uchar) = '!'; }
-#line 1918 "bpgrammar.c" /* yacc.c:1646  */
+#line 1933 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 24:
-#line 421 "bpgrammar.y" /* yacc.c:1646  */
+#line 431 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.string) = NULL; }
-#line 1924 "bpgrammar.c" /* yacc.c:1646  */
+#line 1939 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 25:
-#line 422 "bpgrammar.y" /* yacc.c:1646  */
+#line 432 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.string) = (yyvsp[0].string); if ((yyval.string) == NULL) YYABORT; }
-#line 1930 "bpgrammar.c" /* yacc.c:1646  */
+#line 1945 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 26:
-#line 425 "bpgrammar.y" /* yacc.c:1646  */
+#line 435 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.uint16) = 0; }
-#line 1936 "bpgrammar.c" /* yacc.c:1646  */
+#line 1951 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
   case 27:
-#line 426 "bpgrammar.y" /* yacc.c:1646  */
+#line 436 "bpgrammar.y" /* yacc.c:1652  */
     { (yyval.uint16) = add_uint16((yyvsp[-1].uint16), 1, ctx); if (ndt_err_occurred(ctx)) YYABORT; }
-#line 1942 "bpgrammar.c" /* yacc.c:1646  */
+#line 1957 "bpgrammar.c" /* yacc.c:1652  */
     break;
 
 
-#line 1946 "bpgrammar.c" /* yacc.c:1646  */
+#line 1961 "bpgrammar.c" /* yacc.c:1652  */
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -1968,14 +1983,13 @@ yyreduce:
   /* Now 'shift' the result of the reduction.  Determine what state
      that goes to, based on the state we popped back to and the rule
      number reduced by.  */
-
-  yyn = yyr1[yyn];
-
-  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
-  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-    yystate = yytable[yystate];
-  else
-    yystate = yydefgoto[yyn - YYNTOKENS];
+  {
+    const int yylhs = yyr1[yyn] - YYNTOKENS;
+    const int yyi = yypgoto[yylhs] + *yyssp;
+    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
+               ? yytable[yyi]
+               : yydefgoto[yylhs]);
+  }
 
   goto yynewstate;
 
@@ -2058,14 +2072,11 @@ yyerrlab:
 | yyerrorlab -- error raised explicitly by YYERROR.  |
 `---------------------------------------------------*/
 yyerrorlab:
+  /* Pacify compilers when the user code never invokes YYERROR and the
+     label yyerrorlab therefore never appears in user code.  */
+  if (0)
+    YYERROR;
 
-  /* Pacify compilers like GCC when the user code never invokes
-     YYERROR and the label yyerrorlab therefore never appears in user
-     code.  */
-  if (/*CONSTCOND*/ 0)
-     goto yyerrorlab;
-
-  yyerror_range[1] = yylsp[1-yylen];
   /* Do not reclaim the symbols of the rule whose action triggered
      this YYERROR.  */
   YYPOPSTACK (yylen);
@@ -2131,6 +2142,7 @@ yyacceptlab:
   yyresult = 0;
   goto yyreturn;
 
+
 /*-----------------------------------.
 | yyabortlab -- YYABORT comes here.  |
 `-----------------------------------*/
@@ -2138,6 +2150,7 @@ yyabortlab:
   yyresult = 1;
   goto yyreturn;
 
+
 #if !defined yyoverflow || YYERROR_VERBOSE
 /*-------------------------------------------------.
 | yyexhaustedlab -- memory exhaustion comes here.  |
@@ -2148,6 +2161,10 @@ yyexhaustedlab:
   /* Fall through.  */
 #endif
 
+
+/*-----------------------------------------------------.
+| yyreturn -- parsing is finished, return the result.  |
+`-----------------------------------------------------*/
 yyreturn:
   if (yychar != YYEMPTY)
     {