Commit: aeedfdf6ea611f82e97fd878b15d872cf4c9a593 - mingw-catgets (git)

POSIX.1 National Language Support API for MinGW

Commit MetaInfo

• Révision: aeedfdf6ea611f82e97fd878b15d872cf4c9a593 (tree)
• l'heure: 2007-05-13 01:54:36
• Auteur: Keith Marshall <keithmarshall@user...>
• Commiter: Keith Marshall

Message de Log

Add support for single message deletion.

Change Summary

• modified: ChangeLog
• modified: gencat.c
• modified: include/gcmsgs.h
• modified: include/gencat.h
• modified: mcmerge.c
• modified: mcsource.c

Modification

--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,29 @@
[phone]  Keith Marshall  <[e-mail]>
+
+	Add support for single message deletion.
+
+	* mcsource.c: More comment improvements.
+	(mc_source): Set `this->base = NULL' on parsing a message number
+	immediately followed by `newline'; this causes the message to be
+	removed from the internal catalogue index, when the input record
+	is merged.
+
+	* mcmerge.c (mc_merge): Reorganise logic; add section to remove
+	entries with `set > 0 && msg > 0 && base == NULL'.
+	Relocate logic block for processing `delset' requests; still need
+	an implementation for this.
+	Add logic block to catch and diagnose invalid index entries.
+
+	* include/gcmsgs.h (MSG_CATLOAD_FAILED): Renamed symbolic define...
+	(MSG_BAD_CATALOGUE): ...to this.
+	(MSG_INTERNAL_ERROR, MSG_BAD_INDEX): New message defines; used by
+	`mc_merge', to diagnose invalid index entries.
+
+	* include/gencat.h (msgarg): New macro; used by `mc_merge', to
+	associate `MSG_BAD_INDEX' with `MSG_INTERNAL_ERROR'.
+
+	* gencat.c (main): Use `MSG_BAD_CATALOGUE'.
+
 2007-05-11  Keith Marshall  <[e-mail]>
 
 	* mcsource.c: Miscellaneous comment and layout improvements;

--- a/gencat.c
+++ b/gencat.c
@@ -8,7 +8,7 @@
  * This file implements the `main' function for the `gencat' program.
  *
  * Written by Keith Marshall  <[e-mail]>
- * Last modification: 05-Mar-2007
+ * Last modification: 12-May-2007
  *
  *
  * This is free software.  It is provided AS IS, in the hope that it may
@@ -90,7 +90,6 @@ int main( int argc, char **argv )
     /* Initialise the message list, to incorporate any messages which
      * are already contained within the specified message catalogue.
      */
-
     if( (cat = mc_load( msgcat = *++argv )) == NULL )
       switch( errno )
       {
@@ -102,13 +101,12 @@ int main( int argc, char **argv )
 	  break;
 
 	default:
-	  fprintf( errmsg( MSG_CATLOAD_FAILED ), progname, msgcat );
+	  fprintf( errmsg( MSG_BAD_CATALOGUE ), progname, msgcat );
 	  return EXIT_FAILURE;
       }
 
     /* Merge new or updated message definitions from input files.
      */
-
     while( --argc )
       cat = mc_merge( cat, mc_source( *++argv ));
 
@@ -199,7 +197,6 @@ int main( int argc, char **argv )
     /* User specified insufficient command line arguments.
      * Diagnose, and bail out.
      */
-
     fprintf( errmsg( MSG_MISSING_ARGS ), progname );
     fprintf( errmsg( MSG_GENCAT_USAGE ), progname );
     return EXIT_FAILURE;
@@ -207,4 +204,4 @@ int main( int argc, char **argv )
   return EXIT_SUCCESS;
 }
 
-/* $RCSfile$Revision$: end of file */
+/* $RCSfile$Revision: 1.1.1.1 $: end of file */

--- a/include/gcmsgs.h
+++ b/include/gcmsgs.h
@@ -40,7 +40,8 @@
 #define MSG_GENCAT_USAGE     1, 2, "usage: %s catalogue-name input-file ...\n"
 #define MSG_OUTPUT_NOFILE    1, 3, "%s: %s: cannot create temporary output file\n"
 #define MSG_OUT_OF_MEMORY    1, 4, "%s: out of memory\n"
-#define MSG_CATLOAD_FAILED   2, 1, "%s: %s: catalogue exists, but failed to load\n"
+#define MSG_INTERNAL_ERROR   1, 5, "%s: internal error: %s\n"
+#define MSG_BAD_CATALOGUE    2, 1, "%s: %s: file is not a valid message catalogue\n"
 #define MSG_UNKNOWN_CODESET  2, 2, "%s: %s: unknown codeset descriptor\n"
 #define MSG_CODESET_CLASH    2, 3, "%s:%u: codeset `%s' conflicts with prior declaration\n"
 #define MSG_HAD_CODESET      2, 4, "%s:%u: codeset `%s' was previously declared here\n"
@@ -48,11 +49,12 @@
 #define MSG_MSGNUM_NOT_INCR  2, 6, "invalid message number: expecting > %d; got %d\n"
 #define MSG_REDEFINED        2, 7, "%s: %s:%u: redefinition of message %u in set %u\n"
 #define MSG_PREVIOUS_HERE    2, 8, "%s: %s:%u: previous definition was here\n"
-#define MSG_DEL_UNSUPPORTED  3, 1, "%s: %s:%u: deletion of message entities not yet supported\n"
+#define MSG_DEL_UNSUPPORTED  3, 1, "%s: %s:%u: `delset' operation not yet supported\n"
 #define MSG_EOF_IN_QUOTES    3, 2, "%s:%u: unexpected EOF encountered before closing quote\n"
 #define MSG_TEXT_DISCARDED   3, 3, "%s:%u: incomplete message marked for deletion\n"
 #define MSG_MISSING_NEWLINE  3, 4, "%s:%u: missing newline at end of file\n"
+#define MSG_BAD_INDEX        3, 5, "invalid reference in message index"
 /* !
  * !$ end of file
  */
-#endif /* !defined( GCMSGS_H ): $RCSfile$Revision$: end of file */
+#endif /* !defined( GCMSGS_H ): $RCSfile$Revision: 1.1.1.1 $: end of file */

--- a/include/gencat.h
+++ b/include/gencat.h
@@ -11,7 +11,7 @@
  * the prototypes for the functions used to implement `gencat'.
  *
  * Written by Keith Marshall  <[e-mail]>
- * Last modification: 27-Mar-2007
+ * Last modification: 12-May-2007
  *
  *
  * This is free software.  It is provided AS IS, in the hope that it may
@@ -89,10 +89,11 @@ extern struct msgdict *mc_merge( struct msgdict *, struct msgdict * );
 extern char *map_codeset( iconv_t *, char *, char * );
 extern size_t iconv_wrap( int, iconv_t, char *, size_t, char *, size_t );
 
+#define msgarg(MSG) catgets( gencat_messages, MSG )
 #define errmsg(MSG) stderr, catgets( gencat_messages, MSG )
 #define FATAL(MSG) input, linenum, catgets( gencat_messages, MSG )
 
 #define GENCAT_MSG_SRC(REF)  progname, (REF)->src, (REF)->lineno
 #define GENCAT_MSG_INPUT     GENCAT_MSG_SRC( input )
 
-#endif /* !defined( GENCAT_H ): $RCSfile$Revision$: end of file */
+#endif /* !defined( GENCAT_H ): $RCSfile$Revision: 1.1.1.1 $: end of file */

--- a/mcmerge.c
+++ b/mcmerge.c
@@ -10,7 +10,7 @@
  * any single source file into its current internal dictionary.
  *
  * Written by Keith Marshall  <[e-mail]>
- * Last modification: 30-Dec-2006
+ * Last modification: 12-May-2007
  *
  *
  * This is free software.  It is provided AS IS, in the hope that it may
@@ -65,128 +65,196 @@ struct msgdict *mc_merge( struct msgdict *cat, struct msgdict *input )
 
   while( input )
   {
+    /* Save a pointer to the *next* input record;
+     * we will use this later, to progress to the next record,
+     * after we've freed the current reference structure.
+     */
     struct msgdict *next = input->link;
     
     dfprintf(( stderr, "Process entry from %s line %u\n", input->src, input->lineno ));
-    if( input->base == NULL )
-    {
-      /* This is a `delete' operation...
-       * FIXME: we don't have support for this yet!
-       */
-      fprintf( errmsg( MSG_DEL_UNSUPPORTED ), progname, input->src, input->lineno );
-      free( input );
-    }
 
-    else
+    if( input->set && input->msg )
     {
-      /* This is either an `insert' or a `replace' operation...
-       * locate the insertion point, within the current message list.
+      /* The input reference specifies both set and message numbers.
+       * Thus, the operation to be performed relates to a single message,
+       * which is to be inserted, replaced or deleted at the appropriate
+       * position within the current message list; before proceeding,
+       * we must locate this position.
        */
-
       struct msgdict *curr = mark;
       while( curr && (curr->key < input->key) )
       {
+	/* We loop over the existing messages in the dictionary,
+	 * until we find the location at which the input message
+	 * should be placed; when we find it, we leave `curr'
+	 * pointing at the target location reference, while
+	 * `mark' points to its immediate predecessor.
+	 */
 	mark = curr;
 	curr = curr->link;
       }
 
-      if( curr == NULL )
+      /* Now that we've identified *where* the current input reference
+       * belongs, in the current message list, we may determine *what*
+       * action is to be performed for this record.
+       */
+      if( input->base && (curr == NULL) )
       {
-	/* This is appending to the end of the message list... */
-
+	/* The input record specifies actual message content,
+	 * which is to be appended to the end of the message list...
+	 */
 	if( mark )
 	{
-	  /* ...extending an existing message list. */
-
+	  /* ...extending an existing message list.
+	  */
 	  input->link = mark->link;
 	  mark->link = input;
 	  dfprintf(( stderr, "Append set %u message %u after set %u message %u\n",
 	               input->set, input->msg, mark->set, mark->msg
 	          ));
 	}
-
 	else
 	{
-	  /* There is no current message list; start one now! */
-
+	  /* ...there is no current message list; start one now!
+	   */
 	  cat = mark = input;
 	  mark->link = NULL;
 	  dfprintf(( stderr, "Initialise message list at set %u message %u\n", mark->set, mark->msg ));
 	}
       }
-
       else if( curr->key == input->key )
       {
-	/* This is replacement of an existing message. */
-
-	if( curr->lineno > 0 )
+	/* The input record refers to a message which is already present
+	 * in the current message list; the operation to be performed is
+	 * either deletion or replacement.
+	 */
+	if( input->base == NULL )
 	{
-	  /* This a collision...
-	   * diagnose, and ignore this redefinition.
+	  /* This input reference specifies no message content;
+	   * it is a request to delete the existing message.
+	   */
+	  if( curr == cat )
+	    /*
+	     * We are deleting the first message in the current list,
+	     * so we simply reassign the initial list entry.
+	     */
+	    cat = cat->link;
+
+	  else
+	    /* We are deleting a message from within the list, so we
+	     * relink the immediately preceding reference, to chain it
+	     * directly to the immediately succeeding one.
+	     */
+	    mark->link = curr->link;
+
+	  /* In either case, we may release the the memory allocated to
+	   * the defunct dictionary reference for the deleted message.
 	   */
+	  free( curr );
+	}
 
+	else if( curr->lineno > 0 )
+	{
+	  /* This a redefinition of a message which has previously been
+	   * sourced from another input file in the current input stream;
+	   * this represents a collision, which is probably unintentional,
+	   * so diagnose it, and ignore this redefinition.
+	   */
 	  fprintf( errmsg( MSG_REDEFINED ), GENCAT_MSG_INPUT, curr->msg, curr->set );
 	  fprintf( errmsg( MSG_PREVIOUS_HERE ), GENCAT_MSG_SRC( curr ));
 	}
 
 	else
 	{
+	  /* This is replacement of an existing message, which has
+	   * been inherited from a previously existing message catalogue;
+	   * such replacement is assumed to be intentional, so...
+	   */
 	  dfprintf(( stderr, "Replace set %u message %u\n", curr->set, curr->msg ));
-
 	  if( curr == cat )
 	  {
-	    /* This is the first message in the current list,
-	     * so we simply replace it.
+	    /* ...when this is the first message in the current list,
+	     * we simply replace it.
 	     */
-
 	    cat = input;
 	  }
 
 	  else
 	  {
-	    /* There are preceding messages in the list,
-	     * so we must relink the predecessor to this replacement.
+	    /* ...but when there are preceding messages in the list,
+	     * we must relink the predecessor to this replacement.
 	     */
-
 	    mark->link = input;
 	  }
 
+	  /* Now, to complete the replacement of the original message,
+	   * link any successor to the new reference, release the memory
+	   * allocated to the replaced dictionary entry, and mark the
+	   * new entry as the current reference point.
+	   */
 	  input->link = curr->link;
 	  free( curr );
 	  mark = input;
 	}
       }
-
       else
       {
-	/* This is insertion of a new message within the current list,
-	 * (maybe preceding all messages which are already in the list).
+	/* There is no existing reference with set and message numbers
+	 * matching the current input record; thus the input record must
+	 * be inserted between the existing `mark' and `curr' entries.
 	 */
-
 	dfprintf(( stderr, "Insert set %u message %u ", input->set, input->msg ));
 	if( mark == curr )
 	{
-	  /* This entry must precede any which is already in the list,
-	   * so make it the new initial message.
+	  /* The `curr' entry is the first in the existing dictionary,
+	   * so we insert the input record before it, as the new initial
+	   * entry in the dictionary, leaving `mark' pointing to it.
 	   */
-
 	  dfprintf(( stderr, "at start of list " ));
 	  cat = mark = input;
 	}
-
 	else
 	{
-	  /* There is already an existing message which must precede this one,
-	   * so link this new one to follow the existing predecessor.
+	  /* There is already an existing message which must precede this
+	   * new entry in the dictionary, so we link this new entry as its
+	   * immediate successor.
 	   */
-
 	  dfprintf(( stderr, "after set %u message %u and ", mark->set, mark->msg ));
 	  mark->link = input;
 	}
+	/*
+	 * In either case, any existing `curr' entry must be linked as
+	 * successor to the inserted entry.
+	 */
 	dfprintf(( stderr, "before set %u message %u\n", curr->set, curr->msg ));
 	input->link = curr;
       }
     }
+
+    else if( input->set && (input->base == NULL) )
+    {
+      /* This is a a `delset' operation...
+       * FIXME: we don't have support for this yet!
+       */
+      fprintf( errmsg( MSG_DEL_UNSUPPORTED ), progname, input->src, input->lineno );
+      free( input );
+    }
+
+    else
+    {
+      /* The input record contains an improperly formed message reference.
+       * We should *never* get to here!  If we do, then the entire message
+       * catalogue dictionary structure is invalid; diagnose and abort.
+       */
+      fprintf( errmsg( MSG_INTERNAL_ERROR ), progname, msgarg( MSG_BAD_INDEX ) );
+      exit( EXIT_FAILURE );
+    }
+
+    /* Whatever operation we have just performed, if no fatal error
+     * occurred we proceed to the next input record, if any, using the
+     * pointer we saved earlier, since `input->link' may not now be
+     * a valid reference; (`input' may have been `freed').
+     */
     input = next;
   }
 # ifdef DEBUG
@@ -197,7 +265,11 @@ struct msgdict *mc_merge( struct msgdict *cat, struct msgdict *input )
       fprintf( stderr, "%s:%u: set %u message %u\n", curr->src, curr->lineno, curr->set, curr->msg );
   }
 # endif
+
+  /* When all input records have been processed,
+   * we return the resultant message catalogue index to the caller.
+   */
   return cat;
 }
 
-/* $RCSfile$Revision$: end of file */
+/* $RCSfile$Revision: 1.1.1.1 $: end of file */

--- a/mcsource.c
+++ b/mcsource.c
@@ -9,7 +9,7 @@
  * used internally by `gencat', to compile message dictionaries.
  *
  * Written by Keith Marshall  <[e-mail]>
- * Last modification: 11-May-2007
+ * Last modification: 12-May-2007
  *
  *
  * This is free software.  It is provided AS IS, in the hope that it may
@@ -543,9 +543,16 @@ struct msgdict *mc_source( const char *input )
 
                     /* We may now complete the message details in the new
                      * dictionary slot, and commit the record to the catalogue.
+		     * Note that, if the message number tag in the source file
+		     * is on an otherwise empty line, and is *immediately*
+		     * followed by a newline, with no intervening space,
+		     * then this message should be deleted; we flag this
+		     * by setting `this->base = NULL'.  In all other cases,
+		     * the message is to be placed into the catalogue, so
+		     * we set 'this->base = messages'.
                      */
 		    this->src = input;
-		    this->base = messages;
+		    this->base = (c == L'\n') ? NULL : messages;
 		    this->lineno = linenum;
                     this->set = setnum;
                     this->msg = msgnum = accumulator;
@@ -573,8 +580,10 @@ struct msgdict *mc_source( const char *input )
 
                 else
                 {
-                  /* This doesn't satisfy the requirement for incrementing "msgnum",
-                   * so complain, and bail out.
+                  /* This doesn't satisfy the POSIX requirement that,
+                   * within each set, messages must appear in strictly
+                   * incrementing "msgnum" order, so complain, and
+                   * bail out.
                    */
                   dfputc(( '\n', stderr ));
                   gencat_errno = mc_errout( FATAL( MSG_MSGNUM_NOT_INCR ), msgnum, accumulator );
@@ -832,6 +841,12 @@ struct msgdict *mc_source( const char *input )
   dfprintf(( stderr, "\n\nAllocation adjusted to %u bytes\n", (unsigned)(msgloc) ));
   for( tail = head; tail != NULL; tail = tail->link )
   {
+    /* Just do this for all entries in the list!
+     * Don't assume we can optimise by quitting if we find a reference
+     * which is already mapped to the correct address; the list could
+     * have moved, and subsequently have moved back to the old address,
+     * in which case a later entry could be invalid.
+     */
     if( tail->base != NULL )
       /*
        * Update index entries *except* those with a NULL base pointer;
@@ -849,4 +864,4 @@ struct msgdict *mc_source( const char *input )
   return head;
 }
 
-/* $RCSfile$Revision: 1.4 $: end of file */
+/* $RCSfile$Revision: 1.5 $: end of file */