#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "message.h"
#include "xgettext.h"
#include "x-tcl.h"
#include "error.h"
#include "xalloc.h"
#include "exit.h"
#include "hash.h"
#include "c-ctype.h"
#include "po-charset.h"
#include "ucs4-utf8.h"
#include "gettext.h"
#define _(s) gettext(s)
static bool extract_all = false;
static hash_table keywords;
static bool default_keywords = true;
void
x_tcl_extract_all ()
{
extract_all = true;
}
void
x_tcl_keyword (const char *name)
{
if (name == NULL)
default_keywords = false;
else
{
const char *end;
int argnum1;
int argnum2;
if (keywords.table == NULL)
init_hash (&keywords, 100);
split_keywordspec (name, &end, &argnum1, &argnum2);
if (end - name >= 2 && name[0] == ':' && name[1] == ':')
name += 2;
if (argnum1 == 0)
argnum1 = 1;
insert_entry (&keywords, name, end - name,
(void *) (long) (argnum1 + (argnum2 << 10)));
}
}
static void
init_keywords ()
{
if (default_keywords)
{
x_tcl_keyword ("::msgcat::mc");
default_keywords = false;
}
}
void
init_flag_table_tcl ()
{
xgettext_record_flag ("::msgcat::mc:1:pass-tcl-format");
xgettext_record_flag ("format:1:tcl-format");
}
static const char *real_file_name;
static char *logical_file_name;
static int line_number;
static FILE *fp;
static int
do_getc ()
{
int c = getc (fp);
if (c == EOF)
{
if (ferror (fp))
error (EXIT_FAILURE, errno, _("\
error while reading \"%s\""), real_file_name);
}
else if (c == '\n')
line_number++;
return c;
}
static void
do_ungetc (int c)
{
if (c == '\n')
line_number--;
ungetc (c, fp);
}
#define BS_NL (UCHAR_MAX + 1 + ' ')
static int phase1_pushback[4];
static int phase1_pushback_length;
static int
phase1_getc ()
{
int c;
if (phase1_pushback_length)
{
c = phase1_pushback[--phase1_pushback_length];
if (c == '\n' || c == BS_NL)
++line_number;
return c;
}
c = do_getc ();
if (c != '\\')
return c;
c = do_getc ();
if (c != '\n')
{
if (c != EOF)
do_ungetc (c);
return '\\';
}
for (;;)
{
c = do_getc ();
if (!(c == ' ' || c == '\t'))
break;
}
if (c != EOF)
do_ungetc (c);
return BS_NL;
}
static void
phase1_ungetc (int c)
{
switch (c)
{
case EOF:
break;
case '\n':
case BS_NL:
--line_number;
default:
phase1_pushback[phase1_pushback_length++] = c;
break;
}
}
#define CL_BRACE (UCHAR_MAX + 1 + '}')
static int phase2_pushback[4];
static int phase2_pushback_length;
static int brace_depth;
static int
phase2_push ()
{
int previous_depth = brace_depth;
brace_depth = 1;
return previous_depth;
}
static void
phase2_pop (int previous_depth)
{
brace_depth = previous_depth;
}
static int
phase2_getc ()
{
int c;
if (phase2_pushback_length)
{
c = phase2_pushback[--phase2_pushback_length];
if (c == '\n' || c == BS_NL)
++line_number;
else if (c == '{')
++brace_depth;
else if (c == '}')
--brace_depth;
return c;
}
c = phase1_getc ();
if (c == '{')
++brace_depth;
else if (c == '}')
{
if (--brace_depth == 0)
c = CL_BRACE;
}
return c;
}
static void
phase2_ungetc (int c)
{
if (c != EOF)
{
switch (c)
{
case '\n':
case BS_NL:
--line_number;
break;
case '{':
--brace_depth;
break;
case '}':
++brace_depth;
break;
}
phase2_pushback[phase2_pushback_length++] = c;
}
}
struct token
{
int allocated;
int charcount;
char *chars;
};
static inline void
init_token (struct token *tp)
{
tp->allocated = 10;
tp->chars = (char *) xmalloc (tp->allocated * sizeof (char));
tp->charcount = 0;
}
static inline void
free_token (struct token *tp)
{
free (tp->chars);
}
static inline void
grow_token (struct token *tp)
{
if (tp->charcount == tp->allocated)
{
tp->allocated *= 2;
tp->chars = (char *) xrealloc (tp->chars, tp->allocated * sizeof (char));
}
}
static char *buffer;
static size_t bufmax;
static size_t buflen;
static inline void
comment_start ()
{
buflen = 0;
}
static inline void
comment_add (int c)
{
if (buflen >= bufmax)
{
bufmax = 2 * bufmax + 10;
buffer = xrealloc (buffer, bufmax);
}
buffer[buflen++] = c;
}
static inline void
comment_line_end ()
{
while (buflen >= 1
&& (buffer[buflen - 1] == ' ' || buffer[buflen - 1] == '\t'))
--buflen;
if (buflen >= bufmax)
{
bufmax = 2 * bufmax + 10;
buffer = xrealloc (buffer, bufmax);
}
buffer[buflen] = '\0';
xgettext_comment_add (buffer);
}
static int last_comment_line;
static int last_non_comment_line;
static message_list_ty *mlp;
enum word_type
{
t_string,
t_other,
t_separator,
t_bracket,
t_brace,
t_eof
};
struct word
{
enum word_type type;
struct token *token;
int line_number_at_start;
};
static inline void
free_word (struct word *wp)
{
if (wp->type == t_string)
{
free_token (wp->token);
free (wp->token);
}
}
static char *
string_of_word (const struct word *wp)
{
char *str;
int n;
if (!(wp->type == t_string))
abort ();
n = wp->token->charcount;
str = (char *) xmalloc (n + 1);
memcpy (str, wp->token->chars, n);
str[n] = '\0';
return str;
}
static flag_context_list_table_ty *flag_context_list_table;
static int
do_getc_escaped ()
{
int c;
c = phase1_getc ();
switch (c)
{
case EOF:
return '\\';
case 'a':
return '\a';
case 'b':
return '\b';
case 'f':
return '\f';
case 'n':
return '\n';
case 'r':
return '\r';
case 't':
return '\t';
case 'v':
return '\v';
case 'x':
{
int n = 0;
unsigned int i;
for (i = 0;; i++)
{
c = phase1_getc ();
if (c == EOF || !c_isxdigit ((unsigned char) c))
break;
if (c >= '0' && c <= '9')
n = (n << 4) + (c - '0');
else if (c >= 'A' && c <= 'F')
n = (n << 4) + (c - 'A' + 10);
else if (c >= 'a' && c <= 'f')
n = (n << 4) + (c - 'a' + 10);
}
phase1_ungetc (c);
return (i > 0 ? (unsigned char) n : 'x');
}
case 'u':
{
int n = 0;
unsigned int i;
for (i = 0; i < 4; i++)
{
c = phase1_getc ();
if (c == EOF || !c_isxdigit ((unsigned char) c))
break;
if (c >= '0' && c <= '9')
n = (n << 4) + (c - '0');
else if (c >= 'A' && c <= 'F')
n = (n << 4) + (c - 'A' + 10);
else if (c >= 'a' && c <= 'f')
n = (n << 4) + (c - 'a' + 10);
}
phase1_ungetc (c);
return (i > 0 ? n : 'u');
}
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7':
{
int n = c - '0';
c = phase1_getc ();
if (c != EOF)
{
if (c >= '0' && c <= '7')
{
n = (n << 3) + (c - '0');
c = phase1_getc ();
if (c != EOF)
{
if (c >= '0' && c <= '7')
n = (n << 3) + (c - '0');
else
phase1_ungetc (c);
}
}
else
phase1_ungetc (c);
}
return (unsigned char) n;
}
default:
return (unsigned char) c;
}
}
enum terminator
{
te_space_separator,
te_space_separator_bracket,
te_paren,
te_quote
};
static enum word_type read_command_list (int looking_for,
flag_context_ty outer_context);
static int
accumulate_word (struct word *wp, enum terminator looking_for,
flag_context_ty context)
{
int c;
for (;;)
{
c = phase2_getc ();
if (c == EOF || c == CL_BRACE)
return c;
if ((looking_for == te_space_separator
|| looking_for == te_space_separator_bracket)
&& (c == ' ' || c == BS_NL
|| c == '\t' || c == '\v' || c == '\f' || c == '\r'
|| c == ';' || c == '\n'))
return c;
if (looking_for == te_space_separator_bracket && c == ']')
return c;
if (looking_for == te_paren && c == ')')
return c;
if (looking_for == te_quote && c == '"')
return c;
if (c == '$')
{
c = phase2_getc ();
if (c == '{')
{
do
c = phase2_getc ();
while (c != EOF && c != '}');
wp->type = t_other;
}
else
{
bool nonempty = false;
for (; c != EOF && c != CL_BRACE; c = phase2_getc ())
{
if (c_isalnum ((unsigned char) c) || (c == '_'))
{
nonempty = true;
continue;
}
if (c == ':')
{
c = phase2_getc ();
if (c == ':')
{
do
c = phase2_getc ();
while (c == ':');
phase2_ungetc (c);
nonempty = true;
continue;
}
phase2_ungetc (c);
c = ':';
}
break;
}
if (c == '(')
{
struct word index_word;
index_word.type = t_other;
c = accumulate_word (&index_word, te_paren, null_context);
if (c != EOF && c != ')')
phase2_ungetc (c);
wp->type = t_other;
}
else
{
phase2_ungetc (c);
if (nonempty)
{
wp->type = t_other;
}
else
{
if (wp->type == t_string)
{
grow_token (wp->token);
wp->token->chars[wp->token->charcount++] = '$';
}
}
}
}
}
else if (c == '[')
{
read_command_list (']', context);
wp->type = t_other;
}
else if (c == '\\')
{
unsigned int uc;
unsigned char utf8buf[6];
int count;
int i;
uc = do_getc_escaped ();
assert (uc < 0x10000);
count = u8_uctomb (utf8buf, uc, 6);
assert (count > 0);
if (wp->type == t_string)
for (i = 0; i < count; i++)
{
grow_token (wp->token);
wp->token->chars[wp->token->charcount++] = utf8buf[i];
}
}
else
{
if (wp->type == t_string)
{
grow_token (wp->token);
wp->token->chars[wp->token->charcount++] = (unsigned char) c;
}
}
}
}
static void
read_word (struct word *wp, int looking_for, flag_context_ty context)
{
int c;
do
c = phase2_getc ();
while (c == ' ' || c == BS_NL);
if (c == EOF)
{
wp->type = t_eof;
return;
}
if (c == CL_BRACE)
{
wp->type = t_brace;
last_non_comment_line = line_number;
return;
}
if (c == '\n')
{
if (last_non_comment_line > last_comment_line)
xgettext_comment_reset ();
wp->type = t_separator;
return;
}
if (c == ';')
{
wp->type = t_separator;
last_non_comment_line = line_number;
return;
}
if (looking_for == ']' && c == ']')
{
wp->type = t_bracket;
last_non_comment_line = line_number;
return;
}
if (c == '{')
{
int previous_depth;
enum word_type terminator;
previous_depth = phase2_push () - 1;
terminator = read_command_list ('\0', null_context);
if (terminator == t_brace)
phase2_pop (previous_depth);
wp->type = t_other;
last_non_comment_line = line_number;
return;
}
wp->type = t_string;
wp->token = (struct token *) xmalloc (sizeof (struct token));
init_token (wp->token);
wp->line_number_at_start = line_number;
if (c == '"')
{
c = accumulate_word (wp, te_quote, context);
if (c != EOF && c != '"')
phase2_ungetc (c);
}
else
{
phase2_ungetc (c);
c = accumulate_word (wp,
looking_for == ']'
? te_space_separator_bracket
: te_space_separator,
context);
if (c != EOF)
phase2_ungetc (c);
}
if (wp->type != t_string)
{
free_token (wp->token);
free (wp->token);
}
last_non_comment_line = line_number;
}
static enum word_type
read_command (int looking_for, flag_context_ty outer_context)
{
int c;
for (;;)
{
c = phase2_getc ();
if (c == ' ' || c == BS_NL
|| c == '\t' || c == '\v' || c == '\f' || c == '\r')
continue;
if (c == '#')
{
last_comment_line = line_number;
comment_start ();
for (;;)
{
c = phase2_getc ();
if (c == EOF || c == CL_BRACE || c == '\n')
break;
if (!(buflen == 0 && (c == ' ' || c == '\t')))
comment_add (c);
}
comment_line_end ();
continue;
}
break;
}
phase2_ungetc (c);
{
int arg = 0;
flag_context_list_iterator_ty context_iter;
int argnum1 = 0;
int argnum2 = 0;
message_ty *plural_mp = NULL;
for (;; arg++)
{
struct word inner;
flag_context_ty inner_context;
if (arg == 0)
inner_context = null_context;
else
inner_context =
inherited_context (outer_context,
flag_context_list_iterator_advance (
&context_iter));
read_word (&inner, looking_for, inner_context);
if (inner.type == t_separator || inner.type == t_bracket
|| inner.type == t_brace || inner.type == t_eof)
return inner.type;
if (extract_all)
{
if (inner.type == t_string)
{
lex_pos_ty pos;
pos.file_name = logical_file_name;
pos.line_number = inner.line_number_at_start;
remember_a_message (mlp, string_of_word (&inner),
inner_context, &pos);
}
}
if (arg == 0)
{
if (inner.type == t_string)
{
char *function_name = string_of_word (&inner);
char *stripped_name;
void *keyword_value;
stripped_name = function_name;
if (function_name[0] == ':' && function_name[1] == ':')
stripped_name += 2;
if (find_entry (&keywords,
stripped_name, strlen (stripped_name),
&keyword_value)
== 0)
{
argnum1 = (int) (long) keyword_value & ((1 << 10) - 1);
argnum2 = (int) (long) keyword_value >> 10;
}
context_iter =
flag_context_list_iterator (
flag_context_list_table_lookup (
flag_context_list_table,
stripped_name, strlen (stripped_name)));
free (function_name);
}
else
context_iter = null_context_list_iterator;
}
else
{
if (arg == argnum1)
{
if (inner.type == t_string)
{
lex_pos_ty pos;
message_ty *mp;
pos.file_name = logical_file_name;
pos.line_number = inner.line_number_at_start;
mp = remember_a_message (mlp, string_of_word (&inner),
inner_context, &pos);
if (argnum2 > 0)
plural_mp = mp;
}
}
else if (arg == argnum2)
{
if (inner.type == t_string && plural_mp != NULL)
{
lex_pos_ty pos;
pos.file_name = logical_file_name;
pos.line_number = inner.line_number_at_start;
remember_a_message_plural (plural_mp, string_of_word (&inner),
inner_context, &pos);
}
}
}
free_word (&inner);
}
}
}
static enum word_type
read_command_list (int looking_for, flag_context_ty outer_context)
{
for (;;)
{
enum word_type terminator;
terminator = read_command (looking_for, outer_context);
if (terminator != t_separator)
return terminator;
}
}
void
extract_tcl (FILE *f,
const char *real_filename, const char *logical_filename,
flag_context_list_table_ty *flag_table,
msgdomain_list_ty *mdlp)
{
mlp = mdlp->item[0]->messages;
xgettext_current_source_encoding = po_charset_utf8;
fp = f;
real_file_name = real_filename;
logical_file_name = xstrdup (logical_filename);
line_number = 1;
brace_depth = 1000000;
last_comment_line = -1;
last_non_comment_line = -1;
flag_context_list_table = flag_table;
init_keywords ();
read_command_list ('\0', null_context);
fp = NULL;
real_file_name = NULL;
logical_file_name = NULL;
line_number = 0;
}