mingw/gettext/gettext-tools/src/format-c.c - kiwivm - Git at Google

 /* C format strings.
    Copyright (C) 2001-2004, 2006-2007, 2009-2010, 2019 Free Software Foundation, Inc.
    Written by Bruno Haible <haible@clisp.cons.org>, 2001.

    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
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */

 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif

 #include <stdbool.h>
 #include <stdlib.h>

 #include "format.h"
 #include "c-ctype.h"
 #include "xalloc.h"
 #include "xvasprintf.h"
 #include "gettext.h"

 #define _(str) gettext (str)

 #include "format-invalid.h"

 #define INVALID_C99_MACRO(directive_number) \
   xasprintf (_("In the directive number %u, the token after '<' is not the name of a format specifier macro. The valid macro names are listed in ISO C 99 section 7.8.1."), directive_number)

 #define INVALID_ANGLE_BRACKET(directive_number) \
   xasprintf (_("In the directive number %u, the token after '<' is not followed by '>'."), directive_number)

 #define INVALID_IGNORED_ARGUMENT(referenced_arg, ignored_arg) \
   xasprintf (_("The string refers to argument number %u but ignores argument number %u."), referenced_arg, ignored_arg)

 /* Execute statement if memory allocation function returned NULL.  */
 #define IF_OOM(allocated_ptr, statement)  /* nothing, since we use xalloc.h */

 /* Specifies whether the system dependent segments in msgid and msgstr have
    been processed.  This means:
      - If false, ISO C 99 <inttypes.h> directives are denoted with angle
        brackets.  If true, they have already been expanded, leading in
        particular to %I64d directives on native Windows platforms.
      - If false, the 'I' flag may be present in msgstr (also on platforms
        other than glibc).  If true, the 'I' directive may be present in msgstr
        only on glibc >= 2.2 platforms.  */
 #define SYSDEP_SEGMENTS_PROCESSED false

 /* Include the bulk of the C format string parsing code.  */
 #include "format-c-parse.h"

 static void *
 format_parse (const char *format, bool translated, bool objc_extensions,
               char *fdi, char **invalid_reason)
 {
   struct spec result_buf;
   struct spec *result;

   result = format_parse_entrails (format, translated, objc_extensions, fdi, invalid_reason, &result_buf);

   if (result != NULL)
     {
       /* Copy the result to a heap-allocated object.  */
       struct spec *safe_result = XMALLOC (struct spec);
       *safe_result = *result;
       result = safe_result;
     }
   return result;
 }

 static void *
 format_c_parse (const char *format, bool translated, char *fdi,
                 char **invalid_reason)
 {
   return format_parse (format, translated, false, fdi, invalid_reason);
 }

 static void *
 format_objc_parse (const char *format, bool translated, char *fdi,
                    char **invalid_reason)
 {
   return format_parse (format, translated, true, fdi, invalid_reason);
 }

 static void
 format_free (void *descr)
 {
   struct spec *spec = (struct spec *) descr;

   if (spec->unnumbered != NULL)
     free (spec->unnumbered);
   if (spec->sysdep_directives != NULL)
     free (spec->sysdep_directives);
   free (spec);
 }

 static bool
 format_is_unlikely_intentional (void *descr)
 {
   struct spec *spec = (struct spec *) descr;

   return spec->unlikely_intentional;
 }

 static int
 format_get_number_of_directives (void *descr)
 {
   struct spec *spec = (struct spec *) descr;

   return spec->directives;
 }

 static bool
 format_check (void *msgid_descr, void *msgstr_descr, bool equality,
               formatstring_error_logger_t error_logger,
               const char *pretty_msgid, const char *pretty_msgstr)
 {
   struct spec *spec1 = (struct spec *) msgid_descr;
   struct spec *spec2 = (struct spec *) msgstr_descr;
   bool err = false;
   unsigned int i;

   /* Check the argument types are the same.  */
   if (equality
       ? spec1->unnumbered_arg_count != spec2->unnumbered_arg_count
       : spec1->unnumbered_arg_count < spec2->unnumbered_arg_count)
     {
       if (error_logger)
         error_logger (_("number of format specifications in '%s' and '%s' does not match"),
                       pretty_msgid, pretty_msgstr);
       err = true;
     }
   else
     for (i = 0; i < spec2->unnumbered_arg_count; i++)
       if (spec1->unnumbered[i].type != spec2->unnumbered[i].type)
         {
           if (error_logger)
             error_logger (_("format specifications in '%s' and '%s' for argument %u are not the same"),
                           pretty_msgid, pretty_msgstr, i + 1);
           err = true;
         }

   return err;
 }


 struct formatstring_parser formatstring_c =
 {
   format_c_parse,
   format_free,
   format_get_number_of_directives,
   format_is_unlikely_intentional,
   format_check
 };


 struct formatstring_parser formatstring_objc =
 {
   format_objc_parse,
   format_free,
   format_get_number_of_directives,
   format_is_unlikely_intentional,
   format_check
 };


 void
 get_sysdep_c_format_directives (const char *string, bool translated,
                                 struct interval **intervalsp, size_t *lengthp)
 {
   /* Parse the format string with all possible extensions turned on.  (The
      caller has already verified that the format string is valid for the
      particular language.)  */
   char *invalid_reason = NULL;
   struct spec *descr =
     (struct spec *)
     format_parse (string, translated, true, NULL, &invalid_reason);

   if (descr != NULL && descr->sysdep_directives_count > 0)
     {
       unsigned int n = descr->sysdep_directives_count;
       struct interval *intervals = XNMALLOC (n, struct interval);
       unsigned int i;

       for (i = 0; i < n; i++)
         {
           intervals[i].startpos = descr->sysdep_directives[2 * i] - string;
           intervals[i].endpos = descr->sysdep_directives[2 * i + 1] - string;
         }
       *intervalsp = intervals;
       *lengthp = n;
     }
   else
     {
       *intervalsp = NULL;
       *lengthp = 0;
     }

   if (descr != NULL)
     format_free (descr);
   else
     free (invalid_reason);
 }


 #ifdef TEST

 /* Test program: Print the argument list specification returned by
    format_parse for strings read from standard input.  */

 #include <stdio.h>

 static void
 format_print (void *descr)
 {
   struct spec *spec = (struct spec *) descr;
   unsigned int i;

   if (spec == NULL)
     {
       printf ("INVALID");
       return;
     }

   printf ("(");
   for (i = 0; i < spec->unnumbered_arg_count; i++)
     {
       if (i > 0)
         printf (" ");
       if (spec->unnumbered[i].type & FAT_UNSIGNED)
         printf ("[unsigned]");
       switch (spec->unnumbered[i].type & FAT_SIZE_MASK)
         {
         case 0:
           break;
         case FAT_SIZE_SHORT:
           printf ("[short]");
           break;
         case FAT_SIZE_CHAR:
           printf ("[char]");
           break;
         case FAT_SIZE_LONG:
           printf ("[long]");
           break;
         case FAT_SIZE_LONGLONG:
           printf ("[long long]");
           break;
         case FAT_SIZE_8_T:
           printf ("[int8_t]");
           break;
         case FAT_SIZE_16_T:
           printf ("[int16_t]");
           break;
         case FAT_SIZE_32_T:
           printf ("[int32_t]");
           break;
         case FAT_SIZE_64_T:
           printf ("[int64_t]");
           break;
         case FAT_SIZE_LEAST8_T:
           printf ("[int_least8_t]");
           break;
         case FAT_SIZE_LEAST16_T:
           printf ("[int_least16_t]");
           break;
         case FAT_SIZE_LEAST32_T:
           printf ("[int_least32_t]");
           break;
         case FAT_SIZE_LEAST64_T:
           printf ("[int_least64_t]");
           break;
         case FAT_SIZE_FAST8_T:
           printf ("[int_fast8_t]");
           break;
         case FAT_SIZE_FAST16_T:
           printf ("[int_fast16_t]");
           break;
         case FAT_SIZE_FAST32_T:
           printf ("[int_fast32_t]");
           break;
         case FAT_SIZE_FAST64_T:
           printf ("[int_fast64_t]");
           break;
         case FAT_SIZE_INTMAX_T:
           printf ("[intmax_t]");
           break;
         case FAT_SIZE_INTPTR_T:
           printf ("[intptr_t]");
           break;
         case FAT_SIZE_SIZE_T:
           printf ("[size_t]");
           break;
         case FAT_SIZE_PTRDIFF_T:
           printf ("[ptrdiff_t]");
           break;
         default:
           abort ();
         }
       switch (spec->unnumbered[i].type & ~(FAT_UNSIGNED | FAT_SIZE_MASK))
         {
         case FAT_INTEGER:
           printf ("i");
           break;
         case FAT_DOUBLE:
           printf ("f");
           break;
         case FAT_CHAR:
           printf ("c");
           break;
         case FAT_STRING:
           printf ("s");
           break;
         case FAT_OBJC_OBJECT:
           printf ("@");
           break;
         case FAT_POINTER:
           printf ("p");
           break;
         case FAT_COUNT_POINTER:
           printf ("n");
           break;
         default:
           abort ();
         }
     }
   printf (")");
 }

 int
 main ()
 {
   for (;;)
     {
       char *line = NULL;
       size_t line_size = 0;
       int line_len;
       char *invalid_reason;
       void *descr;

       line_len = getline (&line, &line_size, stdin);
       if (line_len < 0)
         break;
       if (line_len > 0 && line[line_len - 1] == '\n')
         line[--line_len] = '\0';

       invalid_reason = NULL;
       descr = format_c_parse (line, false, NULL, &invalid_reason);

       format_print (descr);
       printf ("\n");
       if (descr == NULL)
         printf ("%s\n", invalid_reason);

       free (invalid_reason);
       free (line);
     }

   return 0;
 }

 /*
  * For Emacs M-x compile
  * Local Variables:
  * compile-command: "/bin/sh ../libtool --tag=CC --mode=link gcc -o a.out -static -O -g -Wall -I.. -I../gnulib-lib -I../../gettext-runtime/intl -DHAVE_CONFIG_H -DTEST format-c.c ../gnulib-lib/libgettextlib.la"
  * End:
  */

 #endif /* TEST */
	/* C format strings.
	Copyright (C) 2001-2004, 2006-2007, 2009-2010, 2019 Free Software Foundation, Inc.
	Written by Bruno Haible <haible@clisp.cons.org>, 2001.

	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
	the Free Software Foundation; either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program. If not, see <https://www.gnu.org/licenses/>. */

	#ifdef HAVE_CONFIG_H
	# include <config.h>
	#endif

	#include <stdbool.h>
	#include <stdlib.h>

	#include "format.h"
	#include "c-ctype.h"
	#include "xalloc.h"
	#include "xvasprintf.h"
	#include "gettext.h"

	#define _(str) gettext (str)

	#include "format-invalid.h"

	#define INVALID_C99_MACRO(directive_number) \
	xasprintf (_("In the directive number %u, the token after '<' is not the name of a format specifier macro. The valid macro names are listed in ISO C 99 section 7.8.1."), directive_number)

	#define INVALID_ANGLE_BRACKET(directive_number) \
	xasprintf (_("In the directive number %u, the token after '<' is not followed by '>'."), directive_number)

	#define INVALID_IGNORED_ARGUMENT(referenced_arg, ignored_arg) \
	xasprintf (_("The string refers to argument number %u but ignores argument number %u."), referenced_arg, ignored_arg)

	/* Execute statement if memory allocation function returned NULL. */
	#define IF_OOM(allocated_ptr, statement) /* nothing, since we use xalloc.h */

	/* Specifies whether the system dependent segments in msgid and msgstr have
	been processed. This means:
	- If false, ISO C 99 <inttypes.h> directives are denoted with angle
	brackets. If true, they have already been expanded, leading in
	particular to %I64d directives on native Windows platforms.
	- If false, the 'I' flag may be present in msgstr (also on platforms
	other than glibc). If true, the 'I' directive may be present in msgstr
	only on glibc >= 2.2 platforms. */
	#define SYSDEP_SEGMENTS_PROCESSED false

	/* Include the bulk of the C format string parsing code. */
	#include "format-c-parse.h"

	static void *
	format_parse (const char *format, bool translated, bool objc_extensions,
	char fdi, char *invalid_reason)
	{
	struct spec result_buf;
	struct spec *result;

	result = format_parse_entrails (format, translated, objc_extensions, fdi, invalid_reason, &result_buf);

	if (result != NULL)
	{
	/* Copy the result to a heap-allocated object. */
	struct spec *safe_result = XMALLOC (struct spec);
	safe_result = result;
	result = safe_result;
	}
	return result;
	}

	static void *
	format_c_parse (const char format, bool translated, char fdi,
	char **invalid_reason)
	{
	return format_parse (format, translated, false, fdi, invalid_reason);
	}

	static void *
	format_objc_parse (const char format, bool translated, char fdi,
	char **invalid_reason)
	{
	return format_parse (format, translated, true, fdi, invalid_reason);
	}

	static void
	format_free (void *descr)
	{
	struct spec spec = (struct spec ) descr;

	if (spec->unnumbered != NULL)
	free (spec->unnumbered);
	if (spec->sysdep_directives != NULL)
	free (spec->sysdep_directives);
	free (spec);
	}

	static bool
	format_is_unlikely_intentional (void *descr)
	{
	struct spec spec = (struct spec ) descr;

	return spec->unlikely_intentional;
	}

	static int
	format_get_number_of_directives (void *descr)
	{
	struct spec spec = (struct spec ) descr;

	return spec->directives;
	}

	static bool
	format_check (void msgid_descr, void msgstr_descr, bool equality,
	formatstring_error_logger_t error_logger,
	const char pretty_msgid, const char pretty_msgstr)
	{
	struct spec spec1 = (struct spec ) msgid_descr;
	struct spec spec2 = (struct spec ) msgstr_descr;
	bool err = false;
	unsigned int i;

	/* Check the argument types are the same. */
	if (equality
	? spec1->unnumbered_arg_count != spec2->unnumbered_arg_count
	: spec1->unnumbered_arg_count < spec2->unnumbered_arg_count)
	{
	if (error_logger)
	error_logger (_("number of format specifications in '%s' and '%s' does not match"),
	pretty_msgid, pretty_msgstr);
	err = true;
	}
	else
	for (i = 0; i < spec2->unnumbered_arg_count; i++)
	if (spec1->unnumbered[i].type != spec2->unnumbered[i].type)
	{
	if (error_logger)
	error_logger (_("format specifications in '%s' and '%s' for argument %u are not the same"),
	pretty_msgid, pretty_msgstr, i + 1);
	err = true;
	}

	return err;
	}


	struct formatstring_parser formatstring_c =
	{
	format_c_parse,
	format_free,
	format_get_number_of_directives,
	format_is_unlikely_intentional,
	format_check
	};


	struct formatstring_parser formatstring_objc =
	{
	format_objc_parse,
	format_free,
	format_get_number_of_directives,
	format_is_unlikely_intentional,
	format_check
	};


	void
	get_sysdep_c_format_directives (const char *string, bool translated,
	struct interval *intervalsp, size_t lengthp)
	{
	/* Parse the format string with all possible extensions turned on. (The
	caller has already verified that the format string is valid for the
	particular language.) */
	char *invalid_reason = NULL;
	struct spec *descr =
	(struct spec *)
	format_parse (string, translated, true, NULL, &invalid_reason);

	if (descr != NULL && descr->sysdep_directives_count > 0)
	{
	unsigned int n = descr->sysdep_directives_count;
	struct interval *intervals = XNMALLOC (n, struct interval);
	unsigned int i;

	for (i = 0; i < n; i++)
	{
	intervals[i].startpos = descr->sysdep_directives[2 * i] - string;
	intervals[i].endpos = descr->sysdep_directives[2 * i + 1] - string;
	}
	*intervalsp = intervals;
	*lengthp = n;
	}
	else
	{
	*intervalsp = NULL;
	*lengthp = 0;
	}

	if (descr != NULL)
	format_free (descr);
	else
	free (invalid_reason);
	}


	#ifdef TEST

	/* Test program: Print the argument list specification returned by
	format_parse for strings read from standard input. */

	#include <stdio.h>

	static void
	format_print (void *descr)
	{
	struct spec spec = (struct spec ) descr;
	unsigned int i;

	if (spec == NULL)
	{
	printf ("INVALID");
	return;
	}

	printf ("(");
	for (i = 0; i < spec->unnumbered_arg_count; i++)
	{
	if (i > 0)
	printf (" ");
	if (spec->unnumbered[i].type & FAT_UNSIGNED)
	printf ("[unsigned]");
	switch (spec->unnumbered[i].type & FAT_SIZE_MASK)
	{
	case 0:
	break;
	case FAT_SIZE_SHORT:
	printf ("[short]");
	break;
	case FAT_SIZE_CHAR:
	printf ("[char]");
	break;
	case FAT_SIZE_LONG:
	printf ("[long]");
	break;
	case FAT_SIZE_LONGLONG:
	printf ("[long long]");
	break;
	case FAT_SIZE_8_T:
	printf ("[int8_t]");
	break;
	case FAT_SIZE_16_T:
	printf ("[int16_t]");
	break;
	case FAT_SIZE_32_T:
	printf ("[int32_t]");
	break;
	case FAT_SIZE_64_T:
	printf ("[int64_t]");
	break;
	case FAT_SIZE_LEAST8_T:
	printf ("[int_least8_t]");
	break;
	case FAT_SIZE_LEAST16_T:
	printf ("[int_least16_t]");
	break;
	case FAT_SIZE_LEAST32_T:
	printf ("[int_least32_t]");
	break;
	case FAT_SIZE_LEAST64_T:
	printf ("[int_least64_t]");
	break;
	case FAT_SIZE_FAST8_T:
	printf ("[int_fast8_t]");
	break;
	case FAT_SIZE_FAST16_T:
	printf ("[int_fast16_t]");
	break;
	case FAT_SIZE_FAST32_T:
	printf ("[int_fast32_t]");
	break;
	case FAT_SIZE_FAST64_T:
	printf ("[int_fast64_t]");
	break;
	case FAT_SIZE_INTMAX_T:
	printf ("[intmax_t]");
	break;
	case FAT_SIZE_INTPTR_T:
	printf ("[intptr_t]");
	break;
	case FAT_SIZE_SIZE_T:
	printf ("[size_t]");
	break;
	case FAT_SIZE_PTRDIFF_T:
	printf ("[ptrdiff_t]");
	break;
	default:
	abort ();
	}
	switch (spec->unnumbered[i].type & ~(FAT_UNSIGNED \| FAT_SIZE_MASK))
	{
	case FAT_INTEGER:
	printf ("i");
	break;
	case FAT_DOUBLE:
	printf ("f");
	break;
	case FAT_CHAR:
	printf ("c");
	break;
	case FAT_STRING:
	printf ("s");
	break;
	case FAT_OBJC_OBJECT:
	printf ("@");
	break;
	case FAT_POINTER:
	printf ("p");
	break;
	case FAT_COUNT_POINTER:
	printf ("n");
	break;
	default:
	abort ();
	}
	}
	printf (")");
	}

	int
	main ()
	{
	for (;;)
	{
	char *line = NULL;
	size_t line_size = 0;
	int line_len;
	char *invalid_reason;
	void *descr;

	line_len = getline (&line, &line_size, stdin);
	if (line_len < 0)
	break;
	if (line_len > 0 && line[line_len - 1] == '\n')
	line[--line_len] = '\0';

	invalid_reason = NULL;
	descr = format_c_parse (line, false, NULL, &invalid_reason);

	format_print (descr);
	printf ("\n");
	if (descr == NULL)
	printf ("%s\n", invalid_reason);

	free (invalid_reason);
	free (line);
	}

	return 0;
	}

	/*
	* For Emacs M-x compile
	* Local Variables:
	* compile-command: "/bin/sh ../libtool --tag=CC --mode=link gcc -o a.out -static -O -g -Wall -I.. -I../gnulib-lib -I../../gettext-runtime/intl -DHAVE_CONFIG_H -DTEST format-c.c ../gnulib-lib/libgettextlib.la"
	* End:
	*/

	#endif /* TEST */