static int
phase4_getuc ()
{
int c = phase3_getc ();
if (c == EOF)
return -1;
if (c == '\\')
{
int c2 = phase3_getc ();
if (c2 == 't')
return '\t';
if (c2 == 'n')
return '\n';
if (c2 == 'r')
return '\r';
if (c2 == 'f')
return '\f';
if (c2 == 'u')
{
unsigned int n = 0;
int i;
for (i = 0; i < 4; i++)
{
int c1 = phase3_getc ();
if (c1 >= '0' && c1 <= '9')
n = (n << 4) + (c1 - '0');
else if (c1 >= 'A' && c1 <= 'F')
n = (n << 4) + (c1 - 'A' + 10);
else if (c1 >= 'a' && c1 <= 'f')
n = (n << 4) + (c1 - 'a' + 10);
else
{
phase3_ungetc (c1);
error_with_progname = false;
error (0, 0, _("%s:%lu: warning: invalid \\uxxxx syntax for Unicode character"),
real_file_name, (unsigned long) gram_pos.line_number);
error_with_progname = true;
return 'u';
}
}
return n;
}
return c2;
}
else
return c;
}
static int
phase7_getc ()
{
int c, n, j;
/* Use phase 3, because phase 4 elides comments. */
c = phase3_getc ();
/* Return a magic newline indicator, so that we can distinguish
between the user requesting a newline in the string (e.g. using
"\n" or "\012") from the user failing to terminate the string or
character constant. The ANSI C standard says: 3.1.3.4 Character
Constants contain ``any character except single quote, backslash or
newline; or an escape sequence'' and 3.1.4 String Literals contain
``any character except double quote, backslash or newline; or an
escape sequence''.
Most compilers give a fatal error in this case, however gcc is
stupidly silent, even though this is a very common typo. OK, so
gcc --pedantic will tell me, but that gripes about too much other
stuff. Could I have a ``gcc -Wnewline-in-string'' option, or
better yet a ``gcc -fno-newline-in-string'' option, please? Gcc is
also inconsistent between string literals and character constants:
you may not embed newlines in character constants; try it, you get
a useful diagnostic. --PMiller */
if (c == '\n')
return P7_NEWLINE;
if (c == '"')
return P7_QUOTES;
if (c == '\'')
return P7_QUOTE;
if (c != '\\')
return c;
c = phase3_getc ();
switch (c)
{
default:
/* Unknown escape sequences really should be an error, but just
ignore them, and let the real compiler complain. */
phase3_ungetc (c);
return '\\';
case '"':
case '\'':
case '?':
case '\\':
return c;
case 'a':
return '\a';
case 'b':
return '\b';
/* The \e escape is preculiar to gcc, and assumes an ASCII
character set (or superset). We don't provide support for it
here. */
case 'f':
return '\f';
case 'n':
return '\n';
case 'r':
return '\r';
case 't':
return '\t';
case 'v':
return '\v';
case 'x':
c = phase3_getc ();
switch (c)
{
default:
phase3_ungetc (c);
phase3_ungetc ('x');
return '\\';
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
break;
}
n = 0;
for (;;)
{
switch (c)
{
default:
phase3_ungetc (c);
return n;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
n = n * 16 + c - '0';
break;
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
n = n * 16 + 10 + c - 'A';
break;
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
n = n * 16 + 10 + c - 'a';
break;
}
c = phase3_getc ();
}
return n;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
n = 0;
for (j = 0; j < 3; ++j)
{
n = n * 8 + c - '0';
c = phase3_getc ();
switch (c)
{
default:
break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
continue;
}
break;
}
phase3_ungetc (c);
return n;
}
}
static int
phase4_getc ()
{
int c;
bool last_was_star;
c = phase3_getc ();
if (c != '/')
return c;
c = phase3_getc ();
switch (c)
{
default:
phase3_ungetc (c);
return '/';
case '*':
/* C comment. */
comment_start ();
last_was_star = false;
for (;;)
{
c = phase3_getc ();
if (c == EOF)
break;
/* We skip all leading white space, but not EOLs. */
if (!(buflen == 0 && (c == ' ' || c == '\t')))
comment_add (c);
switch (c)
{
case '\n':
comment_line_end (1);
comment_start ();
last_was_star = false;
continue;
case '*':
last_was_star = true;
continue;
case '/':
if (last_was_star)
{
comment_line_end (2);
break;
}
/* FALLTHROUGH */
default:
last_was_star = false;
continue;
}
break;
}
last_comment_line = newline_count;
return ' ';
case '/':
/* C++ or ISO C 99 comment. */
comment_start ();
for (;;)
{
c = phase3_getc ();
if (c == '\n' || c == EOF)
break;
/* We skip all leading white space, but not EOLs. */
if (!(buflen == 0 && (c == ' ' || c == '\t')))
comment_add (c);
}
comment_line_end (0);
last_comment_line = newline_count;
return '\n';
}
}
static void
phase4_get (token_ty *tp)
{
static char *buffer;
static int bufmax;
int bufpos;
int c;
if (phase4_pushback_length)
{
*tp = phase4_pushback[--phase4_pushback_length];
return;
}
tp->string = NULL;
for (;;)
{
tp->line_number = line_number;
c = phase3_getc ();
switch (c)
{
case EOF:
tp->type = token_type_eof;
return;
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 '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 '_':
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 127: case 128: case 129: case 130: case 131: case 132: case 133:
case 134: case 135: case 136: case 137: case 138: case 139: case 140:
case 141: case 142: case 143: case 144: case 145: case 146: case 147:
case 148: case 149: case 150: case 151: case 152: case 153: case 154:
case 155: case 156: case 157: case 158: case 159: case 160: case 161:
case 162: case 163: case 164: case 165: case 166: case 167: case 168:
case 169: case 170: case 171: case 172: case 173: case 174: case 175:
case 176: case 177: case 178: case 179: case 180: case 181: case 182:
case 183: case 184: case 185: case 186: case 187: case 188: case 189:
case 190: case 191: case 192: case 193: case 194: case 195: case 196:
case 197: case 198: case 199: case 200: case 201: case 202: case 203:
case 204: case 205: case 206: case 207: case 208: case 209: case 210:
case 211: case 212: case 213: case 214: case 215: case 216: case 217:
case 218: case 219: case 220: case 221: case 222: case 223: case 224:
case 225: case 226: case 227: case 228: case 229: case 230: case 231:
case 232: case 233: case 234: case 235: case 236: case 237: case 238:
case 239: case 240: case 241: case 242: case 243: case 244: case 245:
case 246: case 247: case 248: case 249: case 250: case 251: case 252:
case 253: case 254: case 255:
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 '_':
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':
case 127: case 128: case 129: case 130: case 131: case 132:
case 133: case 134: case 135: case 136: case 137: case 138:
case 139: case 140: case 141: case 142: case 143: case 144:
case 145: case 146: case 147: case 148: case 149: case 150:
case 151: case 152: case 153: case 154: case 155: case 156:
case 157: case 158: case 159: case 160: case 161: case 162:
case 163: case 164: case 165: case 166: case 167: case 168:
case 169: case 170: case 171: case 172: case 173: case 174:
case 175: case 176: case 177: case 178: case 179: case 180:
case 181: case 182: case 183: case 184: case 185: case 186:
case 187: case 188: case 189: case 190: case 191: case 192:
case 193: case 194: case 195: case 196: case 197: case 198:
case 199: case 200: case 201: case 202: case 203: case 204:
case 205: case 206: case 207: case 208: case 209: case 210:
case 211: case 212: case 213: case 214: case 215: case 216:
case 217: case 218: case 219: case 220: case 221: case 222:
case 223: case 224: case 225: case 226: case 227: case 228:
case 229: case 230: case 231: case 232: case 233: case 234:
case 235: case 236: case 237: case 238: case 239: case 240:
case 241: case 242: case 243: case 244: case 245: case 246:
case 247: case 248: case 249: case 250: case 251: case 252:
case 253: case 254: case 255:
continue;
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 '\'':
/* Single-quoted string literal. */
bufpos = 0;
for (;;)
{
c = phase1_getc ();
if (c == EOF || c == '\'')
break;
if (c == '\\')
{
c = phase1_getc ();
if (c != '\\' && c != '\'')
{
phase1_ungetc (c);
c = '\\';
}
}
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);
tp->comment = add_reference (savable_comment);
return;
case '"':
/* Double-quoted string literal. */
tp->type = token_type_string_literal;
bufpos = 0;
for (;;)
{
c = phase1_getc ();
if (c == EOF || c == '"')
break;
if (c == '$')
{
c = phase1_getc ();
if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
|| c == '_' || c == '{' || c >= 0x7f)
{
/* String with variables. */
tp->type = token_type_other;
continue;
}
phase1_ungetc (c);
c = '$';
}
if (c == '{')
{
c = phase1_getc ();
if (c == '$')
{
/* String with expressions. */
tp->type = token_type_other;
continue;
}
phase1_ungetc (c);
c = '{';
}
if (c == '\\')
{
int n, j;
c = phase1_getc ();
switch (c)
{
case '"':
case '\\':
case '$':
break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
n = 0;
for (j = 0; j < 3; ++j)
{
n = n * 8 + c - '0';
c = phase1_getc ();
switch (c)
{
default:
break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
continue;
}
break;
}
phase1_ungetc (c);
c = n;
break;
case 'x':
n = 0;
for (j = 0; j < 2; ++j)
{
c = phase1_getc ();
switch (c)
{
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
n = n * 16 + c - '0';
break;
case 'A': case 'B': case 'C': case 'D': case 'E':
case 'F':
n = n * 16 + 10 + c - 'A';
break;
case 'a': case 'b': case 'c': case 'd': case 'e':
case 'f':
n = n * 16 + 10 + c - 'a';
break;
default:
phase1_ungetc (c);
c = 0;
break;
}
if (c == 0)
break;
}
if (j == 0)
{
phase1_ungetc ('x');
c = '\\';
}
else
c = n;
break;
case 'n':
c = '\n';
break;
case 't':
c = '\t';
break;
case 'r':
c = '\r';
break;
default:
phase1_ungetc (c);
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;
if (tp->type == token_type_string_literal)
{
tp->string = xstrdup (buffer);
tp->comment = add_reference (savable_comment);
}
return;
case '?':
case '%':
{
int c2 = phase1_getc ();
if (c2 == '>')
{
/* ?> and %> terminate PHP mode and switch back to HTML
mode. */
skip_html ();
tp->type = token_type_other;
}
else
{
phase1_ungetc (c2);
tp->type = (c == '%' ? token_type_operator1 : token_type_other);
}
return;
}
case '(':
tp->type = token_type_lparen;
return;
case ')':
tp->type = token_type_rparen;
return;
case ',':
tp->type = token_type_comma;
return;
case '[':
tp->type = token_type_lbracket;
return;
case ']':
tp->type = token_type_rbracket;
return;
case '.':
tp->type = token_type_dot;
return;
case '*':
case '/':
tp->type = token_type_operator1;
return;
case '+':
case '-':
{
int c2 = phase1_getc ();
if (c2 == c)
/* ++ or -- */
tp->type = token_type_operator1;
else
/* + or - */
{
phase1_ungetc (c2);
tp->type = token_type_operator2;
}
return;
}
case '!':
case '~':
case '@':
tp->type = token_type_operator2;
return;
case '<':
{
int c2 = phase1_getc ();
if (c2 == '<')
{
int c3 = phase1_getc ();
if (c3 == '<')
{
/* Start of here document.
Parse whitespace, then label, then newline. */
do
c = phase3_getc ();
while (c == ' ' || c == '\t' || c == '\n' || c == '\r');
bufpos = 0;
do
{
if (bufpos >= bufmax)
{
bufmax = 2 * bufmax + 10;
buffer = xrealloc (buffer, bufmax);
}
buffer[bufpos++] = c;
c = phase3_getc ();
}
while (c != EOF && c != '\n' && c != '\r');
/* buffer[0..bufpos-1] now contains the label. */
/* Now skip the here document. */
for (;;)
{
c = phase1_getc ();
if (c == EOF)
break;
if (c == '\n' || c == '\r')
{
int bufidx = 0;
while (bufidx < bufpos)
{
c = phase1_getc ();
if (c == EOF)
break;
if (c != buffer[bufidx])
{
phase1_ungetc (c);
break;
}
bufidx++;
}
if (bufidx == bufpos)
{
c = phase1_getc ();
if (c != ';')
phase1_ungetc (c);
c = phase1_getc ();
if (c == '\n' || c == '\r')
break;
}
}
}
/* FIXME: Ideally we should turn the here document into a
string literal if it didn't contain $ substitution. And
we should also respect backslash escape sequences like
in double-quoted strings. */
tp->type = token_type_other;
return;
}
phase1_ungetc (c3);
}
/* < / script > terminates PHP mode and switches back to HTML
mode. */
while (c2 == ' ' || c2 == '\t' || c2 == '\n' || c2 == '\r')
c2 = phase1_getc ();
if (c2 == '/')
{
do
c2 = phase1_getc ();
while (c2 == ' ' || c2 == '\t' || c2 == '\n' || c2 == '\r');
if (c2 == 's' || c2 == 'S')
{
c2 = phase1_getc ();
if (c2 == 'c' || c2 == 'C')
{
c2 = phase1_getc ();
if (c2 == 'r' || c2 == 'R')
{
c2 = phase1_getc ();
if (c2 == 'i' || c2 == 'I')
{
c2 = phase1_getc ();
if (c2 == 'p' || c2 == 'P')
{
c2 = phase1_getc ();
if (c2 == 't' || c2 == 'T')
{
do
c2 = phase1_getc ();
while (c2 == ' ' || c2 == '\t'
|| c2 == '\n' || c2 == '\r');
if (c2 == '>')
{
skip_html ();
}
else
phase1_ungetc (c2);
}
else
phase1_ungetc (c2);
}
else
phase1_ungetc (c2);
}
else
phase1_ungetc (c2);
}
else
phase1_ungetc (c2);
}
else
phase1_ungetc (c2);
}
else
phase1_ungetc (c2);
}
else
phase1_ungetc (c2);
tp->type = token_type_other;
return;
}
case '`':
/* Execution operator. */
default:
/* We could carefully recognize each of the 2 and 3 character
operators, but it is not necessary, as we only need to recognize
gettext invocations. Don't bother. */
tp->type = token_type_other;
return;
}
}
}
static char *
read_escaped_string (bool in_key)
{
static unsigned short *buffer;
static size_t bufmax;
static size_t buflen;
int c;
/* Skip whitespace before the string. */
do
c = phase3_getc ();
while (c == ' ' || c == '\t' || c == '\r' || c == '\f');
if (c == EOF || c == '\n')
/* Empty string. */
return NULL;
/* Start accumulating the string. We store the string in UTF-16 before
converting it to UTF-8. Why not converting every character directly to
UTF-8? Because a string can contain surrogates like \uD800\uDF00, and
we must combine them to a single UTF-8 character. */
buflen = 0;
for (;;)
{
if (in_key && (c == '=' || c == ':'
|| c == ' ' || c == '\t' || c == '\r' || c == '\f'))
{
/* Skip whitespace after the string. */
while (c == ' ' || c == '\t' || c == '\r' || c == '\f')
c = phase3_getc ();
/* Skip '=' or ':' separator. */
if (!(c == '=' || c == ':'))
phase3_ungetc (c);
break;
}
phase3_ungetc (c);
/* Read the next UTF-16 codepoint. */
c = phase4_getuc ();
if (c < 0)
break;
/* Append it to the buffer. */
if (buflen >= bufmax)
{
bufmax += 100;
buffer = xrealloc (buffer, bufmax * sizeof (unsigned short));
}
buffer[buflen++] = c;
c = phase3_getc ();
if (c == EOF || c == '\n')
{
if (in_key)
phase3_ungetc (c);
break;
}
}
/* Now convert from UTF-16 to UTF-8. */
{
size_t pos;
unsigned char *utf8_string;
unsigned char *q;
/* Each UTF-16 word needs 3 bytes at worst. */
utf8_string = (unsigned char *) xmalloc (3 * buflen + 1);
for (pos = 0, q = utf8_string; pos < buflen; )
{
unsigned int uc;
int n;
pos += u16_mbtouc (&uc, buffer + pos, buflen - pos);
n = u8_uctomb (q, uc, 6);
assert (n > 0);
q += n;
}
*q = '\0';
assert (q - utf8_string <= 3 * buflen);
return (char *) utf8_string;
}
}
