vasilito
facf0c92e0
Red Bear OS is a full fork. All sources must be available from git clone with zero network access. Removed gitignore rules that excluded fetched source trees under recipes/*/source/, local/recipes/kde/*/source/, local/recipes/qt/*/source/, and vendor source trees. Build artifacts (target/, build/, source.tar, *.o, *.so) remain excluded. 127291 files added — kernel, relibc, base, bootloader, pkgar, all KDE/Qt frameworks, mesa, wayland, DRM drivers, and every other recipe source.
630 lines
17 KiB
C
630 lines
17 KiB
C
/* xgettext Smalltalk backend.
|
|
Copyright (C) 2002-2003, 2005-2009, 2011, 2018-2020 Free Software Foundation, Inc.
|
|
|
|
This file was written by Bruno Haible <haible@clisp.cons.org>, 2002.
|
|
|
|
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
|
|
|
|
/* Specification. */
|
|
#include "x-smalltalk.h"
|
|
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "attribute.h"
|
|
#include "message.h"
|
|
#include "xgettext.h"
|
|
#include "xg-pos.h"
|
|
#include "xg-message.h"
|
|
#include "error.h"
|
|
#include "xalloc.h"
|
|
#include "gettext.h"
|
|
|
|
#define _(s) gettext(s)
|
|
|
|
#define SIZEOF(a) (sizeof(a) / sizeof(a[0]))
|
|
|
|
|
|
/* The relevant parts of the Smalltalk syntax are:
|
|
|
|
stringliteral ::= string | stringconst | symconst
|
|
stringconst ::= "#"string
|
|
string ::= "'"[char]*"'"
|
|
symconst ::= "#"symbol
|
|
symbol ::= id | binsel | keysel[keysel]*
|
|
keysel ::= id":"
|
|
id ::= letter[letter|digit]*
|
|
letter ::= "A".."Z" | "a".."z"
|
|
digit ::= "0".."9"
|
|
binsel ::= selchar[selchar]
|
|
selchar ::= "+" | "-" | "*" | "/" | "~" | "|" | "," | "<" | ">"
|
|
| "=" | "&" | "@" | "?" | "%" | "\"
|
|
|
|
Strings can contain any characters; to include the string delimiter itself,
|
|
it must be duplicated.
|
|
|
|
Character constants are written "$"char
|
|
|
|
Comments are enclosed within double quotes.
|
|
|
|
In well-formed expressions, {} and [] and () are balanced.
|
|
*/
|
|
|
|
|
|
/* ======================== Reading of characters. ======================== */
|
|
|
|
/* The input file stream. */
|
|
static FILE *fp;
|
|
|
|
|
|
/* 1. line_number handling. */
|
|
|
|
static int
|
|
phase1_getc ()
|
|
{
|
|
int c = getc (fp);
|
|
|
|
if (c == EOF)
|
|
{
|
|
if (ferror (fp))
|
|
error (EXIT_FAILURE, errno, _("error while reading \"%s\""),
|
|
real_file_name);
|
|
return EOF;
|
|
}
|
|
|
|
if (c == '\n')
|
|
line_number++;
|
|
|
|
return c;
|
|
}
|
|
|
|
/* Supports only one pushback character. */
|
|
static void
|
|
phase1_ungetc (int c)
|
|
{
|
|
if (c != EOF)
|
|
{
|
|
if (c == '\n')
|
|
--line_number;
|
|
|
|
ungetc (c, fp);
|
|
}
|
|
}
|
|
|
|
|
|
/* Accumulating comments. */
|
|
|
|
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';
|
|
savable_comment_add (buffer);
|
|
}
|
|
|
|
|
|
/* These are for tracking whether comments count as immediately before
|
|
keyword. */
|
|
static int last_comment_line;
|
|
static int last_non_comment_line;
|
|
|
|
|
|
/* ========================== Reading of tokens. ========================== */
|
|
|
|
|
|
enum token_type_ty
|
|
{
|
|
token_type_eof,
|
|
token_type_uniq, /* # */
|
|
token_type_symbol, /* symbol */
|
|
token_type_string_literal, /* string, stringconst, symbolconst */
|
|
token_type_other /* misc. operator */
|
|
};
|
|
typedef enum token_type_ty token_type_ty;
|
|
|
|
typedef struct token_ty token_ty;
|
|
struct token_ty
|
|
{
|
|
token_type_ty type;
|
|
char *string; /* for token_type_string_literal, token_type_symbol */
|
|
int line_number;
|
|
};
|
|
|
|
|
|
/* 2. Combine characters into tokens. Discard comments and whitespace. */
|
|
|
|
static token_ty phase2_pushback[1];
|
|
static int phase2_pushback_length;
|
|
|
|
static void
|
|
phase2_get (token_ty *tp)
|
|
{
|
|
static char *buffer;
|
|
static int bufmax;
|
|
int bufpos;
|
|
int c;
|
|
|
|
if (phase2_pushback_length)
|
|
{
|
|
*tp = phase2_pushback[--phase2_pushback_length];
|
|
return;
|
|
}
|
|
|
|
tp->string = NULL;
|
|
|
|
for (;;)
|
|
{
|
|
tp->line_number = line_number;
|
|
c = phase1_getc ();
|
|
switch (c)
|
|
{
|
|
case EOF:
|
|
tp->type = token_type_eof;
|
|
return;
|
|
|
|
case '"':
|
|
{
|
|
/* Comment. */
|
|
int lineno;
|
|
|
|
comment_start ();
|
|
lineno = line_number;
|
|
for (;;)
|
|
{
|
|
c = phase1_getc ();
|
|
if (c == '"' || c == EOF)
|
|
break;
|
|
if (c == '\n')
|
|
{
|
|
comment_line_end ();
|
|
comment_start ();
|
|
}
|
|
else
|
|
{
|
|
/* We skip all leading white space, but not EOLs. */
|
|
if (!(buflen == 0 && (c == ' ' || c == '\t')))
|
|
comment_add (c);
|
|
}
|
|
}
|
|
comment_line_end ();
|
|
last_comment_line = lineno;
|
|
continue;
|
|
}
|
|
|
|
case '\n':
|
|
if (last_non_comment_line > last_comment_line)
|
|
savable_comment_reset ();
|
|
FALLTHROUGH;
|
|
case ' ':
|
|
case '\t':
|
|
case '\r':
|
|
/* Ignore whitespace. */
|
|
continue;
|
|
}
|
|
|
|
last_non_comment_line = tp->line_number;
|
|
|
|
switch (c)
|
|
{
|
|
case '\'':
|
|
/* String literal. */
|
|
bufpos = 0;
|
|
for (;;)
|
|
{
|
|
c = phase1_getc ();
|
|
if (c == EOF)
|
|
break;
|
|
if (c == '\'')
|
|
{
|
|
c = phase1_getc ();
|
|
if (c != '\'')
|
|
{
|
|
phase1_ungetc (c);
|
|
break;
|
|
}
|
|
}
|
|
if (bufpos >= bufmax)
|
|
{
|
|
bufmax = 2 * bufmax + 10;
|
|
buffer = xrealloc (buffer, bufmax);
|
|
}
|
|
buffer[bufpos++] = c;
|
|
}
|
|
if (bufpos >= bufmax)
|
|
{
|
|
bufmax = 2 * bufmax + 10;
|
|
buffer = xrealloc (buffer, bufmax);
|
|
}
|
|
buffer[bufpos] = 0;
|
|
tp->type = token_type_string_literal;
|
|
tp->string = xstrdup (buffer);
|
|
return;
|
|
|
|
case '+':
|
|
case '-':
|
|
case '*':
|
|
case '/':
|
|
case '~':
|
|
case '|':
|
|
case ',':
|
|
case '<':
|
|
case '>':
|
|
case '=':
|
|
case '&':
|
|
case '@':
|
|
case '?':
|
|
case '%':
|
|
case '\\':
|
|
{
|
|
char *name;
|
|
int c2 = phase1_getc ();
|
|
switch (c2)
|
|
{
|
|
case '+':
|
|
case '-':
|
|
case '*':
|
|
case '/':
|
|
case '~':
|
|
case '|':
|
|
case ',':
|
|
case '<':
|
|
case '>':
|
|
case '=':
|
|
case '&':
|
|
case '@':
|
|
case '?':
|
|
case '%':
|
|
name = XNMALLOC (3, char);
|
|
name[0] = c;
|
|
name[1] = c2;
|
|
name[2] = '\0';
|
|
tp->type = token_type_symbol;
|
|
tp->string = name;
|
|
return;
|
|
default:
|
|
phase1_ungetc (c2);
|
|
break;
|
|
}
|
|
name = XNMALLOC (2, char);
|
|
name[0] = c;
|
|
name[1] = '\0';
|
|
tp->type = token_type_symbol;
|
|
tp->string = name;
|
|
return;
|
|
}
|
|
|
|
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
|
|
case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
|
|
case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
|
|
case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
|
|
case 'Y': case 'Z':
|
|
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
|
|
case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
|
|
case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
|
|
case 's': case 't': case 'u': case 'v': case 'w': case 'x':
|
|
case 'y': case 'z':
|
|
/* Recognize id or id":"[id":"]* or id":"[id":"]*id. */
|
|
bufpos = 0;
|
|
for (;;)
|
|
{
|
|
if (bufpos >= bufmax)
|
|
{
|
|
bufmax = 2 * bufmax + 10;
|
|
buffer = xrealloc (buffer, bufmax);
|
|
}
|
|
buffer[bufpos++] = c;
|
|
c = phase1_getc ();
|
|
switch (c)
|
|
{
|
|
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
|
|
case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
|
|
case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
|
|
case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
|
|
case 'Y': case 'Z':
|
|
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
|
|
case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
|
|
case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
|
|
case 's': case 't': case 'u': case 'v': case 'w': case 'x':
|
|
case 'y': case 'z':
|
|
case '0': case '1': case '2': case '3': case '4':
|
|
case '5': case '6': case '7': case '8': case '9':
|
|
continue;
|
|
case ':':
|
|
if (bufpos >= bufmax)
|
|
{
|
|
bufmax = 2 * bufmax + 10;
|
|
buffer = xrealloc (buffer, bufmax);
|
|
}
|
|
buffer[bufpos++] = c;
|
|
c = phase1_getc ();
|
|
switch (c)
|
|
{
|
|
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
|
|
case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
|
|
case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
|
|
case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
|
|
case 'Y': case 'Z':
|
|
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
|
|
case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
|
|
case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
|
|
case 's': case 't': case 'u': case 'v': case 'w': case 'x':
|
|
case 'y': case 'z':
|
|
continue;
|
|
default:
|
|
phase1_ungetc (c);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
phase1_ungetc (c);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (bufpos >= bufmax)
|
|
{
|
|
bufmax = 2 * bufmax + 10;
|
|
buffer = xrealloc (buffer, bufmax);
|
|
}
|
|
buffer[bufpos] = '\0';
|
|
tp->string = xstrdup (buffer);
|
|
tp->type = token_type_symbol;
|
|
return;
|
|
|
|
case '#':
|
|
/* Uniquification operator. */
|
|
tp->type = token_type_uniq;
|
|
return;
|
|
|
|
case '$':
|
|
c = phase1_getc ();
|
|
tp->type = token_type_other;
|
|
return;
|
|
|
|
default:
|
|
tp->type = token_type_other;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Supports only one pushback token. */
|
|
static void
|
|
phase2_unget (token_ty *tp)
|
|
{
|
|
if (tp->type != token_type_eof)
|
|
{
|
|
if (phase2_pushback_length == SIZEOF (phase2_pushback))
|
|
abort ();
|
|
phase2_pushback[phase2_pushback_length++] = *tp;
|
|
}
|
|
}
|
|
|
|
|
|
/* 3. Combine "# string_literal" and "# symbol" to a single token. */
|
|
|
|
static token_ty phase3_pushback[1];
|
|
static int phase3_pushback_length;
|
|
|
|
static void
|
|
phase3_get (token_ty *tp)
|
|
{
|
|
if (phase3_pushback_length)
|
|
{
|
|
*tp = phase3_pushback[--phase3_pushback_length];
|
|
return;
|
|
}
|
|
|
|
phase2_get (tp);
|
|
if (tp->type == token_type_uniq)
|
|
{
|
|
token_ty token2;
|
|
|
|
phase2_get (&token2);
|
|
if (token2.type == token_type_symbol
|
|
|| token2.type == token_type_string_literal)
|
|
{
|
|
tp->type = token_type_string_literal;
|
|
tp->string = token2.string;
|
|
}
|
|
else
|
|
phase2_unget (&token2);
|
|
}
|
|
}
|
|
|
|
/* Supports only one pushback token. */
|
|
static void
|
|
phase3_unget (token_ty *tp)
|
|
{
|
|
if (tp->type != token_type_eof)
|
|
{
|
|
if (phase3_pushback_length == SIZEOF (phase3_pushback))
|
|
abort ();
|
|
phase3_pushback[phase3_pushback_length++] = *tp;
|
|
}
|
|
}
|
|
|
|
|
|
/* ========================= Extracting strings. ========================== */
|
|
|
|
/* The file is broken into tokens. Scan the token stream, looking for the
|
|
following patterns
|
|
NLS ? <string>
|
|
NLS at: <string>
|
|
NLS at: <string> plural: <string>
|
|
where <string> is one of
|
|
string_literal
|
|
# string_literal
|
|
# symbol
|
|
*/
|
|
|
|
void
|
|
extract_smalltalk (FILE *f,
|
|
const char *real_filename, const char *logical_filename,
|
|
flag_context_list_table_ty *flag_table,
|
|
msgdomain_list_ty *mdlp)
|
|
{
|
|
message_list_ty *mlp = mdlp->item[0]->messages;
|
|
|
|
fp = f;
|
|
real_file_name = real_filename;
|
|
logical_file_name = xstrdup (logical_filename);
|
|
line_number = 1;
|
|
|
|
last_comment_line = -1;
|
|
last_non_comment_line = -1;
|
|
|
|
phase2_pushback_length = 0;
|
|
phase3_pushback_length = 0;
|
|
|
|
/* Eat tokens until eof is seen. */
|
|
{
|
|
/* 0 when no "NLS" has been seen.
|
|
1 after "NLS".
|
|
2 after "NLS ?".
|
|
3 after "NLS at:".
|
|
4 after "NLS at: <string>".
|
|
5 after "NLS at: <string> plural:". */
|
|
int state;
|
|
/* Remember the message containing the msgid, for msgid_plural.
|
|
Non-NULL in states 4, 5. */
|
|
message_ty *plural_mp = NULL;
|
|
|
|
/* Start state is 0. */
|
|
state = 0;
|
|
|
|
for (;;)
|
|
{
|
|
token_ty token;
|
|
|
|
phase3_get (&token);
|
|
|
|
switch (token.type)
|
|
{
|
|
case token_type_symbol:
|
|
state = (strcmp (token.string, "NLS") == 0 ? 1 :
|
|
strcmp (token.string, "?") == 0 && state == 1 ? 2 :
|
|
strcmp (token.string, "at:") == 0 && state == 1 ? 3 :
|
|
strcmp (token.string, "plural:") == 0 && state == 4 ? 5 :
|
|
0);
|
|
free (token.string);
|
|
break;
|
|
|
|
case token_type_string_literal:
|
|
if (state == 2)
|
|
{
|
|
lex_pos_ty pos;
|
|
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);
|
|
state = 0;
|
|
break;
|
|
}
|
|
if (state == 3)
|
|
{
|
|
lex_pos_ty pos;
|
|
token_ty token2;
|
|
|
|
pos.file_name = logical_file_name;
|
|
pos.line_number = token.line_number;
|
|
|
|
phase3_get (&token2);
|
|
|
|
plural_mp =
|
|
remember_a_message (mlp, NULL, token.string, false,
|
|
token2.type == token_type_symbol
|
|
&& strcmp (token.string, "plural:") == 0,
|
|
null_context, &pos,
|
|
NULL, savable_comment, false);
|
|
|
|
phase3_unget (&token2);
|
|
|
|
state = 4;
|
|
break;
|
|
}
|
|
if (state == 5)
|
|
{
|
|
lex_pos_ty pos;
|
|
pos.file_name = logical_file_name;
|
|
pos.line_number = token.line_number;
|
|
if (plural_mp != NULL)
|
|
remember_a_message_plural (plural_mp, token.string, false,
|
|
null_context, &pos,
|
|
savable_comment, false);
|
|
state = 0;
|
|
break;
|
|
}
|
|
state = 0;
|
|
free (token.string);
|
|
break;
|
|
|
|
case token_type_uniq:
|
|
case token_type_other:
|
|
state = 0;
|
|
break;
|
|
|
|
case token_type_eof:
|
|
break;
|
|
|
|
default:
|
|
abort ();
|
|
}
|
|
|
|
if (token.type == token_type_eof)
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Close scanner. */
|
|
fp = NULL;
|
|
real_file_name = NULL;
|
|
logical_file_name = NULL;
|
|
line_number = 0;
|
|
}
|