Return true upon eof, false upon closing parenthesis. */
static bool
extract_parenthesized (message_list_ty *mlp,
- flag_context_ty outer_context,
+ flag_region_ty *outer_region,
flag_context_list_iterator_ty context_iter,
struct arglist_parser *argparser)
{
/* Context iterator that will be used if the next token is a '('. */
flag_context_list_iterator_ty next_context_iter =
passthrough_context_list_iterator;
- /* Current context. */
- flag_context_ty inner_context =
- inherited_context (outer_context,
+ /* Current region. */
+ flag_region_ty *inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (&context_iter));
/* Start state is 0. */
{
/* An argument list starts, even though there is no '('. */
context_iter = next_context_iter;
- outer_context = inner_context;
- inner_context =
- inherited_context (outer_context,
+ assign_region (outer_region, inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
}
if_error (IF_SEVERITY_FATAL_ERROR,
logical_file_name, line_number, (size_t)(-1), false,
_("too many open parentheses"));
- if (extract_parenthesized (mlp, inner_context, next_context_iter,
+ if (extract_parenthesized (mlp, inner_region, next_context_iter,
arglist_parser_alloc (mlp,
state ? next_shapes : NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
nesting_depth--;
case token_type_rparen:
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
case token_type_comma:
arg++;
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
next_is_argument = false;
if (extract_all)
remember_a_message (mlp, NULL, token.string, false, false,
- inner_context, &pos,
+ inner_region, &pos,
NULL, savable_comment, false);
else
{
pos.file_name, pos.line_number);
free (token.string);
arglist_parser_remember (argparser, arg, ms,
- inner_context,
+ inner_region,
pos.file_name, pos.line_number,
savable_comment, false);
}
pos.line_number = token.line_number;
remember_a_message (mlp, NULL, token.string, false, false,
- inner_context, &pos,
+ inner_region, &pos,
NULL, savable_comment, false);
}
next_is_argument = false;
/* An argument list ends, and a new statement begins. */
/* FIXME: Should handle newline that acts as statement separator
in the same way. */
- /* FIXME: Instead of resetting outer_context here, it may be better
+ /* FIXME: Instead of resetting outer_region here, it may be better
to recurse in the next_is_argument handling above, waiting for
the next semicolon or other statement terminator. */
- outer_context = null_context;
+ outer_region = null_context_region ();
context_iter = null_context_list_iterator;
next_is_argument = false;
next_context_iter = passthrough_context_list_iterator;
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
state = 0;
case token_type_eof:
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
case token_type_other:
/* Eat tokens until eof is seen. When extract_parenthesized returns
due to an unbalanced closing parenthesis, just restart it. */
- while (!extract_parenthesized (mlp, null_context, null_context_list_iterator,
+ while (!extract_parenthesized (mlp, null_context_region (), null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
;
Return true upon eof, false upon closing parenthesis. */
static bool
extract_parenthesized (message_list_ty *mlp,
- flag_context_ty outer_context,
+ flag_region_ty *outer_region,
flag_context_list_iterator_ty context_iter,
struct arglist_parser *argparser)
{
(Objective C selector syntax.) */
flag_context_list_iterator_ty selectorcall_context_iter =
passthrough_context_list_iterator;
- /* Current context. */
- flag_context_ty inner_context =
- inherited_context (outer_context,
+ /* Current region. */
+ flag_region_ty *inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (&context_iter));
/* Start state is 0. */
if_error (IF_SEVERITY_FATAL_ERROR,
logical_file_name, line_number, (size_t)(-1), false,
_("too many open parentheses"));
- if (extract_parenthesized (mlp, inner_context, next_context_iter,
+ if (extract_parenthesized (mlp, inner_region, next_context_iter,
arglist_parser_alloc (mlp,
state ? next_shapes : NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
nesting_depth--;
case xgettext_token_type_rparen:
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
case xgettext_token_type_comma:
arg++;
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
next_context_iter = passthrough_context_list_iterator;
if (objc_extensions)
{
context_iter = selectorcall_context_iter;
- inner_context =
- inherited_context (inner_context,
+ assign_new_region (inner_region,
+ inheriting_region (inner_region,
flag_context_list_iterator_advance (
- &context_iter));
+ &context_iter)));
next_context_iter = passthrough_context_list_iterator;
selectorcall_context_iter = passthrough_context_list_iterator;
}
char *string = mixed_string_contents (token.mixed_string);
mixed_string_free (token.mixed_string);
remember_a_message (mlp, NULL, string, true, false,
- inner_context, &token.pos,
+ inner_region, &token.pos,
NULL, token.comment, false);
}
else
arglist_parser_remember (argparser, arg, token.mixed_string,
- inner_context,
+ inner_region,
token.pos.file_name,
token.pos.line_number,
token.comment, false);
case xgettext_token_type_eof:
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
default:
/* Eat tokens until eof is seen. When extract_parenthesized returns
due to an unbalanced closing parenthesis, just restart it. */
- while (!extract_parenthesized (mlp, null_context, null_context_list_iterator,
+ while (!extract_parenthesized (mlp, null_context_region (), null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
;
Return true upon eof, false upon closing parenthesis or brace. */
static bool
extract_parenthesized (message_list_ty *mlp, token_type_ty terminator,
- flag_context_ty outer_context,
+ flag_region_ty *outer_region,
flag_context_list_iterator_ty context_iter,
struct arglist_parser *argparser)
{
/* Context iterator that will be used if the next token is a '('. */
flag_context_list_iterator_ty next_context_iter =
passthrough_context_list_iterator;
- /* Current context. */
- flag_context_ty inner_context =
- inherited_context (outer_context,
+ /* Current region. */
+ flag_region_ty *inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (&context_iter));
/* Start state is 0. */
logical_file_name, line_number, (size_t)(-1), false,
_("too many open parentheses"));
if (extract_parenthesized (mlp, token_type_rparen,
- inner_context, next_context_iter,
+ inner_region, next_context_iter,
arglist_parser_alloc (mlp,
state ? next_shapes : NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
paren_nesting_depth--;
if (terminator == token_type_rparen)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
if (terminator == token_type_rbrace)
logical_file_name, line_number, (size_t)(-1), false,
_("too many open braces"));
if (extract_parenthesized (mlp, token_type_rbrace,
- null_context, null_context_list_iterator,
+ null_context_region (),
+ null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
brace_nesting_depth--;
if (terminator == token_type_rbrace)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
if (terminator == token_type_rparen)
case token_type_comma:
arg++;
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
next_context_iter = passthrough_context_list_iterator;
char *string = mixed_string_contents (token.mixed_string);
mixed_string_free (token.mixed_string);
remember_a_message (mlp, NULL, string, true, false,
- inner_context, &pos,
+ inner_region, &pos,
NULL, token.comment, true);
}
else
arglist_parser_remember (argparser, arg, token.mixed_string,
- inner_context,
+ inner_region,
pos.file_name, pos.line_number,
token.comment, true);
}
case token_type_eof:
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
case token_type_dot:
/* Eat tokens until eof is seen. When extract_parenthesized returns
due to an unbalanced closing parenthesis, just restart it. */
while (!extract_parenthesized (mlp, token_type_eof,
- null_context, null_context_list_iterator,
+ null_context_region (),
+ null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
;
remember_a_message (extract_reader->mlp, NULL,
desktop_unescape_string (value, is_list), false,
- false, null_context, key_pos,
+ false, null_context_region (), key_pos,
NULL, savable_comment, false);
}
savable_comment_reset ();
backquote syntax and new backquote syntax. */
static void
read_object (struct object *op, bool first_in_list, bool new_backquote_flag,
- flag_context_ty outer_context)
+ flag_region_ty *outer_region)
{
if (nesting_depth > MAX_NESTING_DEPTH)
if_error (IF_SEVERITY_FATAL_ERROR,
for (;; arg++)
{
struct object inner;
- flag_context_ty inner_context;
+ flag_region_ty *inner_region;
if (arg == 0)
- inner_context = null_context;
+ inner_region = null_context_region ();
else
- inner_context =
- inherited_context (outer_context,
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
++nesting_depth;
read_object (&inner, arg == 0, new_backquote_flag,
- inner_context);
+ inner_region);
nesting_depth--;
/* Recognize end of list. */
last_non_comment_line = line_number;
if (argparser != NULL)
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return;
}
inner.line_number_at_start);
free (s);
arglist_parser_remember (argparser, arg, ms,
- inner_context,
+ inner_region,
logical_file_name,
inner.line_number_at_start,
savable_comment, false);
}
}
+ unref_region (inner_region);
free_object (&inner);
}
struct object inner;
++nesting_depth;
- read_object (&inner, false, new_backquote_flag, null_context);
+ read_object (&inner, false, new_backquote_flag,
+ null_context_region ());
nesting_depth--;
/* Recognize end of vector. */
struct object inner;
++nesting_depth;
- read_object (&inner, false, new_backquote_flag, null_context);
+ read_object (&inner, false, new_backquote_flag,
+ null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here. But be tolerant. */
struct object inner;
++nesting_depth;
- read_object (&inner, false, true, null_context);
+ read_object (&inner, false, true, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here. But be tolerant. */
struct object inner;
++nesting_depth;
- read_object (&inner, false, false, null_context);
+ read_object (&inner, false, false, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here. But be tolerant. */
pos.file_name = logical_file_name;
pos.line_number = op->line_number_at_start;
remember_a_message (mlp, NULL, string_of_object (op), false,
- false, null_context, &pos,
+ false, null_context_region (), &pos,
NULL, savable_comment, false);
}
last_non_comment_line = line_number;
++nesting_depth;
read_object (&inner, false, new_backquote_flag,
- null_context);
+ null_context_region ());
nesting_depth--;
/* Recognize end of vector. */
struct object length;
++nesting_depth;
read_object (&length, first_in_list, new_backquote_flag,
- null_context);
+ null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here.
But be tolerant. */
struct object string;
++nesting_depth;
read_object (&string, first_in_list, new_backquote_flag,
- null_context);
+ null_context_region ());
nesting_depth--;
free_object (&string);
}
struct object inner;
do_ungetc (dmc);
++nesting_depth;
- read_object (&inner, false, new_backquote_flag, null_context);
+ read_object (&inner, false, new_backquote_flag,
+ null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here.
But be tolerant. */
{
struct object inner;
++nesting_depth;
- read_object (&inner, false, new_backquote_flag, null_context);
+ read_object (&inner, false, new_backquote_flag,
+ null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here.
But be tolerant. */
if (c == '=')
{
++nesting_depth;
- read_object (op, false, new_backquote_flag, outer_context);
+ read_object (op, false, new_backquote_flag, outer_region);
nesting_depth--;
last_non_comment_line = line_number;
return;
{
struct object inner;
++nesting_depth;
- read_object (&inner, false, new_backquote_flag, null_context);
+ read_object (&inner, false, new_backquote_flag,
+ null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here.
But be tolerant. */
{
struct object toplevel_object;
- read_object (&toplevel_object, false, false, null_context);
+ read_object (&toplevel_object, false, false, null_context_region ());
if (toplevel_object.type == t_eof)
break;
Return true upon eof, false upon closing parenthesis or brace. */
static bool
extract_parenthesized (message_list_ty *mlp, token_type_ty terminator,
- flag_context_ty outer_context,
+ flag_region_ty *outer_region,
flag_context_list_iterator_ty context_iter,
struct arglist_parser *argparser)
{
/* Context iterator that will be used if the next token is a '('. */
flag_context_list_iterator_ty next_context_iter =
passthrough_context_list_iterator;
- /* Current context. */
- flag_context_ty inner_context =
- inherited_context (outer_context,
+ /* Current region. */
+ flag_region_ty *inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (&context_iter));
/* Start state is 0. */
logical_file_name, line_number, (size_t)(-1), false,
_("too many open parentheses"));
if (extract_parenthesized (mlp, token_type_rparen,
- inner_context, next_context_iter,
+ inner_region, next_context_iter,
arglist_parser_alloc (mlp,
state ? next_shapes : NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
paren_nesting_depth--;
if (terminator == token_type_rparen)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
if (terminator == token_type_rbrace)
logical_file_name, line_number, (size_t)(-1), false,
_("too many open braces"));
if (extract_parenthesized (mlp, token_type_rbrace,
- null_context, null_context_list_iterator,
+ null_context_region (),
+ null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
brace_nesting_depth--;
if (terminator == token_type_rbrace)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
if (terminator == token_type_rparen)
case token_type_comma:
arg++;
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
next_context_iter = passthrough_context_list_iterator;
char *string = mixed_string_contents (token.mixed_string);
mixed_string_free (token.mixed_string);
remember_a_message (mlp, NULL, string, true, false,
- inner_context, &pos,
+ inner_region, &pos,
NULL, token.comment, true);
}
else
arglist_parser_remember (argparser, arg, token.mixed_string,
- inner_context,
+ inner_region,
pos.file_name, pos.line_number,
token.comment, true);
}
case token_type_eof:
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
case token_type_dot:
/* Eat tokens until eof is seen. When extract_parenthesized returns
due to an unbalanced closing parenthesis, just restart it. */
while (!extract_parenthesized (mlp, token_type_eof,
- null_context, null_context_list_iterator,
+ null_context_region (),
+ null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
;
static bool
extract_balanced (message_list_ty *mlp,
token_type_ty delim,
- flag_context_ty outer_context,
+ flag_region_ty *outer_region,
flag_context_list_iterator_ty context_iter,
struct arglist_parser *argparser)
{
/* Context iterator that will be used if the next token is a '('. */
flag_context_list_iterator_ty next_context_iter =
passthrough_context_list_iterator;
- /* Current context. */
- flag_context_ty inner_context =
- inherited_context (outer_context,
+ /* Current region. */
+ flag_region_ty *inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (&context_iter));
/* Start state is 0. */
logical_file_name, line_number, (size_t)(-1), false,
_("too many open parentheses"));
if (extract_balanced (mlp, token_type_rparen,
- inner_context, next_context_iter,
+ inner_region, next_context_iter,
arglist_parser_alloc (mlp,
state ? next_shapes : NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
paren_nesting_depth--;
if (delim == token_type_rparen || delim == token_type_eof)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
next_context_iter = null_context_list_iterator;
case token_type_comma:
arg++;
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
next_context_iter = passthrough_context_list_iterator;
logical_file_name, line_number, (size_t)(-1), false,
_("too many open brackets"));
if (extract_balanced (mlp, token_type_rbracket,
- null_context, null_context_list_iterator,
+ null_context_region (),
+ null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
bracket_nesting_depth--;
if (delim == token_type_rbracket || delim == token_type_eof)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
next_context_iter = null_context_list_iterator;
logical_file_name, line_number, (size_t)(-1), false,
_("too many open braces"));
if (extract_balanced (mlp, token_type_rbrace,
- null_context, null_context_list_iterator,
+ null_context_region (),
+ null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
brace_nesting_depth--;
if (delim == token_type_rbrace || delim == token_type_eof)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
next_context_iter = null_context_list_iterator;
char *string = mixed_string_contents (token.mixed_string);
mixed_string_free (token.mixed_string);
remember_a_message (mlp, NULL, string, true, false,
- inner_context, &pos,
+ inner_region, &pos,
NULL, token.comment, true);
}
else
arglist_parser_remember (argparser, arg, token.mixed_string,
- inner_context,
+ inner_region,
pos.file_name, pos.line_number,
token.comment, true);
}
logical_file_name, line_number, (size_t)(-1), false,
_("too many open XML elements"));
if (extract_balanced (mlp, token_type_xml_element_end,
- null_context, null_context_list_iterator,
+ null_context_region (),
+ null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
xml_element_nesting_depth--;
if (delim == token_type_xml_element_end || delim == token_type_eof)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
next_context_iter = null_context_list_iterator;
case token_type_eof:
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
case token_type_ltemplate:
/* Eat tokens until eof is seen. When extract_balanced returns
due to an unbalanced closing parenthesis, just restart it. */
while (!extract_balanced (mlp, token_type_eof,
- null_context, null_context_list_iterator,
+ null_context_region (), null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
;
/* Read the next object. */
static void
-read_object (struct object *op, flag_context_ty outer_context)
+read_object (struct object *op, flag_region_ty *outer_region)
{
if (nesting_depth > MAX_NESTING_DEPTH)
if_error (IF_SEVERITY_FATAL_ERROR,
for (;; arg++)
{
struct object inner;
- flag_context_ty inner_context;
+ flag_region_ty *inner_region;
if (arg == 0)
- inner_context = null_context;
+ inner_region = null_context_region ();
else
- inner_context =
- inherited_context (outer_context,
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
++nesting_depth;
- read_object (&inner, inner_context);
+ read_object (&inner, inner_region);
nesting_depth--;
/* Recognize end of list. */
last_non_comment_line = line_number;
if (argparser != NULL)
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return;
}
inner.line_number_at_start);
free (s);
arglist_parser_remember (argparser, arg, ms,
- inner_context,
+ inner_region,
logical_file_name,
inner.line_number_at_start,
savable_comment, false);
}
}
+ unref_region (inner_region);
free_object (&inner);
}
struct object inner;
++nesting_depth;
- read_object (&inner, null_context);
+ read_object (&inner, null_context_region ());
nesting_depth--;
/* Recognize end of vector. */
struct object inner;
++nesting_depth;
- read_object (&inner, null_context);
+ read_object (&inner, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here. But be tolerant. */
pos.file_name = logical_file_name;
pos.line_number = op->line_number_at_start;
remember_a_message (mlp, NULL, string_of_object (op), false,
- false, null_context, &pos,
+ false, null_context_region (), &pos,
NULL, savable_comment, false);
}
last_non_comment_line = line_number;
{
struct object inner;
++nesting_depth;
- read_object (&inner, null_context);
+ read_object (&inner, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here.
But be tolerant. */
struct object inner;
do_ungetc (dmc);
++nesting_depth;
- read_object (&inner, null_context);
+ read_object (&inner, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here.
But be tolerant. */
{
struct object toplevel_object;
- read_object (&toplevel_object, null_context);
+ read_object (&toplevel_object, null_context_region ());
if (toplevel_object.type == t_eof)
break;
/* Read the next object. */
static void
-read_object (struct object *op, flag_context_ty outer_context)
+read_object (struct object *op, flag_region_ty *outer_region)
{
if (nesting_depth > MAX_NESTING_DEPTH)
if_error (IF_SEVERITY_FATAL_ERROR,
for (;; arg++)
{
struct object inner;
- flag_context_ty inner_context;
+ flag_region_ty *inner_region;
if (arg == 0)
- inner_context = null_context;
+ inner_region = null_context_region ();
else
- inner_context =
- inherited_context (outer_context,
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
++nesting_depth;
- read_object (&inner, inner_context);
+ read_object (&inner, inner_region);
nesting_depth--;
/* Recognize end of list. */
last_non_comment_line = line_number;
if (argparser != NULL)
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return;
}
inner.line_number_at_start);
free (s);
arglist_parser_remember (argparser, arg, ms,
- inner_context,
+ inner_region,
logical_file_name,
inner.line_number_at_start,
savable_comment, false);
}
}
+ unref_region (inner_region);
free_object (&inner);
}
struct object inner;
++nesting_depth;
- read_object (&inner, null_context);
+ read_object (&inner, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here. But be tolerant. */
pos.file_name = logical_file_name;
pos.line_number = op->line_number_at_start;
remember_a_message (mlp, NULL, string_of_object (op), false,
- false, null_context, &pos,
+ false, null_context_region (), &pos,
NULL, savable_comment, false);
}
last_non_comment_line = line_number;
{
struct object inner;
++nesting_depth;
- read_object (&inner, null_context);
+ read_object (&inner, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here.
But be tolerant. */
{
struct object inner;
++nesting_depth;
- read_object (&inner, null_context);
+ read_object (&inner, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here.
But be tolerant. */
{
struct object toplevel_object;
- read_object (&toplevel_object, null_context);
+ read_object (&toplevel_object, null_context_region ());
if (toplevel_object.type == t_eof)
break;
Return true upon eof, false upon closing parenthesis or bracket. */
static bool
extract_balanced (message_list_ty *mlp, token_type_ty delim,
- flag_context_ty outer_context,
+ flag_region_ty *outer_region,
flag_context_list_iterator_ty context_iter,
struct arglist_parser *argparser)
{
/* Context iterator that will be used if the next token is a '('. */
flag_context_list_iterator_ty next_context_iter =
passthrough_context_list_iterator;
- /* Current context. */
- flag_context_ty inner_context =
- inherited_context (outer_context,
+ /* Current region. */
+ flag_region_ty *inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (&context_iter));
/* Start state is 0. */
logical_file_name, line_number, (size_t)(-1), false,
_("too many open parentheses"));
if (extract_balanced (mlp, token_type_rparen,
- inner_context, next_context_iter,
+ inner_region, next_context_iter,
arglist_parser_alloc (mlp,
state ? next_shapes : NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
paren_nesting_depth--;
if (delim == token_type_rparen || delim == token_type_eof)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
logical_file_name, line_number, (size_t)(-1), false,
_("too many open brackets"));
if (extract_balanced (mlp, token_type_rbracket,
- null_context, null_context_list_iterator,
+ null_context_region (),
+ null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
bracket_nesting_depth--;
if (delim == token_type_rbracket || delim == token_type_eof)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
case token_type_comma:
arg++;
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
next_context_iter = passthrough_context_list_iterator;
case token_type_eof:
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
case token_type_string:
if (extract_all)
remember_a_message (mlp, NULL, token.string, false, false,
- inner_context, &pos,
+ inner_region, &pos,
NULL, token.comment, false);
else
{
tmp_argparser = arglist_parser_alloc (mlp, next_shapes);
arglist_parser_remember (tmp_argparser, 1, ms,
- inner_context,
+ inner_region,
pos.file_name, pos.line_number,
token.comment, false);
arglist_parser_done (tmp_argparser, 1);
}
else
arglist_parser_remember (argparser, arg, ms,
- inner_context,
+ inner_region,
pos.file_name, pos.line_number,
token.comment, false);
}
/* Eat tokens until eof is seen. When extract_parenthesized returns
due to an unbalanced closing parenthesis, just restart it. */
while (!extract_balanced (mlp, token_type_eof,
- null_context, null_context_list_iterator,
+ null_context_region (), null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
;
token_type_ty delim, bool eat_delim,
bool semicolon_delim, bool eat_semicolon_delim,
bool comma_delim,
- flag_context_ty outer_context,
+ flag_region_ty *outer_region,
flag_context_list_iterator_ty context_iter,
int arg, struct arglist_parser *argparser);
if (extract_balanced (mlp,
token_type_rbrace, true,
false, false, false,
- null_context, null_context_list_iterator,
+ null_context_region (), null_context_list_iterator,
1, arglist_parser_alloc (mlp, NULL)))
{
tp->type = token_type_eof;
token_ty *t2 = x_perl_lex (mlp);
if (t2->type == token_type_rbrace)
{
- flag_context_ty context;
+ flag_region_ty *region;
lex_pos_ty pos;
- context =
- inherited_context (null_context,
+ region =
+ inheriting_region (null_context_region (),
flag_context_list_iterator_advance (
&context_iter));
pos.file_name = logical_file_name;
remember_a_message (mlp, NULL, xstrdup (t1->string),
- true, false, context, &pos,
+ true, false, region, &pos,
NULL, savable_comment, true);
free_token (t2);
free_token (t1);
if (extract_balanced (mlp,
token_type_rbrace, true,
false, false, false,
- null_context, context_iter,
+ null_context_region (), context_iter,
1, arglist_parser_alloc (mlp, &shapes)))
return;
}
extract_balanced (mlp,
token_type_rbrace, true,
false, false, false,
- null_context, null_context_list_iterator,
+ null_context_region (), null_context_list_iterator,
1, arglist_parser_alloc (mlp, NULL));
break;
extract_balanced (mlp,
token_type_rbracket, true,
false, false, false,
- null_context, null_context_list_iterator,
+ null_context_region (), null_context_list_iterator,
1, arglist_parser_alloc (mlp, NULL));
break;
static char *buffer;
static int bufmax = 0;
int bufpos = 0;
- flag_context_ty context;
+ flag_region_ty *region;
size_t length;
size_t index;
char c;
* barekey: an bareword character has been seen in state WAIT_QUOTE
* wait_rbrace: closing quote has been seen in state DQUOTE or SQUOTE
*
- * In the states initial...identifier the context is null_context; in the
- * states minus...wait_rbrace the context is the one suitable for the first
- * argument of the last seen identifier.
+ * In the states initial...identifier the context is null_context_region ();
+ * in the states minus...wait_rbrace the context is the one suitable for the
+ * first argument of the last seen identifier.
*/
state = initial;
- context = null_context;
+ region = null_context_region ();
length = string_desc_length (string);
index = 0;
flag_context_list_table_lookup (
flag_context_list_table,
buffer, bufpos));
- context =
- inherited_context (null_context,
+ region =
+ inheriting_region (null_context_region (),
flag_context_list_iterator_advance (
&context_iter));
state = minus;
flag_context_list_table_lookup (
flag_context_list_table,
buffer, bufpos));
- context =
- inherited_context (null_context,
+ region =
+ inheriting_region (null_context_region (),
flag_context_list_iterator_advance (
&context_iter));
state = wait_quote;
state = wait_lbrace;
break;
default:
- context = null_context;
+ region = null_context_region ();
state = initial;
break;
}
state = wait_quote;
break;
default:
- context = null_context;
+ region = null_context_region ();
state = initial;
break;
}
}
else
{
- context = null_context;
+ region = null_context_region ();
state = initial;
}
break;
case '\\':
if (index == length)
{
- context = null_context;
+ region = null_context_region ();
state = initial;
}
else
case '\\':
if (index == length)
{
- context = null_context;
+ region = null_context_region ();
state = initial;
}
else
}
else if (c != '}')
{
- context = null_context;
+ region = null_context_region ();
state = initial;
break;
}
buffer[bufpos] = '\0';
token.string = xstrdup (buffer);
extract_quotelike_pass3 (&token, IF_SEVERITY_FATAL_ERROR);
- remember_a_message (mlp, NULL, token.string, true, false, context,
+ remember_a_message (mlp, NULL, token.string, true, false, region,
&pos, NULL, savable_comment, true);
FALLTHROUGH;
default:
- context = null_context;
+ region = null_context_region ();
state = initial;
break;
}
token_type_ty delim, bool eat_delim,
bool semicolon_delim, bool eat_semicolon_delim,
bool comma_delim,
- flag_context_ty outer_context,
+ flag_region_ty *outer_region,
flag_context_list_iterator_ty context_iter,
int arg, struct arglist_parser *argparser)
{
/* Context iterator that will be used if the next token is a '('. */
flag_context_list_iterator_ty next_context_iter =
passthrough_context_list_iterator;
- /* Current context. */
- flag_context_ty inner_context =
- inherited_context (outer_context,
+ /* Current region. */
+ flag_region_ty *inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (&context_iter));
#if DEBUG_PERL
|| tp->type == token_type_rbracket)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
if (next_argparser != NULL)
free (next_argparser);
#if DEBUG_PERL
if (semicolon_delim && tp->type == token_type_semicolon)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
if (next_argparser != NULL)
free (next_argparser);
#if DEBUG_PERL
if (comma_delim && tp->type == token_type_comma)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
if (next_argparser != NULL)
free (next_argparser);
#if DEBUG_PERL
if (extract_balanced (mlp,
delim, false,
true, false, next_comma_delim,
- inner_context, next_context_iter,
+ inner_region, next_context_iter,
1, next_argparser))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
#if DEBUG_NESTING_DEPTH
if (extract_balanced (mlp,
token_type_rparen, true,
false, false, false,
- inner_context, next_context_iter,
+ inner_region, next_context_iter,
1, next_argparser))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
#if DEBUG_NESTING_DEPTH
if (extract_balanced (mlp,
token_type_rparen, true,
false, false, false,
- inner_context, next_context_iter,
+ inner_region, next_context_iter,
arg, arglist_parser_clone (argparser)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
if (next_argparser != NULL)
free (next_argparser);
free_token (tp);
fprintf (stderr, "%s:%d: arg: %d\n",
real_file_name, tp->line_number, arg);
#endif
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
next_is_argument = false;
pos.file_name = logical_file_name;
pos.line_number = tp->line_number;
- remember_a_message (mlp, NULL, string, true, false, inner_context,
+ remember_a_message (mlp, NULL, string, true, false, inner_region,
&pos, NULL, tp->comment, true);
}
else if (!skip_until_comma)
mixed_string_alloc_utf8 (string, lc_string,
logical_file_name, tp->line_number);
free (string);
- arglist_parser_remember (argparser, arg, ms, inner_context,
+ arglist_parser_remember (argparser, arg, ms, inner_region,
logical_file_name, tp->line_number,
tp->comment, true);
}
logical_file_name, tp->line_number, nesting_level);
#endif
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
if (next_argparser != NULL)
free (next_argparser);
next_argparser = NULL;
if (extract_balanced (mlp,
token_type_rbrace, true,
false, false, false,
- null_context, null_context_list_iterator,
+ null_context_region (),
+ null_context_list_iterator,
1, arglist_parser_alloc (mlp, NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
if (next_argparser != NULL)
free (next_argparser);
free_token (tp);
/* Go back to the caller. We don't want to recurse each time we
parsed a sub name... { ... } definition. */
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
free_token (tp);
return false;
}
if (extract_balanced (mlp,
token_type_rbracket, true,
false, false, false,
- null_context, null_context_list_iterator,
+ null_context_region (),
+ null_context_list_iterator,
1, arglist_parser_alloc (mlp, NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
if (next_argparser != NULL)
free (next_argparser);
free_token (tp);
/* FIXME: Instead of resetting outer_context here, it may be better
to recurse in the next_is_argument handling above, waiting for
the next semicolon or other statement terminator. */
- outer_context = null_context;
+ outer_region = null_context_region ();
context_iter = null_context_list_iterator;
next_is_argument = false;
if (next_argparser != NULL)
free (next_argparser);
next_argparser = NULL;
next_context_iter = passthrough_context_list_iterator;
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
break;
while (!extract_balanced (mlp,
token_type_r_any, true,
true, true, false,
- null_context, null_context_list_iterator,
+ null_context_region (), null_context_list_iterator,
1, arglist_parser_alloc (mlp, NULL)))
;
static bool
extract_balanced (message_list_ty *mlp,
token_type_ty delim,
- flag_context_ty outer_context,
+ flag_region_ty *outer_region,
flag_context_list_iterator_ty context_iter,
struct arglist_parser *argparser)
{
/* Context iterator that will be used if the next token is a '('. */
flag_context_list_iterator_ty next_context_iter =
passthrough_context_list_iterator;
- /* Current context. */
- flag_context_ty inner_context =
- inherited_context (outer_context,
+ /* Current region. */
+ flag_region_ty *inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (&context_iter));
/* Start state is 0. */
logical_file_name, line_number, (size_t)(-1), false,
_("too many open parentheses"));
if (extract_balanced (mlp, token_type_rparen,
- inner_context, next_context_iter,
+ inner_region, next_context_iter,
arglist_parser_alloc (mlp,
state ? next_shapes : NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
paren_nesting_depth--;
if (delim == token_type_rparen || delim == token_type_eof)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
next_context_iter = null_context_list_iterator;
case token_type_comma:
arg++;
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
next_context_iter = passthrough_context_list_iterator;
logical_file_name, line_number, (size_t)(-1), false,
_("too many open brackets"));
if (extract_balanced (mlp, token_type_rbracket,
- null_context, null_context_list_iterator,
+ null_context_region (),
+ null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
bracket_nesting_depth--;
if (delim == token_type_rbracket || delim == token_type_eof)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
next_context_iter = null_context_list_iterator;
if (extract_all)
remember_a_message (mlp, NULL, token.string, false, false,
- inner_context, &pos,
+ inner_region, &pos,
NULL, token.comment, false);
else
{
mixed_string_alloc_simple (token.string, lc_string,
pos.file_name, pos.line_number);
free (token.string);
- arglist_parser_remember (argparser, arg, ms, inner_context,
+ arglist_parser_remember (argparser, arg, ms, inner_region,
pos.file_name, pos.line_number,
token.comment, false);
}
case token_type_eof:
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
default:
/* Eat tokens until eof is seen. When extract_balanced returns
due to an unbalanced closing parenthesis, just restart it. */
while (!extract_balanced (mlp, token_type_eof,
- null_context, null_context_list_iterator,
+ null_context_region (), null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
;
static bool
extract_balanced (message_list_ty *mlp,
token_type_ty delim,
- flag_context_ty outer_context,
+ flag_region_ty *outer_region,
flag_context_list_iterator_ty context_iter,
struct arglist_parser *argparser)
{
/* Context iterator that will be used if the next token is a '('. */
flag_context_list_iterator_ty next_context_iter =
passthrough_context_list_iterator;
- /* Current context. */
- flag_context_ty inner_context =
- inherited_context (outer_context,
+ /* Current region. */
+ flag_region_ty *inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (&context_iter));
/* Start state is 0. */
logical_file_name, line_number, (size_t)(-1), false,
_("too many open parentheses"));
if (extract_balanced (mlp, token_type_rparen,
- inner_context, next_context_iter,
+ inner_region, next_context_iter,
arglist_parser_alloc (mlp,
state ? next_shapes : NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
paren_nesting_depth--;
if (delim == token_type_rparen || delim == token_type_eof)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
next_context_iter = null_context_list_iterator;
case token_type_comma:
arg++;
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
next_context_iter = passthrough_context_list_iterator;
logical_file_name, line_number, (size_t)(-1), false,
_("too many open brackets"));
if (extract_balanced (mlp, token_type_rbracket,
- null_context, null_context_list_iterator,
+ null_context_region (),
+ null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
bracket_nesting_depth--;
if (delim == token_type_rbracket || delim == token_type_eof)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
next_context_iter = null_context_list_iterator;
char *string = mixed_string_contents (token.mixed_string);
mixed_string_free (token.mixed_string);
remember_a_message (mlp, NULL, string, true, false,
- inner_context, &pos,
+ inner_region, &pos,
NULL, token.comment, true);
}
else
arglist_parser_remember (argparser, arg, token.mixed_string,
- inner_context,
+ inner_region,
pos.file_name, pos.line_number,
token.comment, true);
}
case token_type_eof:
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
case token_type_plus:
/* Eat tokens until eof is seen. When extract_balanced returns
due to an unbalanced closing parenthesis, just restart it. */
while (!extract_balanced (mlp, token_type_eof,
- null_context, null_context_list_iterator,
+ null_context_region (), null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
;
pos.file_name = location;
pos.line_number = (size_t)(-1);
- remember_a_message (mlp, NULL, msgid, false, false, null_context, &pos,
+ remember_a_message (mlp, NULL, msgid, false, false,
+ null_context_region (), &pos,
NULL, NULL, false);
/* Here c is the last read character: EOF or '\n'. */
pos.line_number = (size_t)(-1);
remember_a_message (mlp, NULL, msgid, true, false,
- null_context, &pos,
+ null_context_region (), &pos,
NULL, NULL, false);
/* Parse a comma. */
/* Read the next object. */
static void
-read_object (struct object *op, flag_context_ty outer_context)
+read_object (struct object *op, flag_region_ty *outer_region)
{
if (nesting_depth > MAX_NESTING_DEPTH)
if_error (IF_SEVERITY_FATAL_ERROR,
const struct callshapes *shapes = NULL;
struct arglist_parser *argparser = NULL;
- for (;; arg++)
- {
+ for (;; arg++)
+ {
struct object inner;
- flag_context_ty inner_context;
+ flag_region_ty *inner_region;
if (arg == 0)
- inner_context = null_context;
+ inner_region = null_context_region ();
else
- inner_context =
- inherited_context (outer_context,
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
++nesting_depth;
- read_object (&inner, inner_context);
+ read_object (&inner, inner_region);
nesting_depth--;
/* Recognize end of list. */
last_non_comment_line = line_number;
if (argparser != NULL)
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return;
}
inner.line_number_at_start);
free (s);
arglist_parser_remember (argparser, arg, ms,
- inner_context,
+ inner_region,
logical_file_name,
inner.line_number_at_start,
savable_comment, false);
}
}
+ unref_region (inner_region);
free_object (&inner);
}
if (argparser != NULL)
struct object inner;
++nesting_depth;
- read_object (&inner, null_context);
+ read_object (&inner, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here. But be tolerant. */
{
struct object inner;
++nesting_depth;
- read_object (&inner, null_context);
+ read_object (&inner, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here.
But be tolerant. */
*/
struct object inner;
++nesting_depth;
- read_object (&inner, null_context);
+ read_object (&inner, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here.
But be tolerant. */
*/
struct object inner;
++nesting_depth;
- read_object (&inner, null_context);
+ read_object (&inner, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here.
But be tolerant. */
{
struct object inner;
++nesting_depth;
- read_object (&inner, null_context);
+ read_object (&inner, null_context_region ());
nesting_depth--;
/* Dots and EOF are not allowed here.
But be tolerant. */
pos.file_name = logical_file_name;
pos.line_number = op->line_number_at_start;
remember_a_message (mlp, NULL, string_of_object (op), false,
- false, null_context, &pos,
+ false, null_context_region (), &pos,
NULL, savable_comment, false);
}
last_non_comment_line = line_number;
{
struct object toplevel_object;
- read_object (&toplevel_object, null_context);
+ read_object (&toplevel_object, null_context_region ());
if (toplevel_object.type == t_eof)
break;
/* Forward declaration of local functions. */
static enum word_type read_command_list (int looking_for,
- flag_context_ty outer_context);
+ flag_region_ty *outer_region);
'looking_for' denotes a parse terminator, either CLOSING_BACKQUOTE, ')'
or '\0'. */
static void
-read_word (struct word *wp, int looking_for, flag_context_ty context)
+read_word (struct word *wp, int looking_for, flag_region_ty *region)
{
int c;
bool all_unquoted_digits;
/* Command substitution (Bash syntax). */
phase2_ungetc (c3);
++nesting_depth;
- read_command_list (')', context);
+ read_command_list (')', region);
nesting_depth--;
}
string.chars[string.charcount++] = (unsigned char) c;
}
remember_a_message (mlp, NULL, string_of_token (&string),
- false, false, context, &pos,
+ false, false, region, &pos,
NULL, savable_comment, false);
free_token (&string);
saw_opening_backquote ();
++nesting_depth;
- read_command_list (CLOSING_BACKQUOTE, context);
+ read_command_list (CLOSING_BACKQUOTE, region);
nesting_depth--;
wp->type = t_other;
{
/* Process substitution (Bash syntax). */
++nesting_depth;
- read_command_list (')', context);
+ read_command_list (')', region);
nesting_depth--;
wp->type = t_other;
or '\0'.
Returns the type of the word that terminated the command. */
static enum word_type
-read_command (int looking_for, flag_context_ty outer_context)
+read_command (int looking_for, flag_region_ty *outer_region)
{
/* Read the words that make up the command.
Here we completely ignore field splitting at whitespace and wildcard
for (;;)
{
struct word inner;
- flag_context_ty inner_context;
+ flag_region_ty *inner_region;
if (arg == 0)
- inner_context = null_context;
+ inner_region = null_context_region ();
else
- inner_context =
- inherited_context (outer_context,
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
- read_word (&inner, looking_for, inner_context);
+ read_word (&inner, looking_for, inner_region);
/* Recognize end of command. */
if (inner.type == t_separator
{
if (argparser != NULL)
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return inner.type;
}
pos.file_name = logical_file_name;
pos.line_number = inner.line_number_at_start;
remember_a_message (mlp, NULL, string_of_word (&inner), false,
- false, inner_context, &pos,
+ false, inner_region, &pos,
NULL, savable_comment, false);
}
}
free (s);
argparser->next_is_msgctxt = false;
arglist_parser_remember_msgctxt (argparser, ms,
- inner_context,
+ inner_region,
logical_file_name,
inner.line_number_at_start);
matters_for_argparser = false;
free (s);
argparser->next_is_msgctxt = false;
arglist_parser_remember_msgctxt (argparser, ms,
- inner_context,
+ inner_region,
logical_file_name,
inner.line_number_at_start);
matters_for_argparser = false;
inner.line_number_at_start);
free (s);
arglist_parser_remember (argparser, arg, ms,
- inner_context,
+ inner_region,
logical_file_name,
inner.line_number_at_start,
savable_comment, false);
arg++;
}
+ unref_region (inner_region);
free_word (&inner);
}
}
or '\0'.
Returns the type of the word that terminated the command list. */
static enum word_type
-read_command_list (int looking_for, flag_context_ty outer_context)
+read_command_list (int looking_for, flag_region_ty *outer_region)
{
if (nesting_depth > MAX_NESTING_DEPTH)
if_error (IF_SEVERITY_FATAL_ERROR,
{
enum word_type terminator;
- terminator = read_command (looking_for, outer_context);
+ terminator = read_command (looking_for, outer_region);
if (terminator != t_separator)
return terminator;
}
init_keywords ();
/* Eat tokens until eof is seen. */
- read_command_list ('\0', null_context);
+ read_command_list ('\0', null_context_region ());
fp = NULL;
real_file_name = NULL;
pos.file_name = logical_file_name;
pos.line_number = token.line_number;
remember_a_message (mlp, NULL, token.string, false, false,
- null_context, &pos, NULL, savable_comment,
- false);
+ null_context_region (), &pos,
+ NULL, savable_comment, false);
state = 0;
break;
}
remember_a_message (mlp, NULL, token.string, false,
token2.type == token_type_symbol
&& strcmp (token.string, "plural:") == 0,
- null_context, &pos,
+ null_context_region (), &pos,
NULL, savable_comment, false);
phase3_unget (&token2);
pos.line_number = token.line_number;
if (plural_mp != NULL)
remember_a_message_plural (plural_mp, token.string, false,
- null_context, &pos,
+ null_context_region (), &pos,
savable_comment, false);
state = 0;
break;
/* Forward declaration of local functions. */
static enum word_type read_command_list (int looking_for,
- flag_context_ty outer_context);
+ flag_region_ty *outer_region);
/* Accumulate tokens into the given word.
'looking_for' denotes a parse terminator combination.
Return the first character past the token. */
static int
accumulate_word (struct word *wp, enum terminator looking_for,
- flag_context_ty context)
+ flag_region_ty *region)
{
int c;
struct word index_word;
index_word.type = t_other;
- c = accumulate_word (&index_word, te_paren, null_context);
+ c = accumulate_word (&index_word, te_paren,
+ null_context_region ());
if (c != EOF && c != ')')
phase2_ungetc (c);
wp->type = t_other;
if_error (IF_SEVERITY_FATAL_ERROR,
logical_file_name, line_number, (size_t)(-1), false,
_("too many open brackets"));
- read_command_list (']', context);
+ read_command_list (']', region);
bracket_nesting_depth--;
wp->type = t_other;
}
/* Read the next word.
'looking_for' denotes a parse terminator, either ']' or '\0'. */
static void
-read_word (struct word *wp, int looking_for, flag_context_ty context)
+read_word (struct word *wp, int looking_for, flag_region_ty *region)
{
int c;
if_error (IF_SEVERITY_FATAL_ERROR,
logical_file_name, line_number, (size_t)(-1), false,
_("too many open braces"));
- terminator = read_command_list ('\0', null_context);
+ terminator = read_command_list ('\0', null_context_region ());
brace_nesting_depth--;
if (terminator == t_brace)
if (c == '"')
{
- c = accumulate_word (wp, te_quote, context);
+ c = accumulate_word (wp, te_quote, region);
if (c != EOF && c != '"')
phase2_ungetc (c);
}
looking_for == ']'
? te_space_separator_bracket
: te_space_separator,
- context);
+ region);
if (c != EOF)
phase2_ungetc (c);
}
Returns the type of the word that terminated the command: t_separator or
t_bracket (only if looking_for is ']') or t_brace or t_eof. */
static enum word_type
-read_command (int looking_for, flag_context_ty outer_context)
+read_command (int looking_for, flag_region_ty *outer_region)
{
int c;
for (;; arg++)
{
struct word inner;
- flag_context_ty inner_context;
+ flag_region_ty *inner_region;
if (arg == 0)
- inner_context = null_context;
+ inner_region = null_context_region ();
else
- inner_context =
- inherited_context (outer_context,
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
- read_word (&inner, looking_for, inner_context);
+ read_word (&inner, looking_for, inner_region);
/* Recognize end of command. */
if (inner.type == t_separator || inner.type == t_bracket
{
if (argparser != NULL)
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return inner.type;
}
pos.file_name = logical_file_name;
pos.line_number = inner.line_number_at_start;
remember_a_message (mlp, NULL, string_of_word (&inner), false,
- false, inner_context, &pos,
+ false, inner_region, &pos,
NULL, savable_comment, false);
}
}
inner.line_number_at_start);
free (s);
arglist_parser_remember (argparser, arg, ms,
- inner_context,
+ inner_region,
logical_file_name,
inner.line_number_at_start,
savable_comment, false);
}
}
+ unref_region (inner_region);
free_word (&inner);
}
}
Returns the type of the word that terminated the command list:
t_bracket (only if looking_for is ']') or t_brace or t_eof. */
static enum word_type
-read_command_list (int looking_for, flag_context_ty outer_context)
+read_command_list (int looking_for, flag_region_ty *outer_region)
{
for (;;)
{
enum word_type terminator;
- terminator = read_command (looking_for, outer_context);
+ terminator = read_command (looking_for, outer_region);
if (terminator != t_separator)
return terminator;
}
init_keywords ();
/* Eat tokens until eof is seen. */
- read_command_list ('\0', null_context);
+ read_command_list ('\0', null_context_region ());
fp = NULL;
real_file_name = NULL;
Return true upon eof, false upon closing parenthesis or bracket. */
static bool
extract_balanced (message_list_ty *mlp, token_type_ty delim,
- flag_context_ty outer_context,
+ flag_region_ty *outer_region,
flag_context_list_iterator_ty context_iter,
struct arglist_parser *argparser)
{
/* Context iterator that will be used if the next token is a '('. */
flag_context_list_iterator_ty next_context_iter =
passthrough_context_list_iterator;
- /* Current context. */
- flag_context_ty inner_context =
- inherited_context (outer_context,
+ /* Current region. */
+ flag_region_ty *inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (&context_iter));
/* Start state is 0. */
logical_file_name, line_number, (size_t)(-1), false,
_("too many open parentheses"));
if (extract_balanced (mlp, token_type_rparen,
- inner_context, next_context_iter,
+ inner_region, next_context_iter,
arglist_parser_alloc (mlp,
state ? next_shapes : NULL)))
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
}
nesting_depth--;
if (delim == token_type_rparen || delim == token_type_eof)
{
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return false;
}
case token_type_comma:
arg++;
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
next_context_iter = passthrough_context_list_iterator;
case token_type_eof:
arglist_parser_done (argparser, arg);
+ unref_region (inner_region);
return true;
case token_type_string_literal:
char *string = mixed_string_contents (token.mixed_string);
mixed_string_free (token.mixed_string);
remember_a_message (mlp, NULL, string, true, false,
- inner_context, &pos,
+ inner_region, &pos,
NULL, token.comment, false);
}
else
tmp_argparser = arglist_parser_alloc (mlp, next_shapes);
arglist_parser_remember (tmp_argparser, 1,
- token.mixed_string, inner_context,
+ token.mixed_string, inner_region,
pos.file_name, pos.line_number,
token.comment, false);
arglist_parser_done (tmp_argparser, 1);
}
else
arglist_parser_remember (argparser, arg,
- token.mixed_string, inner_context,
+ token.mixed_string, inner_region,
pos.file_name, pos.line_number,
token.comment, false);
}
/* Eat tokens until eof is seen. When extract_parenthesized returns
due to an unbalanced closing parenthesis, just restart it. */
while (!extract_balanced (mlp, token_type_eof,
- null_context, null_context_list_iterator,
+ null_context_region (), null_context_list_iterator,
arglist_parser_alloc (mlp, NULL)))
;
Return true upon eof, false upon closing parenthesis. */
static bool
extract_parenthesized (message_list_ty *mlp,
- flag_context_ty outer_context,
+ flag_region_ty *outer_region,
flag_context_list_iterator_ty context_iter,
bool in_i18n)
{
/* Context iterator that will be used if the next token is a '('. */
flag_context_list_iterator_ty next_context_iter =
passthrough_context_list_iterator;
- /* Current context. */
- flag_context_ty inner_context =
- inherited_context (outer_context,
+ /* Current region. */
+ flag_region_ty *inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (&context_iter));
/* Start state is 0 or 1. */
if_error (IF_SEVERITY_FATAL_ERROR,
logical_file_name, line_number, (size_t)(-1), false,
_("too many open parentheses"));
- if (extract_parenthesized (mlp, inner_context, next_context_iter,
+ if (extract_parenthesized (mlp, inner_region, next_context_iter,
true))
- return true;
+ {
+ unref_region (inner_region);
+ return true;
+ }
nesting_depth--;
next_context_iter = null_context_list_iterator;
state = 0;
plural_mp =
remember_a_message (mlp, NULL, token.string, false,
token2.type == token_type_comma,
- inner_context, &pos,
+ inner_region, &pos,
NULL, token.comment, false);
if (in_i18n)
/* Seen an msgid_plural. */
if (plural_mp != NULL)
remember_a_message_plural (plural_mp, token.string, false,
- inner_context, &pos,
+ inner_region, &pos,
token.comment, false);
state = 0;
}
if_error (IF_SEVERITY_FATAL_ERROR,
logical_file_name, line_number, (size_t)(-1), false,
_("too many open parentheses"));
- if (extract_parenthesized (mlp, inner_context, next_context_iter,
+ if (extract_parenthesized (mlp, inner_region, next_context_iter,
false))
- return true;
+ {
+ unref_region (inner_region);
+ return true;
+ }
nesting_depth--;
next_context_iter = null_context_list_iterator;
state = 0;
continue;
case token_type_rparen:
+ unref_region (inner_region);
return false;
case token_type_comma:
state = 1;
else
state = 0;
- inner_context =
- inherited_context (outer_context,
+ unref_region (inner_region);
+ inner_region =
+ inheriting_region (outer_region,
flag_context_list_iterator_advance (
&context_iter));
next_context_iter = passthrough_context_list_iterator;
continue;
case token_type_eof:
+ unref_region (inner_region);
return true;
default:
/* Eat tokens until eof is seen. When extract_parenthesized returns
due to an unbalanced closing parenthesis, just restart it. */
- while (!extract_parenthesized (mlp, null_context, null_context_list_iterator,
- false))
+ while (!extract_parenthesized (mlp, null_context_region (),
+ null_context_list_iterator, false))
;
fp = NULL;
#include <stdlib.h>
+#include "attribute.h"
#include "xalloc.h"
#include "xmalloca.h"
#include "verify.h"
/* Null context. */
-flag_context_ty null_context =
+static flag_context_ty null_context =
{
{
{ undecided, false },
};
/* Transparent context. */
-flag_context_ty passthrough_context =
+MAYBE_UNUSED static flag_context_ty passthrough_context =
{
{
{ undecided, true },
};
-flag_context_ty
-inherited_context (flag_context_ty outer_context,
- flag_context_ty modifier_context)
-{
- flag_context_ty result = modifier_context;
-
- for (size_t fi = 0; fi < NXFORMATS; fi++)
- if (result.for_formatstring[fi].pass_format)
- {
- result.for_formatstring[fi].is_format = outer_context.for_formatstring[fi].is_format;
- result.for_formatstring[fi].pass_format = false;
- }
- return result;
-}
-
-
/* Null context list iterator. */
flag_context_list_iterator_ty null_context_list_iterator = { 1, NULL };
}
}
}
+
+
+/* We don't need to remember messages that were processed in the null context
+ region. Therefore the null context region can be a singleton. This
+ reduces the number of needed calls to unref_region. */
+static flag_region_ty const the_null_context_region =
+ {
+ 1,
+ {
+ { undecided },
+ { undecided },
+ { undecided },
+ { undecided }
+ }
+ };
+
+flag_region_ty *
+null_context_region ()
+{
+ return (flag_region_ty *) &the_null_context_region;
+}
+
+
+flag_region_ty *
+inheriting_region (flag_region_ty *outer_region,
+ flag_context_ty modifier_context)
+{
+ flag_region_ty *region = XMALLOC (flag_region_ty);
+
+ region->refcount = 1;
+ for (size_t fi = 0; fi < NXFORMATS; fi++)
+ {
+ if (modifier_context.for_formatstring[fi].pass_format)
+ region->for_formatstring[fi].is_format = outer_region->for_formatstring[fi].is_format;
+ else
+ region->for_formatstring[fi].is_format = modifier_context.for_formatstring[fi].is_format;
+ }
+
+ return region;
+}
+
+
+flag_region_ty *
+ref_region (flag_region_ty *region)
+{
+ if (region != NULL && region != &the_null_context_region)
+ region->refcount++;
+ return region;
+}
+
+
+void
+unref_region (flag_region_ty *region)
+{
+ if (region != NULL && region != &the_null_context_region)
+ {
+ if (region->refcount > 1)
+ region->refcount--;
+ else
+ free (region);
+ }
+}
{
struct formatstring_context_ty for_formatstring[NXFORMATS];
};
-/* Null context. */
-extern flag_context_ty null_context;
-/* Transparent context. */
-extern flag_context_ty passthrough_context;
-/* Compute an inherited context.
- The outer_context is assumed to have all pass_format flags = false.
- The result will then also have all pass_format flags = false. */
-extern flag_context_ty
- inherited_context (flag_context_ty outer_context,
- flag_context_ty modifier_context);
/* Context representing some flags, for each possible argument number.
This is a linked list, sorted according to the argument number. */
extern flag_context_ty
flag_context_list_iterator_advance (flag_context_list_iterator_ty *iter);
+
/* For nearly each backend, we have a separate table mapping a keyword to
a flag_context_list_ty *. */
typedef hash_table /* char[] -> flag_context_list_ty * */
int argnum, enum is_format value, bool pass);
+/* Context representing some flags w.r.t. a specific format string type,
+ as effective in a region of the input file. */
+struct formatstring_region_ty
+{
+ enum is_format is_format;
+};
+
+/* A region of the input file, in which a given context is in effect, together
+ with the messages that were remembered while processing this region. */
+typedef struct flag_region_ty flag_region_ty;
+struct flag_region_ty
+{
+ unsigned int refcount;
+ struct formatstring_region_ty for_formatstring[NXFORMATS];
+};
+
+/* Creates a region in which the null context is in effect. */
+extern flag_region_ty *
+ null_context_region ();
+
+/* Creates a sub-region that inherits from an outer region. */
+extern flag_region_ty *
+ inheriting_region (flag_region_ty *outer_region,
+ flag_context_ty modifier_context);
+
+/* Adds a reference to a region. Returns the region. */
+extern flag_region_ty *
+ ref_region (flag_region_ty *region);
+
+/* Drops a reference to a region.
+ When the last reference is dropped, the region is freed. */
+extern void
+ unref_region (flag_region_ty *region);
+
+/* Assigns the value of B to the variable A.
+ Both are of type 'flag_region_ty *'. B is *not* freshly created. */
+#define assign_region(a, b) \
+ do { \
+ flag_region_ty *_prev_a = (a); \
+ (a) = (b); \
+ ref_region (a); \
+ unref_region (_prev_a); \
+ } while (0)
+
+/* Assigns the value of B to the variable A.
+ Both are of type 'flag_region_ty *'. B is freshly created. */
+#define assign_new_region(a, b) \
+ do { \
+ flag_region_ty *_prev_a = (a); \
+ (a) = (b); \
+ unref_region (_prev_a); \
+ } while (0)
+
+
#ifdef __cplusplus
}
#endif
ap->alternative[i].msgctxt_pos.file_name = NULL;
ap->alternative[i].msgctxt_pos.line_number = (size_t)(-1);
ap->alternative[i].msgid = NULL;
- ap->alternative[i].msgid_context = null_context;
+ ap->alternative[i].msgid_region = null_context_region ();
ap->alternative[i].msgid_pos.file_name = NULL;
ap->alternative[i].msgid_pos.line_number = (size_t)(-1);
ap->alternative[i].msgid_comment = NULL;
ap->alternative[i].msgid_comment_is_utf8 = false;
ap->alternative[i].msgid_plural = NULL;
- ap->alternative[i].msgid_plural_context = null_context;
+ ap->alternative[i].msgid_plural_region = null_context_region ();
ap->alternative[i].msgid_plural_pos.file_name = NULL;
ap->alternative[i].msgid_plural_pos.line_number = (size_t)(-1);
}
(cp->msgctxt != NULL ? mixed_string_clone (cp->msgctxt) : NULL);
ccp->msgctxt_pos = cp->msgctxt_pos;
ccp->msgid = (cp->msgid != NULL ? mixed_string_clone (cp->msgid) : NULL);
- ccp->msgid_context = cp->msgid_context;
+ ccp->msgid_region = ref_region (cp->msgid_region);
ccp->msgid_pos = cp->msgid_pos;
ccp->msgid_comment = add_reference (cp->msgid_comment);
ccp->msgid_comment_is_utf8 = cp->msgid_comment_is_utf8;
ccp->msgid_plural =
(cp->msgid_plural != NULL ? mixed_string_clone (cp->msgid_plural) : NULL);
- ccp->msgid_plural_context = cp->msgid_plural_context;
+ ccp->msgid_plural_region = ref_region (cp->msgid_plural_region);
ccp->msgid_plural_pos = cp->msgid_plural_pos;
}
void
arglist_parser_remember (struct arglist_parser *ap,
int argnum, mixed_string_ty *string,
- flag_context_ty context,
+ flag_region_ty *region,
const char *file_name, size_t line_number,
refcounted_string_list_ty *comment,
bool comment_is_utf8)
if (argnum == cp->argnum1)
{
cp->msgid = string;
- cp->msgid_context = context;
+ cp->msgid_region = ref_region (region);
cp->msgid_pos.file_name = file_name;
cp->msgid_pos.line_number = line_number;
cp->msgid_comment = add_reference (comment);
if (argnum == cp->argnum2)
{
cp->msgid_plural = string;
- cp->msgid_plural_context = context;
+ cp->msgid_plural_region = ref_region (region);
cp->msgid_plural_pos.file_name = file_name;
cp->msgid_plural_pos.line_number = line_number;
stored_string = true;
void
arglist_parser_remember_msgctxt (struct arglist_parser *ap,
mixed_string_ty *string,
- flag_context_ty context,
+ flag_region_ty *region,
const char *file_name, size_t line_number)
{
bool stored_string = false;
{
/* best_cp indicates the best found complete call.
Now call remember_a_message. */
- flag_context_ty msgid_context;
- flag_context_ty msgid_plural_context;
+ flag_region_ty *msgid_region;
+ flag_region_ty *msgid_plural_region;
char *best_msgctxt;
char *best_msgid;
char *best_msgid_plural;
message_ty *mp;
- msgid_context = best_cp->msgid_context;
- msgid_plural_context = best_cp->msgid_plural_context;
+ msgid_region = best_cp->msgid_region;
+ msgid_plural_region = best_cp->msgid_plural_region;
/* Special support for the 3-argument tr operator in Qt:
When --qt and --keyword=tr:1,1,2c,3t are specified, add to the
if (recognize_qt_formatstrings ()
&& best_cp->msgid_plural == best_cp->msgid)
{
- msgid_context.for_formatstring[XFORMAT_FOURTH].is_format = yes_according_to_context;
- msgid_plural_context.for_formatstring[XFORMAT_FOURTH].is_format = yes_according_to_context;
+ msgid_region->for_formatstring[XFORMAT_FOURTH].is_format = yes_according_to_context;
+ msgid_plural_region->for_formatstring[XFORMAT_FOURTH].is_format = yes_according_to_context;
}
best_msgctxt =
mp = remember_a_message (ap->mlp, best_msgctxt, best_msgid, true,
best_msgid_plural != NULL,
- msgid_context,
+ msgid_region,
&best_cp->msgid_pos,
NULL, best_cp->msgid_comment,
best_cp->msgid_comment_is_utf8);
if (mp != NULL && best_msgid_plural != NULL)
remember_a_message_plural (mp, best_msgid_plural, true,
- msgid_plural_context,
+ msgid_plural_region,
&best_cp->msgid_plural_pos,
NULL, false);
}
for (i = 0; i < ap->nalternatives; i++)
- drop_reference (ap->alternative[i].msgid_comment);
+ {
+ drop_reference (ap->alternative[i].msgid_comment);
+ unref_region (ap->alternative[i].msgid_region);
+ unref_region (ap->alternative[i].msgid_plural_region);
+ }
free (ap);
}
mixed_string_ty *msgctxt; /* context - owned mixed_string, or NULL */
lex_pos_ty msgctxt_pos;
mixed_string_ty *msgid; /* msgid - owned mixed_string, or NULL */
- flag_context_ty msgid_context;
+ flag_region_ty *msgid_region;
lex_pos_ty msgid_pos;
refcounted_string_list_ty *msgid_comment;
bool msgid_comment_is_utf8;
mixed_string_ty *msgid_plural; /* msgid_plural - owned mixed_string, or NULL */
- flag_context_ty msgid_plural_context;
+ flag_region_ty *msgid_plural_region;
lex_pos_ty msgid_plural_pos;
};
*/
extern void arglist_parser_remember (struct arglist_parser *ap,
int argnum, mixed_string_ty *string,
- flag_context_ty context,
+ flag_region_ty *region,
const char *file_name, size_t line_number,
refcounted_string_list_ty *comment,
bool comment_is_utf8);
FILE_NAME must be allocated with indefinite extent. */
extern void arglist_parser_remember_msgctxt (struct arglist_parser *ap,
mixed_string_ty *string,
- flag_context_ty context,
+ flag_region_ty *region,
const char *file_name, size_t line_number);
/* Tests whether an arglist_parser has is not waiting for more arguments after
argument ARGNUM. */
/* Update the is_format[] flags depending on the information given in the
- context. */
+ region's context. */
static void
set_format_flags_from_context (enum is_format is_format[NFORMATS],
- flag_context_ty context, const char *string,
+ flag_region_ty const *region, const char *string,
lex_pos_ty *pos, const char *pretty_msgstr)
{
bool some_undecided;
some_undecided = false;
for (size_t fi = 0; fi < NXFORMATS; fi++)
- some_undecided |= (context.for_formatstring[fi].is_format != undecided);
+ some_undecided |= (region->for_formatstring[fi].is_format != undecided);
if (some_undecided)
for (size_t i = 0; i < NFORMATS; i++)
if (is_format[i] == undecided)
for (size_t fi = 0; fi < NXFORMATS; fi++)
if (formatstring_parsers[i] == current_formatstring_parser[fi]
- && context.for_formatstring[fi].is_format != undecided)
- is_format[i] = (enum is_format) context.for_formatstring[fi].is_format;
+ && region->for_formatstring[fi].is_format != undecided)
+ is_format[i] = region->for_formatstring[fi].is_format;
if (possible_format_p (is_format[i]))
{
struct formatstring_parser *parser = formatstring_parsers[i];
message_ty *
remember_a_message (message_list_ty *mlp, char *msgctxt, char *msgid,
- bool is_utf8, bool pluralp, flag_context_ty context,
+ bool is_utf8, bool pluralp, flag_region_ty *region,
lex_pos_ty *pos,
const char *extracted_comment,
refcounted_string_list_ty *comment, bool comment_is_utf8)
/* Determine whether the context specifies that the msgid is a format
string. */
- set_format_flags_from_context (mp->is_format, context, mp->msgid, pos, "msgid");
+ set_format_flags_from_context (mp->is_format, region, mp->msgid, pos, "msgid");
/* Ask the lexer for the comments it has seen. */
{
void
remember_a_message_plural (message_ty *mp, char *string, bool is_utf8,
- flag_context_ty context, lex_pos_ty *pos,
+ flag_region_ty *region, lex_pos_ty *pos,
refcounted_string_list_ty *comment,
bool comment_is_utf8)
{
/* Determine whether the context specifies that the msgid_plural is a
format string. */
- set_format_flags_from_context (mp->is_format, context, mp->msgid_plural,
+ set_format_flags_from_context (mp->is_format, region, mp->msgid_plural,
pos, "msgid_plural");
/* If it is not already decided, through programmer comments or
/* Extracting a message. Accumulating the message list.
- Copyright (C) 2001-2020 Free Software Foundation, Inc.
+ Copyright (C) 2001-2023 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
char *msgid,
bool is_utf8,
bool pluralp,
- flag_context_ty context,
+ flag_region_ty *region,
lex_pos_ty *pos,
const char *extracted_comment,
refcounted_string_list_ty *comment,
extern void remember_a_message_plural (message_ty *mp,
char *string,
bool is_utf8,
- flag_context_ty context,
+ flag_region_ty *region,
lex_pos_ty *pos,
refcounted_string_list_ty *comment,
bool comment_is_utf8);
msgctxt == NULL ? NULL : xstrdup (msgctxt),
xstrdup (msgid),
false, false,
- null_context, pos,
+ null_context_region (), pos,
extracted_comment, NULL, false);
if (add_itstool_comments)
projects / thirdparty / gettext.git / commitdiff
