Merge pull request #3160 from masatake/update-subtrees

masatake · web-flow · commit 43448e82a73e · 2021-09-16T10:41:59.000+09:00
Update subtrees
diff --git a/libreadtags/.circleci/config.yml b/libreadtags/.circleci/config.yml
@@ -23,7 +23,7 @@ jobs:
       - run:
           name: Test
           command: |
-            make check
+            make check VERBOSE=1
   fedora31_distcheck:
     working_directory: ~/libreadtags
     docker:
diff --git a/libreadtags/.gitignore b/libreadtags/.gitignore
@@ -31,9 +31,11 @@ test-driver
 
 tests/*.log
 tests/*.trs
+tests/test-api-tagsClose
 tests/test-api-tagsFind
 tests/test-api-tagsFirst
 tests/test-api-tagsFirstPseudoTag
 tests/test-api-tagsOpen
+tests/test-api-tagsSetSortType
 tests/test-fix-null-deref
 tests/test-fix-unescaping
diff --git a/libreadtags/NEWS.md b/libreadtags/NEWS.md
@@ -1,3 +1,11 @@
+# Version ???
+
+- delete debug output automatically printed when DEBUG is defiend in
+  build-time.
+
+- fix potential crashes trigged when passing NULL as `file` parameter
+  to the API functions. Provided by rootkea (GitHub account).
+
 # Version 0.1.0
 
 - propagate internal errors to caller
diff --git a/libreadtags/autogen.sh b/libreadtags/autogen.sh
diff --git a/libreadtags/readtags.c b/libreadtags/readtags.c
@@ -870,19 +870,23 @@ static void terminate (tagFile *const file)
 static tagResult readNext (tagFile *const file, tagEntry *const entry)
 {
 	tagResult result;
-	if (file == NULL  ||  ! file->initialized)
+
+	if (file == NULL)
+		return TagFailure;
+
+	if (! file->initialized)
 	{
 		file->err = TagErrnoInvalidArgument;
-		result = TagFailure;
-	}
-	else if (! readTagLine (file, &file->err))
-		result = TagFailure;
-	else
-	{
-		result = (entry != NULL)
-			? parseTagLine (file, entry, &file->err)
-			: TagSuccess;
+		return TagFailure;
 	}
+
+	if (! readTagLine (file, &file->err))
+		return TagFailure;
+
+	result = (entry != NULL)
+		? parseTagLine (file, entry, &file->err)
+		: TagSuccess;
+
 	return result;
 }
 
@@ -1034,7 +1038,10 @@ static tagResult findSequentialFull (tagFile *const file,
 									 int (* isAcceptable) (tagFile *const, void *),
 									 void *data)
 {
-	if (file == NULL || !file->initialized || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
 		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
@@ -1095,18 +1102,12 @@ static tagResult find (tagFile *const file, tagEntry *const entry,
 	if ((file->sortMethod == TAG_SORTED      && !file->search.ignorecase) ||
 		(file->sortMethod == TAG_FOLDSORTED  &&  file->search.ignorecase))
 	{
-#ifdef DEBUG
-		fputs ("<performing binary search>\n", stderr);
-#endif
 		result = findBinary (file);
 		if (result == TagFailure && file->err)
 			return TagFailure;
 	}
 	else
 	{
-#ifdef DEBUG
-		fputs ("<performing sequential search>\n", stderr);
-#endif
 		result = findSequential (file);
 		if (result == TagFailure && file->err)
 			return TagFailure;
@@ -1155,9 +1156,12 @@ static tagResult findNext (tagFile *const file, tagEntry *const entry)
 
 static tagResult findPseudoTag (tagFile *const file, int rewindBeforeFinding, tagEntry *const entry)
 {
-	if (file == NULL || (!file->initialized) || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
-		file->err= TagErrnoInvalidArgument;;
+		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
 	}
 
@@ -1188,7 +1192,10 @@ extern tagFile *tagsOpen (const char *const filePath, tagFileInfo *const info)
 
 extern tagResult tagsSetSortType (tagFile *const file, const tagSortType type)
 {
-	if (file == NULL || (!file->initialized) || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
 		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
@@ -1209,7 +1216,10 @@ extern tagResult tagsSetSortType (tagFile *const file, const tagSortType type)
 
 extern tagResult tagsFirst (tagFile *const file, tagEntry *const entry)
 {
-	if (file == NULL || (!file->initialized) || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
 		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
@@ -1222,7 +1232,10 @@ extern tagResult tagsFirst (tagFile *const file, tagEntry *const entry)
 
 extern tagResult tagsNext (tagFile *const file, tagEntry *const entry)
 {
-	if (file == NULL || (!file->initialized) || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
 		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
@@ -1242,21 +1255,29 @@ extern const char *tagsField (const tagEntry *const entry, const char *const key
 extern tagResult tagsFind (tagFile *const file, tagEntry *const entry,
 						   const char *const name, const int options)
 {
-	if (file == NULL || !file->initialized || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
 		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
 	}
+
 	return find (file, entry, name, options);
 }
 
 extern tagResult tagsFindNext (tagFile *const file, tagEntry *const entry)
 {
-	if (file == NULL || !file->initialized || file->err)
+	if (file == NULL)
+		return TagFailure;
+
+	if (!file->initialized || file->err)
 	{
 		file->err = TagErrnoInvalidArgument;
 		return TagFailure;
 	}
+
 	return findNext (file, entry);
 }
 
diff --git a/libreadtags/tests/test-api-tagsFind.c b/libreadtags/tests/test-api-tagsFind.c
@@ -65,14 +65,14 @@ check_finding0 (tagFile *t, const char *name, const int options,
 				if (err == x->err)
 				{
 					if (err == 0)
-						fprintf (stderr, "not found, and it is expected\n", err);
+						fprintf (stderr, "not found, and it is expected\n");
 					else
 						fprintf (stderr, "error as expected: %d\n", err);
 					continue;
 				}
 				else
 				{
-					fprintf (stderr, "errer number doesn't match: %d (expected: %d)\n",
+					fprintf (stderr, "error number doesn't match: %d (expected: %d)\n",
 							 err, x->err);
 					return 1;
 				}
diff --git a/libreadtags/tests/test-api-tagsOpen.c b/libreadtags/tests/test-api-tagsOpen.c
@@ -157,7 +157,8 @@ main (void)
 	}
 	fprintf (stderr, "ok\n");
 
-	fprintf (stderr, "opening a / (EISDIR is expected)...");
+	fprintf (stderr, "opening a / (an error is expected)...");
+	info.status.error_number = 0;
 	t = tagsOpen ("/", &info);
 	if (t != NULL)
 	{
@@ -169,12 +170,12 @@ main (void)
 		fprintf (stderr, "unexpected result (opened != 0)\n");
 		return 1;
 	}
-	else if (info.status.error_number != EISDIR)
+	else if (info.status.error_number == 0)
 	{
-		fprintf (stderr, "unexpected result (error_number != EISDIR)\n");
+		fprintf (stderr, "no error\n");
 		return 1;
 	}
-	fprintf (stderr, "ok\n");
+	fprintf (stderr, "ok (errno: %d)\n", info.status.error_number);
 
 	fprintf (stderr, "closing the unopened tag file...");
 	if (tagsClose (t) == TagSuccess)
@@ -275,9 +276,9 @@ main (void)
 	for (int i = 0; i < 6; i++)
 	{
 		char tagf_name_tmpl [] = "./api-tagsOpen-incomplete-program-author-%d.tags";
-		char tagf_name [sizeof (tagf_name_tmpl)];
+		char tagf_name [sizeof (tagf_name_tmpl) - 1];
 		fprintf (stderr, "opening a tags file with incomplete PROGRAM_AUTHOR field [trimming level: %d]...", i);
-		sprintf (tagf_name, tagf_name_tmpl, i);
+		snprintf (tagf_name, sizeof (tagf_name), tagf_name_tmpl, i);
 		t = tagsOpen (tagf_name, &info);
 		if (t == NULL)
 		{
diff --git a/libreadtags/tests/test-fix-null-deref.c b/libreadtags/tests/test-fix-null-deref.c
@@ -41,7 +41,6 @@ main (void)
 	fprintf (stderr, "ok\n");
 
 	tagEntry e;
-	tagResult r;
 
 	/* Without fix, this program crashes in tagsFirst(). */
 	tagsFirst (t, &e);
diff --git a/misc/packcc/README.md b/misc/packcc/README.md
@@ -339,7 +339,7 @@ Some macros are prepared to customize the parser. The macro definition should be
 
 ```
 %source {
-#define PCC_GETCHAR(auxil) get_character(auxil->input)
+#define PCC_GETCHAR(auxil) get_character((auxil)->input)
 #define PCC_BUFFERSIZE 1024
 }
 ```
@@ -430,8 +430,7 @@ A very simple implementation could look like this:
 ```C
 static const char *dbg_str[] = { "Evaluating rule", "Matched rule", "Abandoning rule" };
 #define PCC_DEBUG(event, rule, level, pos, buffer, length) \
-    fprintf(stderr, "%*s%s %s @%d [%.*s]\n", level * 2, "", dbg_str[event], rule, pos, length, buffer)
-}
+    fprintf(stderr, "%*s%s %s @%zu [%.*s]\n", (int)((level) * 2), "", dbg_str[event], rule, pos, (int)(length), buffer)
 ```
 
 The default is to do nothing:
diff --git a/misc/packcc/src/packcc.c b/misc/packcc/src/packcc.c
@@ -64,14 +64,14 @@ static size_t strnlen_(const char *str, size_t maxlen) {
 #include <unistd.h> /* for unlink() */
 #endif
 
-#ifndef __attribute__
+#ifndef __has_attribute
 #define __attribute__(x)
 #endif
 
 #undef TRUE  /* to avoid macro definition conflicts with the system header file of IBM AIX */
 #undef FALSE
 
-#define VERSION "1.5.0"
+#define VERSION "1.5.1"
 
 #ifndef BUFFER_INIT_SIZE
 #define BUFFER_INIT_SIZE 256
@@ -285,7 +285,8 @@ typedef enum code_reach_tag {
 
 static const char *g_cmdname = "packcc"; /* replaced later with actual one */
 
-static int print_error(const char *format, ...) __attribute__((format(printf, 1, 2))) {
+__attribute__((format(printf, 1, 2)))
+static int print_error(const char *format, ...) {
     int n;
     va_list a;
     va_start(a, format);
@@ -352,7 +353,8 @@ static int fputs_e(const char *s, FILE *stream) {
     return r;
 }
 
-static int fprintf_e(FILE *stream, const char *format, ...) __attribute__((format(printf, 2, 3))) {
+__attribute__((format(printf, 2, 3)))
+static int fprintf_e(FILE *stream, const char *format, ...) {
     int n;
     va_list a;
     va_start(a, format);
@@ -1436,8 +1438,8 @@ static void verify_captures(context_t *ctx, node_t *node, node_const_array_t *ca
                 if (node->data.expand.index == capts->buf[i]->data.capture.index) break;
             }
             if (i >= capts->len && node->data.expand.index != VOID_VALUE) {
-                print_error("%s:" FMT_LU ":" FMT_LU ": Capture %d not available at this position\n",
-                    ctx->iname, (ulong_t)(node->data.expand.line + 1), (ulong_t)(node->data.expand.col + 1), node->data.expand.index + 1);
+                print_error("%s:" FMT_LU ":" FMT_LU ": Capture " FMT_LU " not available at this position\n",
+                    ctx->iname, (ulong_t)(node->data.expand.line + 1), (ulong_t)(node->data.expand.col + 1), (ulong_t)(node->data.expand.index + 1));
                 ctx->errnum++;
             }
         }
@@ -2730,26 +2732,20 @@ static code_reach_t generate_predicating_code(generate_t *gen, const node_t *exp
     }
     write_characters(gen->stream, ' ', indent);
     fputs_e("const size_t p = ctx->cur;\n", gen->stream);
-    write_characters(gen->stream, ' ', indent);
-    fputs_e("const size_t n = chunk->thunks.len;\n", gen->stream);
     if (neg) {
         const int l = ++gen->label;
         r = generate_code(gen, expr, l, indent, FALSE);
         if (r != CODE_REACH__ALWAYS_FAIL) {
             write_characters(gen->stream, ' ', indent);
             fputs_e("ctx->cur = p;\n", gen->stream);
             write_characters(gen->stream, ' ', indent);
-            fputs_e("pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);\n", gen->stream);
-            write_characters(gen->stream, ' ', indent);
             fprintf_e(gen->stream, "goto L%04d;\n", onfail);
         }
         if (r != CODE_REACH__ALWAYS_SUCCEED) {
             if (indent > 4) write_characters(gen->stream, ' ', indent - 4);
             fprintf_e(gen->stream, "L%04d:;\n", l);
             write_characters(gen->stream, ' ', indent);
             fputs_e("ctx->cur = p;\n", gen->stream);
-            write_characters(gen->stream, ' ', indent);
-            fputs_e("pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);\n", gen->stream);
         }
         switch (r) {
         case CODE_REACH__ALWAYS_SUCCEED: r = CODE_REACH__ALWAYS_FAIL; break;
@@ -2764,8 +2760,6 @@ static code_reach_t generate_predicating_code(generate_t *gen, const node_t *exp
         if (r != CODE_REACH__ALWAYS_FAIL) {
             write_characters(gen->stream, ' ', indent);
             fputs_e("ctx->cur = p;\n", gen->stream);
-            write_characters(gen->stream, ' ', indent);
-            fputs_e("pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);\n", gen->stream);
         }
         if (r == CODE_REACH__BOTH) {
             write_characters(gen->stream, ' ', indent);
@@ -2777,8 +2771,6 @@ static code_reach_t generate_predicating_code(generate_t *gen, const node_t *exp
             write_characters(gen->stream, ' ', indent);
             fputs_e("ctx->cur = p;\n", gen->stream);
             write_characters(gen->stream, ' ', indent);
-            fputs_e("pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);\n", gen->stream);
-            write_characters(gen->stream, ' ', indent);
             fprintf_e(gen->stream, "goto L%04d;\n", onfail);
         }
         if (r == CODE_REACH__BOTH) {
@@ -4283,8 +4275,8 @@ static bool_t generate(context_t *ctx) {
                     }
                     fprintf_e(
                         sstream,
-                        "static void pcc_action_%s_%d(%s_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {\n",
-                        r->name, d, get_prefix(ctx)
+                        "static void pcc_action_%s_" FMT_LU "(%s_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {\n",
+                        r->name, (ulong_t)d, get_prefix(ctx)
                     );
                     fputs_e(
                         "#define auxil (__pcc_ctx->auxil)\n"
@@ -4303,8 +4295,8 @@ static bool_t generate(context_t *ctx) {
                     }
                     fputs_e(
                         "#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)\n"
-                        "#define _0s ((const size_t)__pcc_in->data.leaf.capt0.range.start)\n"
-                        "#define _0e ((const size_t)__pcc_in->data.leaf.capt0.range.end)\n",
+                        "#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))\n"
+                        "#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))\n",
                         sstream
                     );
                     k = 0;
diff --git a/misc/packcc/tests/debug_macro.d/input.peg b/misc/packcc/tests/debug_macro.d/input.peg
@@ -1,7 +1,7 @@
 %source {
 static const char *dbg_str[] = { "Evaluating rule", "Matched rule", "Abandoning rule" };
 #define PCC_DEBUG(event, rule, level, pos, buffer, length) \
-    fprintf(stdout, "%*s%s %s @%d [%.*s]\n", level * 2, "", dbg_str[event], rule, pos, length, buffer)
+    fprintf(stdout, "%*s%s %s @%zu [%.*s]\n", (int)((level) * 2), "", dbg_str[event], rule, pos, (int)(length), buffer)
     /* NOTE: To guarantee the output order, stderr, which can lead a race condition with stdout, is not used. */
 }
 

Original file line number	Diff line number	Diff line change
`@@ -870,19 +870,23 @@ static void terminate (tagFile *const file)`
`870`	`870`	`static tagResult readNext (tagFile const file, tagEntry const entry)`
`871`	`871`	`{`
`872`	`872`	`tagResult result;`
`873`		`- if (file == NULL \|\| ! file->initialized)`
	`873`	`+`
	`874`	`+ if (file == NULL)`
	`875`	`+ return TagFailure;`
	`876`	`+`
	`877`	`+ if (! file->initialized)`
`874`	`878`	`{`
`875`	`879`	`file->err = TagErrnoInvalidArgument;`
`876`		`- result = TagFailure;`
`877`		`- }`
`878`		`- else if (! readTagLine (file, &file->err))`
`879`		`- result = TagFailure;`
`880`		`- else`
`881`		`- {`
`882`		`- result = (entry != NULL)`
`883`		`- ? parseTagLine (file, entry, &file->err)`
`884`		`- : TagSuccess;`
	`880`	`+ return TagFailure;`
`885`	`881`	`}`
	`882`	`+`
	`883`	`+ if (! readTagLine (file, &file->err))`
	`884`	`+ return TagFailure;`
	`885`	`+`
	`886`	`+ result = (entry != NULL)`
	`887`	`+ ? parseTagLine (file, entry, &file->err)`
	`888`	`+ : TagSuccess;`
	`889`	`+`
`886`	`890`	`return result;`
`887`	`891`	`}`
`888`	`892`
`@@ -1034,7 +1038,10 @@ static tagResult findSequentialFull (tagFile *const file,`
`1034`	`1038`	`int (* isAcceptable) (tagFile const, void ),`
`1035`	`1039`	`void *data)`
`1036`	`1040`	`{`
`1037`		`- if (file == NULL \|\| !file->initialized \|\| file->err)`
	`1041`	`+ if (file == NULL)`
	`1042`	`+ return TagFailure;`
	`1043`	`+`
	`1044`	`+ if (!file->initialized \|\| file->err)`
`1038`	`1045`	`{`
`1039`	`1046`	`file->err = TagErrnoInvalidArgument;`
`1040`	`1047`	`return TagFailure;`
`@@ -1095,18 +1102,12 @@ static tagResult find (tagFile const file, tagEntry const entry,`
`1095`	`1102`	`if ((file->sortMethod == TAG_SORTED && !file->search.ignorecase) \|\|`
`1096`	`1103`	`(file->sortMethod == TAG_FOLDSORTED && file->search.ignorecase))`
`1097`	`1104`	`{`
`1098`		`-#ifdef DEBUG`
`1099`		`- fputs ("<performing binary search>\n", stderr);`
`1100`		`-#endif`
`1101`	`1105`	`result = findBinary (file);`
`1102`	`1106`	`if (result == TagFailure && file->err)`
`1103`	`1107`	`return TagFailure;`
`1104`	`1108`	`}`
`1105`	`1109`	`else`
`1106`	`1110`	`{`
`1107`		`-#ifdef DEBUG`
`1108`		`- fputs ("<performing sequential search>\n", stderr);`
`1109`		`-#endif`
`1110`	`1111`	`result = findSequential (file);`
`1111`	`1112`	`if (result == TagFailure && file->err)`
`1112`	`1113`	`return TagFailure;`
`@@ -1155,9 +1156,12 @@ static tagResult findNext (tagFile const file, tagEntry const entry)`
`1155`	`1156`
`1156`	`1157`	`static tagResult findPseudoTag (tagFile const file, int rewindBeforeFinding, tagEntry const entry)`
`1157`	`1158`	`{`
`1158`		`- if (file == NULL \|\| (!file->initialized) \|\| file->err)`
	`1159`	`+ if (file == NULL)`
	`1160`	`+ return TagFailure;`
	`1161`	`+`
	`1162`	`+ if (!file->initialized \|\| file->err)`
`1159`	`1163`	`{`
`1160`		`- file->err= TagErrnoInvalidArgument;;`
	`1164`	`+ file->err = TagErrnoInvalidArgument;`
`1161`	`1165`	`return TagFailure;`
`1162`	`1166`	`}`
`1163`	`1167`
`@@ -1188,7 +1192,10 @@ extern tagFile tagsOpen (const char const filePath, tagFileInfo *const info)`
`1188`	`1192`
`1189`	`1193`	`extern tagResult tagsSetSortType (tagFile *const file, const tagSortType type)`
`1190`	`1194`	`{`
`1191`		`- if (file == NULL \|\| (!file->initialized) \|\| file->err)`
	`1195`	`+ if (file == NULL)`
	`1196`	`+ return TagFailure;`
	`1197`	`+`
	`1198`	`+ if (!file->initialized \|\| file->err)`
`1192`	`1199`	`{`
`1193`	`1200`	`file->err = TagErrnoInvalidArgument;`
`1194`	`1201`	`return TagFailure;`
`@@ -1209,7 +1216,10 @@ extern tagResult tagsSetSortType (tagFile *const file, const tagSortType type)`
`1209`	`1216`
`1210`	`1217`	`extern tagResult tagsFirst (tagFile const file, tagEntry const entry)`
`1211`	`1218`	`{`
`1212`		`- if (file == NULL \|\| (!file->initialized) \|\| file->err)`
	`1219`	`+ if (file == NULL)`
	`1220`	`+ return TagFailure;`
	`1221`	`+`
	`1222`	`+ if (!file->initialized \|\| file->err)`
`1213`	`1223`	`{`
`1214`	`1224`	`file->err = TagErrnoInvalidArgument;`
`1215`	`1225`	`return TagFailure;`
`@@ -1222,7 +1232,10 @@ extern tagResult tagsFirst (tagFile const file, tagEntry const entry)`
`1222`	`1232`
`1223`	`1233`	`extern tagResult tagsNext (tagFile const file, tagEntry const entry)`
`1224`	`1234`	`{`
`1225`		`- if (file == NULL \|\| (!file->initialized) \|\| file->err)`
	`1235`	`+ if (file == NULL)`
	`1236`	`+ return TagFailure;`
	`1237`	`+`
	`1238`	`+ if (!file->initialized \|\| file->err)`
`1226`	`1239`	`{`
`1227`	`1240`	`file->err = TagErrnoInvalidArgument;`
`1228`	`1241`	`return TagFailure;`
`@@ -1242,21 +1255,29 @@ extern const char tagsField (const tagEntry const entry, const char *const key`
`1242`	`1255`	`extern tagResult tagsFind (tagFile const file, tagEntry const entry,`
`1243`	`1256`	`const char *const name, const int options)`
`1244`	`1257`	`{`
`1245`		`- if (file == NULL \|\| !file->initialized \|\| file->err)`
	`1258`	`+ if (file == NULL)`
	`1259`	`+ return TagFailure;`
	`1260`	`+`
	`1261`	`+ if (!file->initialized \|\| file->err)`
`1246`	`1262`	`{`
`1247`	`1263`	`file->err = TagErrnoInvalidArgument;`
`1248`	`1264`	`return TagFailure;`
`1249`	`1265`	`}`
	`1266`	`+`
`1250`	`1267`	`return find (file, entry, name, options);`
`1251`	`1268`	`}`
`1252`	`1269`
`1253`	`1270`	`extern tagResult tagsFindNext (tagFile const file, tagEntry const entry)`
`1254`	`1271`	`{`
`1255`		`- if (file == NULL \|\| !file->initialized \|\| file->err)`
	`1272`	`+ if (file == NULL)`
	`1273`	`+ return TagFailure;`
	`1274`	`+`
	`1275`	`+ if (!file->initialized \|\| file->err)`
`1256`	`1276`	`{`
`1257`	`1277`	`file->err = TagErrnoInvalidArgument;`
`1258`	`1278`	`return TagFailure;`
`1259`	`1279`	`}`
	`1280`	`+`
`1260`	`1281`	`return findNext (file, entry);`
`1261`	`1282`	`}`
`1262`	`1283`
Original file line number	Diff line number	Diff line change
`@@ -65,14 +65,14 @@ check_finding0 (tagFile t, const char name, const int options,`
`65`	`65`	`if (err == x->err)`
`66`	`66`	`{`
`67`	`67`	`if (err == 0)`
`68`		`- fprintf (stderr, "not found, and it is expected\n", err);`
	`68`	`+ fprintf (stderr, "not found, and it is expected\n");`
`69`	`69`	`else`
`70`	`70`	`fprintf (stderr, "error as expected: %d\n", err);`
`71`	`71`	`continue;`
`72`	`72`	`}`
`73`	`73`	`else`
`74`	`74`	`{`
`75`		`- fprintf (stderr, "errer number doesn't match: %d (expected: %d)\n",`
	`75`	`+ fprintf (stderr, "error number doesn't match: %d (expected: %d)\n",`
`76`	`76`	`err, x->err);`
`77`	`77`	`return 1;`
`78`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,8 @@ main (void)`
`157`	`157`	`}`
`158`	`158`	`fprintf (stderr, "ok\n");`
`159`	`159`
`160`		`- fprintf (stderr, "opening a / (EISDIR is expected)...");`
	`160`	`+ fprintf (stderr, "opening a / (an error is expected)...");`
	`161`	`+ info.status.error_number = 0;`
`161`	`162`	`t = tagsOpen ("/", &info);`
`162`	`163`	`if (t != NULL)`
`163`	`164`	`{`
`@@ -169,12 +170,12 @@ main (void)`
`169`	`170`	`fprintf (stderr, "unexpected result (opened != 0)\n");`
`170`	`171`	`return 1;`
`171`	`172`	`}`
`172`		`- else if (info.status.error_number != EISDIR)`
	`173`	`+ else if (info.status.error_number == 0)`
`173`	`174`	`{`
`174`		`- fprintf (stderr, "unexpected result (error_number != EISDIR)\n");`
	`175`	`+ fprintf (stderr, "no error\n");`
`175`	`176`	`return 1;`
`176`	`177`	`}`
`177`		`- fprintf (stderr, "ok\n");`
	`178`	`+ fprintf (stderr, "ok (errno: %d)\n", info.status.error_number);`
`178`	`179`
`179`	`180`	`fprintf (stderr, "closing the unopened tag file...");`
`180`	`181`	`if (tagsClose (t) == TagSuccess)`
`@@ -275,9 +276,9 @@ main (void)`
`275`	`276`	`for (int i = 0; i < 6; i++)`
`276`	`277`	`{`
`277`	`278`	`char tagf_name_tmpl [] = "./api-tagsOpen-incomplete-program-author-%d.tags";`
`278`		`- char tagf_name [sizeof (tagf_name_tmpl)];`
	`279`	`+ char tagf_name [sizeof (tagf_name_tmpl) - 1];`
`279`	`280`	`fprintf (stderr, "opening a tags file with incomplete PROGRAM_AUTHOR field [trimming level: %d]...", i);`
`280`		`- sprintf (tagf_name, tagf_name_tmpl, i);`
	`281`	`+ snprintf (tagf_name, sizeof (tagf_name), tagf_name_tmpl, i);`
`281`	`282`	`t = tagsOpen (tagf_name, &info);`
`282`	`283`	`if (t == NULL)`
`283`	`284`	`{`