static void makeTagEntryNotify (subparser *s, const tagEntryInfo *entry, int corkIndex)
{
struct sQtMocSubparser *pQtMoc = (struct sQtMocSubparser*)s;
if (pQtMoc->iDepthOfQtClass == 0)
return;
if ((pQtMoc->eMemberMarker != QtMocMemberMarkerNone) &&
entry->kindIndex == CXXTagKindPROTOTYPE)
{
tagEntryInfo parasiteTag = *entry;
parasiteTag.langType = getInputLanguage ();
parasiteTag.kindIndex = (pQtMoc->eMemberMarker == QtMocMemberMarkerSlot)
? K_SLOT
: K_SIGNAL;
parasiteTag.extensionFields.scopeLangType = entry->langType;
makeTagEntry (¶siteTag);
}
}
extern bool doesInputLanguageRequestAutomaticFQTag (void)
{
return doesLanguageRequestAutomaticFQTag (getInputLanguage ());
}
extern bool doesInputLanguageAllowNullTag (void)
{
return doesLanguageAllowNullTag (getInputLanguage ());
}
extern unsigned int countInputLanguageRoles (int kindIndex)
{
return countLanguageRoles (getInputLanguage (), kindIndex);
}
extern unsigned int countInputLanguageKinds (void)
{
return countLanguageKinds (getInputLanguage ());
}
extern bool isInputLanguageRoleEnabled (int kindIndex, int roleIndex)
{
return isLanguageRoleEnabled (getInputLanguage (),
kindIndex, roleIndex);
}
extern bool isInputLanguageKindEnabled (int kindIndex)
{
return isLanguageKindEnabled (getInputLanguage (), kindIndex);
}
extern bool isInputLanguage (langType lang)
{
return (bool)((lang) == getInputLanguage ());
}
extern const char *getInputLanguageName (void)
{
return getLanguageName (getInputLanguage());
}
static void readToken (tokenInfo *const token)
{
int c;
token->type = TOKEN_UNDEFINED;
token->keyword = KEYWORD_NONE;
vStringClear (token->string);
getNextChar:
if (! InPhp)
{
c = findPhpStart ();
if (c != EOF)
InPhp = TRUE;
}
else
c = getcFromInputFile ();
c = skipWhitespaces (c);
token->lineNumber = getInputLineNumber ();
token->filePosition = getInputFilePosition ();
switch (c)
{
case EOF: token->type = TOKEN_EOF; break;
case '(': token->type = TOKEN_OPEN_PAREN; break;
case ')': token->type = TOKEN_CLOSE_PAREN; break;
case ';': token->type = TOKEN_SEMICOLON; break;
case ',': token->type = TOKEN_COMMA; break;
case '.': token->type = TOKEN_PERIOD; break;
case ':': token->type = TOKEN_COLON; break;
case '{': token->type = TOKEN_OPEN_CURLY; break;
case '}': token->type = TOKEN_CLOSE_CURLY; break;
case '[': token->type = TOKEN_OPEN_SQUARE; break;
case ']': token->type = TOKEN_CLOSE_SQUARE; break;
case '&': token->type = TOKEN_AMPERSAND; break;
case '\\': token->type = TOKEN_BACKSLASH; break;
case '=':
{
int d = getcFromInputFile ();
if (d == '=' || d == '>')
token->type = TOKEN_OPERATOR;
else
{
ungetcToInputFile (d);
token->type = TOKEN_EQUAL_SIGN;
}
break;
}
case '\'':
case '"':
token->type = TOKEN_STRING;
parseString (token->string, c);
token->lineNumber = getInputLineNumber ();
token->filePosition = getInputFilePosition ();
break;
case '<':
{
int d = getcFromInputFile ();
if (d == '/')
{
/* </script[:white:]*> */
if (tolower ((d = getcFromInputFile ())) == 's' &&
tolower ((d = getcFromInputFile ())) == 'c' &&
tolower ((d = getcFromInputFile ())) == 'r' &&
tolower ((d = getcFromInputFile ())) == 'i' &&
tolower ((d = getcFromInputFile ())) == 'p' &&
tolower ((d = getcFromInputFile ())) == 't' &&
(d = skipWhitespaces (getcFromInputFile ())) == '>')
{
InPhp = FALSE;
goto getNextChar;
}
else
{
ungetcToInputFile (d);
token->type = TOKEN_UNDEFINED;
}
}
else if (d == '<' && (d = getcFromInputFile ()) == '<')
{
token->type = TOKEN_STRING;
parseHeredoc (token->string);
}
else
{
ungetcToInputFile (d);
token->type = TOKEN_UNDEFINED;
}
break;
}
case '#': /* comment */
skipSingleComment ();
goto getNextChar;
break;
case '+':
case '-':
case '*':
case '%':
{
int d = getcFromInputFile ();
if (d != '=' && ! (c == '-' && d == '>'))
ungetcToInputFile (d);
token->type = TOKEN_OPERATOR;
break;
}
case '/': /* division or comment start */
{
int d = getcFromInputFile ();
if (d == '/') /* single-line comment */
{
skipSingleComment ();
goto getNextChar;
}
else if (d == '*')
{
do
{
c = skipToCharacter ('*');
if (c != EOF)
{
c = getcFromInputFile ();
if (c == '/')
break;
else
ungetcToInputFile (c);
}
} while (c != EOF && c != '\0');
goto getNextChar;
}
else
{
if (d != '=')
ungetcToInputFile (d);
token->type = TOKEN_OPERATOR;
}
break;
}
case '$': /* variable start */
{
int d = getcFromInputFile ();
if (! isIdentChar (d))
{
ungetcToInputFile (d);
token->type = TOKEN_UNDEFINED;
}
else
{
parseIdentifier (token->string, d);
token->type = TOKEN_VARIABLE;
}
break;
}
case '?': /* maybe the end of the PHP chunk */
{
int d = getcFromInputFile ();
if (d == '>')
{
InPhp = FALSE;
goto getNextChar;
}
else
{
ungetcToInputFile (d);
token->type = TOKEN_UNDEFINED;
}
break;
}
default:
if (! isIdentChar (c))
token->type = TOKEN_UNDEFINED;
else
{
parseIdentifier (token->string, c);
token->keyword = analyzeToken (token->string, getInputLanguage ());
if (token->keyword == KEYWORD_NONE)
token->type = TOKEN_IDENTIFIER;
else
token->type = TOKEN_KEYWORD;
}
break;
}
if (token->type == TOKEN_SEMICOLON ||
token->type == TOKEN_OPEN_CURLY ||
token->type == TOKEN_CLOSE_CURLY)
{
/* reset current statement details on statement end, and when entering
* a deeper scope.
* it is a bit ugly to do this in readToken(), but it makes everything
* a lot simpler. */
CurrentStatement.access = ACCESS_UNDEFINED;
CurrentStatement.impl = IMPL_UNDEFINED;
}
}
/* parse a function
*
* if @name is NULL, parses a normal function
* function myfunc($foo, $bar) {}
* function &myfunc($foo, $bar) {}
* function myfunc($foo, $bar) : type {}
*
* if @name is not NULL, parses an anonymous function with name @name
* $foo = function($foo, $bar) {}
* $foo = function&($foo, $bar) {}
* $foo = function($foo, $bar) use ($x, &$y) {}
* $foo = function($foo, $bar) use ($x, &$y) : type {} */
static boolean parseFunction (tokenInfo *const token, const tokenInfo *name)
{
boolean readNext = TRUE;
accessType access = CurrentStatement.access;
implType impl = CurrentStatement.impl;
tokenInfo *nameFree = NULL;
readToken (token);
/* skip a possible leading ampersand (return by reference) */
if (token->type == TOKEN_AMPERSAND)
readToken (token);
if (! name)
{
if (token->type != TOKEN_IDENTIFIER && token->type != TOKEN_KEYWORD)
return FALSE;
name = nameFree = newToken ();
copyToken (nameFree, token, TRUE);
readToken (token);
}
if (token->type == TOKEN_OPEN_PAREN)
{
vString *arglist = vStringNew ();
int depth = 1;
vStringPut (arglist, '(');
do
{
readToken (token);
switch (token->type)
{
case TOKEN_OPEN_PAREN: depth++; break;
case TOKEN_CLOSE_PAREN: depth--; break;
default: break;
}
/* display part */
switch (token->type)
{
case TOKEN_AMPERSAND: vStringPut (arglist, '&'); break;
case TOKEN_CLOSE_CURLY: vStringPut (arglist, '}'); break;
case TOKEN_CLOSE_PAREN: vStringPut (arglist, ')'); break;
case TOKEN_CLOSE_SQUARE: vStringPut (arglist, ']'); break;
case TOKEN_COLON: vStringPut (arglist, ':'); break;
case TOKEN_COMMA: vStringCatS (arglist, ", "); break;
case TOKEN_EQUAL_SIGN: vStringCatS (arglist, " = "); break;
case TOKEN_OPEN_CURLY: vStringPut (arglist, '{'); break;
case TOKEN_OPEN_PAREN: vStringPut (arglist, '('); break;
case TOKEN_OPEN_SQUARE: vStringPut (arglist, '['); break;
case TOKEN_PERIOD: vStringPut (arglist, '.'); break;
case TOKEN_SEMICOLON: vStringPut (arglist, ';'); break;
case TOKEN_BACKSLASH: vStringPut (arglist, '\\'); break;
case TOKEN_STRING:
{
vStringCatS (arglist, "'");
vStringCat (arglist, token->string);
vStringCatS (arglist, "'");
break;
}
case TOKEN_IDENTIFIER:
case TOKEN_KEYWORD:
case TOKEN_VARIABLE:
{
switch (vStringLast (arglist))
{
case 0:
case ' ':
case '{':
case '(':
case '[':
case '.':
case '\\':
/* no need for a space between those and the identifier */
break;
default:
vStringPut (arglist, ' ');
break;
}
if (token->type == TOKEN_VARIABLE)
vStringPut (arglist, '$');
vStringCat (arglist, token->string);
break;
}
default: break;
}
}
while (token->type != TOKEN_EOF && depth > 0);
vStringTerminate (arglist);
makeFunctionTag (name, arglist, access, impl);
vStringDelete (arglist);
readToken (token); /* normally it's an open brace or "use" keyword */
}
/* skip use(...) */
if (token->type == TOKEN_KEYWORD && token->keyword == KEYWORD_use)
{
readToken (token);
skipOverParens (token);
}
/* PHP7 return type declaration or if parsing Zephir, skip function return
* type hint */
if ((getInputLanguage () == Lang_php && token->type == TOKEN_COLON) ||
(getInputLanguage () == Lang_zephir && token->type == TOKEN_OPERATOR))
{
do
readToken (token);
while (token->type == TOKEN_IDENTIFIER ||
token->type == TOKEN_BACKSLASH);
}
if (token->type == TOKEN_OPEN_CURLY)
enterScope (token, name->string, K_FUNCTION);
else
readNext = FALSE;
if (nameFree)
deleteToken (nameFree);
return readNext;
}
extern kindDefinition *getInputLanguageFileKind (void)
{
return getLanguageKind (getInputLanguage (), KIND_FILE_INDEX);
}
extern bool isInputLanguageKindEnabled (char c)
{
return isLanguageKindEnabled (getInputLanguage (), c);
}
static const char *phpScopeSeparatorFor (int kind, int upperScopeKind)
{
return scopeSeparatorFor (getInputLanguage(), kind, upperScopeKind);
}
static verilogKind getKind (tokenInfo *const token)
{
return (verilogKind) lookupKeyword (vStringValue (token->name), getInputLanguage () );
}
