QT_BEGIN_NAMESPACE
// only moc needs this function
static QByteArray normalizeType(const char *s, bool fixScope = false)
{
int len = qstrlen(s);
char stackbuf[64];
char *buf = (len >= 64 ? new char[len + 1] : stackbuf);
char *d = buf;
char last = 0;
while(*s && is_space(*s))
s++;
while (*s) {
while (*s && !is_space(*s))
last = *d++ = *s++;
while (*s && is_space(*s))
s++;
if (*s && ((is_ident_char(*s) && is_ident_char(last))
|| ((*s == ':') && (last == '<')))) {
last = *d++ = ' ';
}
}
*d = '\0';
QByteArray result;
if (strncmp("void", buf, d - buf) != 0)
result = normalizeTypeInternal(buf, d, fixScope);
if (buf != stackbuf)
delete [] buf;
return result;
}
QByteArray Moc::lexemUntil(Token target)
{
int from = index;
until(target);
QByteArray s;
while (from <= index) {
QByteArray n = symbols.at(from++-1).lexem();
if (s.size() && n.size()
&& is_ident_char(s.at(s.size()-1))
&& is_ident_char(n.at(0)))
s += ' ';
s += n;
}
return s;
}
void newState(QList<State> &states, const char *token, const char *lexem, bool pre)
{
const char * ident = 0;
if (is_ident_start(*lexem))
ident = pre?"PP_CHARACTER" : "CHARACTER";
else if (*lexem == '#')
ident = pre?"PP_HASH" : "HASH";
int state = 0;
while (*lexem) {
int next = states[state].next[(int)*lexem];
if (!next) {
const char * t = 0;
if (ident)
t = ident;
else
t = pre?"PP_INCOMPLETE":"INCOMPLETE";
next = states.size();
states += State(t);
states[state].next[(int)*lexem] = next;
states[next].ident = ident;
}
state = next;
++lexem;
if (ident && !is_ident_char(*lexem))
ident = 0;
}
states[state].token = token;
}
static void qRemoveWhitespace(const char *s, char *d)
{
char last = 0;
while (*s && is_space(*s))
s++;
while (*s) {
while (*s && !is_space(*s))
last = *d++ = *s++;
while (*s && is_space(*s))
s++;
if (*s && ((is_ident_char(*s) && is_ident_char(last))
|| ((*s == ':') && (last == '<')))) {
last = *d++ = ' ';
}
}
*d = '\0';
}
static Symbols tokenize(const QByteArray &input, int lineNum = 1, TokenizeMode mode = TokenizeCpp)
{
Symbols symbols;
const char *begin = input;
const char *data = begin;
while (*data) {
if (mode == TokenizeCpp) {
int column = 0;
const char *lexem = data;
int state = 0;
Token token = NOTOKEN;
for (;;) {
if (static_cast<signed char>(*data) < 0) {
++data;
continue;
}
int nextindex = keywords[state].next;
int next = 0;
if (*data == keywords[state].defchar)
next = keywords[state].defnext;
else if (!state || nextindex)
next = keyword_trans[nextindex][(int)*data];
if (!next)
break;
state = next;
token = keywords[state].token;
++data;
}
// suboptimal, is_ident_char should use a table
if (keywords[state].ident && is_ident_char(*data))
token = keywords[state].ident;
if (token == NOTOKEN) {
// an error really
++data;
continue;
}
++column;
if (token > SPECIAL_TREATMENT_MARK) {
switch (token) {
case QUOTE:
data = skipQuote(data);
token = STRING_LITERAL;
// concatenate multi-line strings for easier
// STRING_LITERAAL handling in moc
if (!Preprocessor::preprocessOnly
&& !symbols.isEmpty()
&& symbols.last().token == STRING_LITERAL) {
QByteArray newString = symbols.last().unquotedLexem();
newString += input.mid(lexem - begin + 1, data - lexem - 2);
newString.prepend('\"');
newString.append('\"');
symbols.last() = Symbol(symbols.last().lineNum,
STRING_LITERAL,
newString);
continue;
}
break;
case SINGLEQUOTE:
while (*data && (*data != '\''
|| (*(data-1)=='\\'
&& *(data-2)!='\\')))
++data;
if (*data)
++data;
token = CHARACTER_LITERAL;
break;
case LANGLE_SCOPE:
// split <:: into two tokens, < and ::
token = LANGLE;
data -= 2;
break;
case DIGIT:
while (is_digit_char(*data))
++data;
if (!*data || *data != '.') {
token = INTEGER_LITERAL;
if (data - lexem == 1 &&
(*data == 'x' || *data == 'X')
&& *lexem == '0') {
++data;
while (is_hex_char(*data))
++data;
}
break;
}
token = FLOATING_LITERAL;
++data;
// fall through
case FLOATING_LITERAL:
while (is_digit_char(*data))
++data;
if (*data == '+' || *data == '-')
++data;
if (*data == 'e' || *data == 'E') {
++data;
while (is_digit_char(*data))
++data;
}
if (*data == 'f' || *data == 'F'
|| *data == 'l' || *data == 'L')
++data;
break;
case HASH:
if (column == 1) {
mode = PreparePreprocessorStatement;
while (*data && (*data == ' ' || *data == '\t'))
++data;
if (is_ident_char(*data))
mode = TokenizePreprocessorStatement;
continue;
}
break;
case NEWLINE:
++lineNum;
continue;
case BACKSLASH:
{
const char *rewind = data;
while (*data && (*data == ' ' || *data == '\t'))
++data;
if (*data && *data == '\n') {
++data;
continue;
}
data = rewind;
} break;
case CHARACTER:
while (is_ident_char(*data))
++data;
token = IDENTIFIER;
break;
case C_COMMENT:
if (*data) {
if (*data == '\n')
++lineNum;
++data;
if (*data) {
if (*data == '\n')
++lineNum;
++data;
}
}
while (*data && (*(data-1) != '/' || *(data-2) != '*')) {
if (*data == '\n')
++lineNum;
++data;
}
token = WHITESPACE; // one comment, one whitespace
// fall through;
case WHITESPACE:
if (column == 1)
column = 0;
while (*data && (*data == ' ' || *data == '\t'))
++data;
if (Preprocessor::preprocessOnly) // tokenize whitespace
break;
continue;
case CPP_COMMENT:
while (*data && *data != '\n')
++data;
continue; // ignore safely, the newline is a separator
default:
continue; //ignore
}
}
#ifdef USE_LEXEM_STORE
if (!Preprocessor::preprocessOnly
&& token != IDENTIFIER
&& token != STRING_LITERAL
&& token != FLOATING_LITERAL
&& token != INTEGER_LITERAL)
symbols += Symbol(lineNum, token);
else
#endif
symbols += Symbol(lineNum, token, input, lexem-begin, data-lexem);
} else { // Preprocessor
const char *lexem = data;
int state = 0;
Token token = NOTOKEN;
if (mode == TokenizePreprocessorStatement) {
state = pp_keyword_trans[0][(int)'#'];
mode = TokenizePreprocessor;
}
for (;;) {
if (static_cast<signed char>(*data) < 0) {
++data;
continue;
}
int nextindex = pp_keywords[state].next;
int next = 0;
if (*data == pp_keywords[state].defchar)
next = pp_keywords[state].defnext;
else if (!state || nextindex)
next = pp_keyword_trans[nextindex][(int)*data];
if (!next)
break;
state = next;
token = pp_keywords[state].token;
++data;
}
// suboptimal, is_ident_char should use a table
if (pp_keywords[state].ident && is_ident_char(*data))
token = pp_keywords[state].ident;
switch (token) {
case NOTOKEN:
++data;
break;
case PP_IFDEF:
symbols += Symbol(lineNum, PP_IF);
symbols += Symbol(lineNum, PP_DEFINED);
continue;
case PP_IFNDEF:
symbols += Symbol(lineNum, PP_IF);
symbols += Symbol(lineNum, PP_NOT);
symbols += Symbol(lineNum, PP_DEFINED);
continue;
case PP_INCLUDE:
mode = TokenizeInclude;
break;
case PP_QUOTE:
data = skipQuote(data);
token = PP_STRING_LITERAL;
break;
case PP_SINGLEQUOTE:
while (*data && (*data != '\''
|| (*(data-1)=='\\'
&& *(data-2)!='\\')))
++data;
if (*data)
++data;
token = PP_CHARACTER_LITERAL;
break;
case PP_DIGIT:
while (is_digit_char(*data))
++data;
if (!*data || *data != '.') {
token = PP_INTEGER_LITERAL;
if (data - lexem == 1 &&
(*data == 'x' || *data == 'X')
&& *lexem == '0') {
++data;
while (is_hex_char(*data))
++data;
}
break;
}
token = PP_FLOATING_LITERAL;
++data;
// fall through
case PP_FLOATING_LITERAL:
while (is_digit_char(*data))
++data;
if (*data == '+' || *data == '-')
++data;
if (*data == 'e' || *data == 'E') {
++data;
while (is_digit_char(*data))
++data;
}
if (*data == 'f' || *data == 'F'
|| *data == 'l' || *data == 'L')
++data;
break;
case PP_CHARACTER:
if (mode == PreparePreprocessorStatement) {
// rewind entire token to begin
data = lexem;
mode = TokenizePreprocessorStatement;
continue;
}
while (is_ident_char(*data))
++data;
token = PP_IDENTIFIER;
break;
case PP_C_COMMENT:
if (*data) {
if (*data == '\n')
++lineNum;
++data;
if (*data) {
if (*data == '\n')
++lineNum;
++data;
}
}
while (*data && (*(data-1) != '/' || *(data-2) != '*')) {
if (*data == '\n')
++lineNum;
++data;
}
token = PP_WHITESPACE; // one comment, one whitespace
// fall through;
case PP_WHITESPACE:
while (*data && (*data == ' ' || *data == '\t'))
++data;
continue; // the preprocessor needs no whitespace
case PP_CPP_COMMENT:
while (*data && *data != '\n')
++data;
continue; // ignore safely, the newline is a separator
case PP_NEWLINE:
++lineNum;
mode = TokenizeCpp;
break;
case PP_BACKSLASH:
{
const char *rewind = data;
while (*data && (*data == ' ' || *data == '\t'))
++data;
if (*data && *data == '\n') {
++data;
continue;
}
data = rewind;
} break;
case PP_LANGLE:
if (mode != TokenizeInclude)
break;
token = PP_STRING_LITERAL;
while (*data && *data != '\n' && *(data-1) != '>')
++data;
break;
default:
break;
}
if (mode == PreparePreprocessorStatement)
continue;
#ifdef USE_LEXEM_STORE
if (token != PP_IDENTIFIER
&& token != PP_STRING_LITERAL
&& token != PP_FLOATING_LITERAL
&& token != PP_INTEGER_LITERAL)
symbols += Symbol(lineNum, token);
else
#endif
symbols += Symbol(lineNum, token, input, lexem-begin, data-lexem);
}
}
symbols += Symbol(); // eof symbol
return symbols;
}
// This code is shared with moc.cpp
static QByteArray normalizeTypeInternalQt47(const char *t, const char *e, bool fixScope = false, bool adjustConst = true)
{
int len = e - t;
/*
Convert 'char const *' into 'const char *'. Start at index 1,
not 0, because 'const char *' is already OK.
*/
QByteArray constbuf;
for (int i = 1; i < len; i++) {
if ( t[i] == 'c'
&& strncmp(t + i + 1, "onst", 4) == 0
&& (i + 5 >= len || !is_ident_char(t[i + 5]))
&& !is_ident_char(t[i-1])
) {
constbuf = QByteArray(t, len);
if (is_space(t[i-1]))
constbuf.remove(i-1, 6);
else
constbuf.remove(i, 5);
constbuf.prepend("const ");
t = constbuf.data();
e = constbuf.data() + constbuf.length();
break;
}
/*
We musn't convert 'char * const *' into 'const char **'
and we must beware of 'Bar<const Bla>'.
*/
if (t[i] == '&' || t[i] == '*' ||t[i] == '<')
break;
}
if (adjustConst && e > t + 6 && strncmp("const ", t, 6) == 0) {
if (*(e-1) == '&') { // treat const reference as value
t += 6;
--e;
} else if (is_ident_char(*(e-1)) || *(e-1) == '>') { // treat const value as value
t += 6;
}
}
QByteArray result;
result.reserve(len);
#if 1
// consume initial 'const '
if (strncmp("const ", t, 6) == 0) {
t+= 6;
result += "const ";
}
#endif
// some type substitutions for 'unsigned x'
if (strncmp("unsigned", t, 8) == 0) {
// make sure "unsigned" is an isolated word before making substitutions
if (!t[8] || !is_ident_char(t[8])) {
if (strncmp(" int", t+8, 4) == 0) {
t += 8+4;
result += "uint";
} else if (strncmp(" long", t+8, 5) == 0) {
if ((strlen(t + 8 + 5) < 4 || strncmp(t + 8 + 5, " int", 4) != 0) // preserve '[unsigned] long int'
&& (strlen(t + 8 + 5) < 5 || strncmp(t + 8 + 5, " long", 5) != 0) // preserve '[unsigned] long long'
) {
t += 8+5;
result += "ulong";
}
} else if (strncmp(" short", t+8, 6) != 0 // preserve unsigned short
&& strncmp(" char", t+8, 5) != 0) { // preserve unsigned char
// treat rest (unsigned) as uint
t += 8;
result += "uint";
}
}
} else {
// discard 'struct', 'class', and 'enum'; they are optional
// and we don't want them in the normalized signature
struct {
const char *keyword;
int len;
} optional[] = {
{ "struct ", 7 },
{ "class ", 6 },
{ "enum ", 5 },
{ 0, 0 }
};
int i = 0;
do {
if (strncmp(optional[i].keyword, t, optional[i].len) == 0) {
t += optional[i].len;
break;
}
} while (optional[++i].keyword != 0);
}
bool star = false;
while (t != e) {
char c = *t++;
if (fixScope && c == ':' && *t == ':' ) {
++t;
c = *t++;
int i = result.size() - 1;
while (i >= 0 && is_ident_char(result.at(i)))
--i;
result.resize(i + 1);
}
star = star || c == '*';
result += c;
if (c == '<') {
//template recursion
const char* tt = t;
int templdepth = 1;
while (t != e) {
c = *t++;
if (c == '<')
++templdepth;
if (c == '>')
--templdepth;
if (templdepth == 0 || (templdepth == 1 && c == ',')) {
result += normalizeTypeInternalQt47(tt, t-1, fixScope, false);
result += c;
if (templdepth == 0) {
if (*t == '>')
result += ' '; // avoid >>
break;
}
tt = t;
}
}
}
// cv qualifers can appear after the type as well
if (!is_ident_char(c) && t != e && (e - t >= 5 && strncmp("const", t, 5) == 0)
&& (e - t == 5 || !is_ident_char(t[5]))) {
t += 5;
while (t != e && is_space(*t))
++t;
if (adjustConst && t != e && *t == '&') {
// treat const ref as value
++t;
} else if (adjustConst && !star) {
// treat const as value
} else if (!star) {
// move const to the front (but not if const comes after a *)
result.prepend("const ");
} else {
// keep const after a *
result += "const";
}
}
}
return result;
}
static int
parse_line(const unsigned char *str, size_t len, testinfo_t *pt, struct testinfo_subst_handler *sh)
{
unsigned char *subst_str = NULL;
const unsigned char *s = str;
unsigned char *name_buf = 0, *p;
unsigned char *val_buf = 0;
unsigned char **ppval;
size_t len2;
struct cmdline_buf cmd;
int retval = 0, x, n;
if (sh && pt->enable_subst > 0) {
subst_str = sh->substitute(sh, str);
str = subst_str;
s = str;
}
memset(&cmd, 0, sizeof(cmd));
if (!(name_buf = (unsigned char *) alloca(len + 1))) FAIL(TINF_E_NO_MEMORY);
if (!(val_buf = (unsigned char *) alloca(len + 2))) FAIL(TINF_E_NO_MEMORY);
while (isspace(*s)) s++;
p = name_buf;
if (!is_ident_char(*s)) FAIL(TINF_E_IDENT_EXPECTED);
while (is_ident_char(*s)) *p++ = *s++;
*p = 0;
while (isspace(*s)) s++;
if (!*s) {
/* implicit "1" */
strcpy(val_buf, "1");
} else if (*s != '=') {
FAIL(TINF_E_EQUAL_EXPECTED);
} else {
s++;
while (isspace(*s)) s++;
strcpy(val_buf, s);
len2 = strlen(val_buf);
while (len2 > 0 && isspace(val_buf[len2 - 1])) len2--;
}
if ((retval = parse_cmdline(val_buf, &cmd)) < 0) {
free_cmdline(&cmd);
free(subst_str);
return retval;
}
if (!strcmp(name_buf, "params")) {
if (pt->cmd_argc >= 0) FAIL(TINF_E_VAR_REDEFINED);
pt->cmd_argc = cmd.u;
pt->cmd_argv = (char**) cmd.v;
memset(&cmd, 0, sizeof(cmd));
} else if (!strcmp(name_buf, "environ")) {
if (pt->env_u > 0) FAIL(TINF_E_VAR_REDEFINED);
pt->env_u = cmd.u;
pt->env_v = (char**) cmd.v;
memset(&cmd, 0, sizeof(cmd));
} else if (!strcmp(name_buf, "compiler_env")) {
if (pt->compiler_env_u > 0) FAIL(TINF_E_VAR_REDEFINED);
pt->compiler_env_u = cmd.u;
pt->compiler_env_v = (char**) cmd.v;
memset(&cmd, 0, sizeof(cmd));
} else if (!strcmp(name_buf, "style_checker_env")) {
if (pt->style_checker_env_u > 0) FAIL(TINF_E_VAR_REDEFINED);
pt->style_checker_env_u = cmd.u;
pt->style_checker_env_v = (char**) cmd.v;
memset(&cmd, 0, sizeof(cmd));
} else if (!strcmp(name_buf, "comment")
|| !strcmp(name_buf, "team_comment")
|| !strcmp(name_buf, "source_stub")) {
if (!strcmp(name_buf, "comment")) {
ppval = (unsigned char**) ((void*) &pt->comment);
} else if (!strcmp(name_buf, "source_stub")) {
ppval = (unsigned char**) ((void*) &pt->source_stub);
} else {
ppval = (unsigned char**) ((void*)&pt->team_comment);
}
if (*ppval) FAIL(TINF_E_VAR_REDEFINED);
if (cmd.u < 1) FAIL(TINF_E_EMPTY_VALUE);
if (cmd.u > 1) FAIL(TINF_E_MULTIPLE_VALUE);
*ppval = cmd.v[0];
cmd.v[0] = 0;
} else if (!strcmp(name_buf, "exit_code")) {
if (cmd.u < 1) FAIL(TINF_E_EMPTY_VALUE);
if (cmd.u > 1) FAIL(TINF_E_MULTIPLE_VALUE);
if (sscanf(cmd.v[0], "%d%n", &x, &n) != 1 || cmd.v[0][n]
|| x < 0 || x > 127)
FAIL(TINF_E_INVALID_VALUE);
pt->exit_code = x;
} else if (!strcmp(name_buf, "check_stderr")) {
if (cmd.u < 1) {
x = 1;
} else {
if (cmd.u > 1) FAIL(TINF_E_MULTIPLE_VALUE);
if (sscanf(cmd.v[0], "%d%n", &x, &n) != 1 || cmd.v[0][n]
|| x < 0 || x > 1)
FAIL(TINF_E_INVALID_VALUE);
}
pt->check_stderr = x;
} else if (!strcmp(name_buf, "disable_stderr")) {
if (cmd.u < 1) {
x = 1;
} else {
if (cmd.u > 1) FAIL(TINF_E_MULTIPLE_VALUE);
if (sscanf(cmd.v[0], "%d%n", &x, &n) != 1 || cmd.v[0][n]
|| x < 0 || x > 1)
FAIL(TINF_E_INVALID_VALUE);
}
pt->disable_stderr = x;
} else if (!strcmp(name_buf, "enable_subst")) {
if (cmd.u < 1) {
x = 1;
} else {
if (cmd.u > 1) FAIL(TINF_E_MULTIPLE_VALUE);
if (sscanf(cmd.v[0], "%d%n", &x, &n) != 1 || cmd.v[0][n]
|| x < 0 || x > 1)
FAIL(TINF_E_INVALID_VALUE);
}
pt->enable_subst = x;
} else if (!strcmp(name_buf, "compiler_must_fail")) {
if (cmd.u < 1) {
x = 1;
} else {
if (cmd.u > 1) FAIL(TINF_E_MULTIPLE_VALUE);
if (sscanf(cmd.v[0], "%d%n", &x, &n) != 1 || cmd.v[0][n]
|| x < 0 || x > 1)
FAIL(TINF_E_INVALID_VALUE);
}
pt->compiler_must_fail = x;
} else {
FAIL(TINF_E_INVALID_VAR_NAME);
}
free_cmdline(&cmd);
free(subst_str);
return 0;
fail:
free_cmdline(&cmd);
free(subst_str);
return retval;
}
static void ident(const char **s) {
while (is_ident_char((unsigned char) s[0][0])) (*s)++;
}
static gboolean
write_filter_html_doc (FILE *out, top_level_decl_t *decl)
{
arg_decl_t *arg;
int num_args;
int arg_indent;
g_assert(decl->type == TOP_LEVEL_FILTER);
fprintf(out, "<p><a name=\"filter_%s\"></a><font size=\"+1\"><tt>filter <b>%s</b> (",
decl->name, decl->name);
num_args = 0;
for (arg = decl->v.filter.args; arg != NULL; arg = arg->next)
++num_args;
arg_indent = strlen("filter") + strlen(decl->name) + 3;
for (arg = decl->v.filter.args; arg != NULL; arg = arg->next)
{
static struct { int num; const char *name; } types[] =
{ { ARG_TYPE_INT, "int" },
{ ARG_TYPE_FLOAT, "float" },
{ ARG_TYPE_COLOR, "color" },
{ ARG_TYPE_GRADIENT, "gradient" },
{ ARG_TYPE_CURVE, "curve" },
{ ARG_TYPE_IMAGE, "image" },
{ 0, NULL } };
int i;
for (i = 0; types[i].name != NULL; ++i)
if (types[i].num == arg->type)
break;
g_assert(types[i].name != NULL);
fprintf(out, "%s <b>%s</b>", types[i].name, arg->name);
switch (arg->type)
{
case ARG_TYPE_INT :
if (arg->v.integer.have_limits)
fprintf(out, ": %d - %d", arg->v.integer.min, arg->v.integer.max);
break;
case ARG_TYPE_FLOAT :
if (arg->v.floating.have_limits)
fprintf(out, ": %g - %g", arg->v.floating.min, arg->v.floating.max);
break;
default :
break;
}
if (arg->next != NULL)
{
if (num_args > 2)
{
int i;
fprintf(out, ",\n<br>");
for (i = 0; i < arg_indent; ++i)
fprintf(out, " ");
}
else
fprintf(out, ", ");
}
}
fprintf(out, ")</font>\n");
if (decl->docstring != NULL)
{
char *p;
gboolean bold_mode = FALSE;
gboolean newline = FALSE;
fprintf(out, "<blockquote>");
for (p = decl->docstring; *p != '\0'; ++p)
{
if (*p == '\n')
{
if (newline)
{
fprintf(out, "\n<p>");
continue;
}
newline = TRUE;
}
else
newline = FALSE;
if (*p == '@')
{
fprintf(out, "<b>");
bold_mode = TRUE;
}
else
{
if (bold_mode && !is_ident_char(*p))
{
fprintf(out, "</b>");
bold_mode = FALSE;
}
if (!print_html_char(out, *p))
return FALSE;
}
}
fprintf(out, "</blockquote>\n");
}
return TRUE;
}