Use simpler names for statement flags

3 files changed, 24 insertions, 26 deletions

diff --git a/serd/serd.h b/serd/serd.h
index 6697a878..d81fbd7c 100644
--- a/serd/serd.h
+++ b/serd/serd.h
@@ -169,11 +169,11 @@ typedef enum {
    Flags indicating inline abbreviation information for a statement.
 */
 typedef enum {
-	SERD_EMPTY_S      = 1 << 0,  /**< Empty blank node subject */
-	SERD_ANON_S_BEGIN = 1 << 1,  /**< Start of anonymous subject */
-	SERD_ANON_O_BEGIN = 1 << 2,  /**< Start of anonymous object */
-	SERD_LIST_S_BEGIN = 1 << 3,  /**< Start of list subject */
-	SERD_LIST_O_BEGIN = 1 << 4,  /**< Start of list object */
+	SERD_EMPTY_S = 1 << 0,  /**< Empty blank node subject */
+	SERD_ANON_S  = 1 << 1,  /**< Start of anonymous subject */
+	SERD_ANON_O  = 1 << 2,  /**< Start of anonymous object */
+	SERD_LIST_S  = 1 << 3,  /**< Start of list subject */
+	SERD_LIST_O  = 1 << 4   /**< Start of list object */
 } SerdStatementFlag;
 
 /**
diff --git a/src/n3.c b/src/n3.c
index b221e9b5..38e06fcb 100644
--- a/src/n3.c
+++ b/src/n3.c
@@ -981,9 +981,9 @@ read_anon(SerdReader* reader, ReadContext ctx, bool subject, SerdNode** dest)
 	bool                     empty     = false;
 	eat_byte_safe(reader, '[');
 	if ((empty = peek_delim(reader, ']'))) {
-		*ctx.flags |= (subject) ? SERD_EMPTY_S : SERD_ANON_O_BEGIN;
+		*ctx.flags |= (subject) ? SERD_EMPTY_S : SERD_ANON_O;
 	} else {
-		*ctx.flags |= (subject) ? SERD_ANON_S_BEGIN : SERD_ANON_O_BEGIN;
+		*ctx.flags |= (subject) ? SERD_ANON_S : SERD_ANON_O;
 		if (peek_delim(reader, '=')) {
 			if (!(*dest = read_blankName(reader)) ||
 			    !eat_delim(reader, ';')) {
@@ -1191,10 +1191,10 @@ read_collection(SerdReader* reader, ReadContext ctx, SerdNode** dest)
 	*dest = end ? reader->rdf_nil : blank_id(reader);
 	if (ctx.subject) {
 		// subject predicate _:head
-		*ctx.flags |= (end ? 0 : SERD_LIST_O_BEGIN);
+		*ctx.flags |= (end ? 0 : SERD_LIST_O);
 		TRY(st, emit_statement(reader, ctx, *dest));
 	} else {
-		*ctx.flags |= (end ? 0 : SERD_LIST_S_BEGIN);
+		*ctx.flags |= (end ? 0 : SERD_LIST_S);
 	}
 
 	if (end) {
diff --git a/src/writer.c b/src/writer.c
index 132cf028..02f331bc 100644
--- a/src/writer.c
+++ b/src/writer.c
@@ -478,8 +478,8 @@ is_inline_start(const SerdWriter*  writer,
                 SerdStatementFlags flags)
 {
 	return (supports_abbrev(writer) &&
-	        ((field == SERD_SUBJECT && (flags & SERD_ANON_S_BEGIN)) ||
-	         (field == SERD_OBJECT &&  (flags & SERD_ANON_O_BEGIN))));
+	        ((field == SERD_SUBJECT && (flags & SERD_ANON_S)) ||
+	         (field == SERD_OBJECT &&  (flags & SERD_ANON_O))));
 }
 
 static bool
@@ -655,8 +655,8 @@ write_blank(SerdWriter* const        writer,
 	if (supports_abbrev(writer)) {
 		if (is_inline_start(writer, field, flags)) {
 			return write_sep(writer, SEP_ANON_BEGIN);
-		} else if ((field == SERD_SUBJECT && (flags & SERD_LIST_S_BEGIN)) ||
-		           (field == SERD_OBJECT && (flags & SERD_LIST_O_BEGIN))) {
+		} else if ((field == SERD_SUBJECT && (flags & SERD_LIST_S)) ||
+		           (field == SERD_OBJECT && (flags & SERD_LIST_O))) {
 			return write_sep(writer, SEP_LIST_BEGIN);
 		} else if (field == SERD_SUBJECT && (flags & SERD_EMPTY_S)) {
 			writer->last_sep = SEP_NONE; // Treat "[]" like anode
@@ -737,10 +737,8 @@ serd_writer_write_statement(SerdWriter*          writer,
                             SerdStatementFlags   flags,
                             const SerdStatement* statement)
 {
-	assert(!((flags & SERD_EMPTY_S) && (flags & SERD_ANON_S_BEGIN)));
-	assert(!((flags & SERD_EMPTY_S) && (flags & SERD_LIST_S_BEGIN)));
-	assert(!((flags & SERD_ANON_S_BEGIN) && (flags & SERD_LIST_S_BEGIN)));
-	assert(!((flags & SERD_ANON_O_BEGIN) && (flags & SERD_LIST_O_BEGIN)));
+	assert(!((flags & SERD_ANON_S) && (flags & SERD_LIST_S)));
+	assert(!((flags & SERD_ANON_O) && (flags & SERD_LIST_O)));
 
 	const SerdNode* const subject   = serd_statement_subject(statement);
 	const SerdNode* const predicate = serd_statement_predicate(statement);
@@ -803,7 +801,7 @@ serd_writer_write_statement(SerdWriter*          writer,
 		if (serd_node_equals(predicate, writer->context.predicate)) {
 			// Abbreviate S P
 			if (!writer->context.indented_object &&
-			    !(flags & (SERD_ANON_O_BEGIN | SERD_LIST_O_BEGIN))) {
+			    !(flags & (SERD_ANON_O | SERD_LIST_O))) {
 				++writer->indent;
 				writer->context.indented_object = true;
 			}
@@ -840,9 +838,9 @@ serd_writer_write_statement(SerdWriter*          writer,
 
 		if (serd_stack_is_empty(&writer->anon_stack)) {
 			write_node(writer, subject, SERD_SUBJECT, flags);
-			if (!(flags & (SERD_ANON_S_BEGIN | SERD_LIST_S_BEGIN))) {
+			if (!(flags & (SERD_ANON_S | SERD_LIST_S))) {
 				write_sep(writer, SEP_S_P);
-			} else if (flags & SERD_ANON_S_BEGIN) {
+			} else if (flags & SERD_ANON_S) {
 				write_sep(writer, SEP_ANON_S_P);
 			}
 		} else {
@@ -852,21 +850,21 @@ serd_writer_write_statement(SerdWriter*          writer,
 		reset_context(writer, false);
 		serd_node_set(&writer->context.subject, subject);
 
-		if (!(flags & SERD_LIST_S_BEGIN)) {
+		if (!(flags & SERD_LIST_S)) {
 			write_pred(writer, flags, predicate);
 		}
 
 		write_node(writer, object, SERD_OBJECT, flags);
 	}
 
-	if (flags & SERD_LIST_S_BEGIN) {
+	if (flags & SERD_LIST_S) {
 		const WriteContext ctx = {CTX_LIST,
 		                          serd_node_copy(graph),
 		                          serd_node_copy(subject),
 		                          NULL,
 		                          false};
 		push_context(writer, ctx);
-	} if (flags & SERD_LIST_O_BEGIN) {
+	} if (flags & SERD_LIST_O) {
 		const WriteContext ctx = {CTX_LIST,
 		                          serd_node_copy(graph),
 		                          serd_node_copy(object),
@@ -875,9 +873,9 @@ serd_writer_write_statement(SerdWriter*          writer,
 		push_context(writer, ctx);
 	}
 
-	if (flags & (SERD_ANON_S_BEGIN | SERD_ANON_O_BEGIN)) {
-		const bool is_list    = flags & (SERD_LIST_S_BEGIN | SERD_LIST_O_BEGIN);
-		const bool is_subject = flags & SERD_ANON_S_BEGIN;
+	if (flags & (SERD_ANON_S | SERD_ANON_O)) {
+		const bool is_list    = flags & (SERD_LIST_S | SERD_LIST_O);
+		const bool is_subject = flags & SERD_ANON_S;
 
 		const WriteContext ctx = {is_list ? CTX_LIST : CTX_BLANK,
 		                          serd_node_copy(graph),