// Parse a template declaration.
//
// tempate-declaration:
// 'template' '<' template-parameter-list '>' [requires-clause] declaration
//
// FIXME: Support explicit template instantiations in one way or
// another.
Decl&
Parser::template_declaration()
{
#if 0
require(tk::template_tok);
// Build a psuedo-scope.
//
// FIXME: Merge this with template parameter scope. I don't think
// that it's serving a very useful purpose.
// Template_scope& tmp = cxt.make_template_scope();
Enter_scope tscope(cxt, tmp);
// TODO: Allow >> to close the template parameter list in the
// case of default template arguments.
Enter_template_parameter_scope pscope(cxt);
match(tk::lt_tok);
tmp.parms = template_parameter_list();
match(tk::gt_tok);
// Parse the optional requires clause, followed by the parameterized
// declaration.
if (tk::next_token_is(tk::requires_tok)) {
// TODO: How are dependent names resolved in a requires clause?
tmp.cons = &requires_clause();
// Enter_scope cscope(cxt, cxt.make_constrained_scope(*tmp.cons));
Parsing_template save(*this, &tmp.parms, tmp.cons);
return declaration();
} else {
Parsing_template save(*this, &tmp.parms);
return declaration();
}
#endif
lingo_unreachable();
}
int declaration_list(void) {
if( declaration() ) {
} else if( declaration_list() ) {
declaration();
} else {
abort();
}
}
Parameter::Parameter(const std::string& decl, Function* pFunction):
Decl(handleDecl(decl), 0), // handle init values
_type(),
_isRef(false),
_isPointer(false),
_isConst(false)
{
std::size_t pos = declaration().rfind(name());
std::string tmp;
if (pos == 0 && name().size() == declaration().size())
tmp = declaration();
else
tmp = declaration().substr(0, pos);
_type = Poco::trim(tmp);
std::size_t rightCut = _type.size();
while (rightCut > 0 && (_type[rightCut-1] == '&' || _type[rightCut-1] == '*' || _type[rightCut-1] == '\t' || _type[rightCut-1] == ' '))
{
if (_type[rightCut-1] == '&')
_isRef = true;
if (_type[rightCut-1] == '*')
_isPointer = true;
--rightCut;
}
_type = Poco::trim(_type.substr(0, rightCut));
if (_type.find("const ") == 0)
{
_isConst = true;
_type = _type.substr(6);
}
if (_type.find("const\t") == 0)
{
_type = _type.substr(6);
_isConst = true;
}
Poco::trimInPlace(_type);
pos = decl.find("=");
_hasDefaultValue = (pos != std::string::npos);
if (_hasDefaultValue)
{
_defaultDecl = decl.substr(pos + 1);
Poco::trimInPlace(_defaultDecl);
std::size_t posStart = _defaultDecl.find("(");
std::size_t posEnd = _defaultDecl.rfind(")");
if (posStart != std::string::npos && posEnd != std::string::npos)
{
_defaultValue = _defaultDecl.substr(posStart + 1, posEnd-posStart - 1);
}
else
{
poco_assert (posStart == std::string::npos && posEnd == std::string::npos);
_defaultValue = _defaultDecl;
}
Poco::trimInPlace(_defaultValue);
}
}
void CodeRuntimeBinding::updateValue(){
if ( m_converter ){
QString code = m_converter->serialize()->toCode(
sender()->property(declaration()->identifierChain().last().toUtf8()), 0
);
if ( !code.isEmpty() ){
declaration()->document()->updateBindingValue(this, code);
m_modifiedByEngine = true;
}
}
}
QVariant CompletionItem::data(const QModelIndex& index, int role, const KDevelop::CodeCompletionModel* model) const
{
switch(role)
{
case Qt::DisplayRole:
{
if (index.column() == CodeCompletionModel::Prefix && m_prefix != "") {
return m_prefix;
}
break;
}
case CodeCompletionModel::BestMatchesCount:
return 5;
case CodeCompletionModel::MatchQuality:
{
if(!declaration())
return QVariant();
//type aliases are actually different types
if(declaration()->isTypeAlias())
return QVariant();
AbstractType::Ptr typeToMatch = static_cast<go::CodeCompletionContext*>(model->completionContext().data())->typeToMatch();
if(!typeToMatch)
return QVariant();
AbstractType::Ptr declType = declaration()->abstractType();
if (!declType)
return QVariant();
//ignore constants
typeToMatch->setModifiers(AbstractType::NoModifiers);
declType->setModifiers(AbstractType::NoModifiers);
if(declType->equals(typeToMatch.constData()))
{
return QVariant(10);
}
else if(declType->whichType() == AbstractType::TypeFunction)
{
GoFunctionType* function = fastCast<GoFunctionType*>(declType.constData());
auto args = function->returnArguments();
if(args.size() != 0)
{
AbstractType::Ptr first = args.first();
first->setModifiers(AbstractType::NoModifiers);
if(first->equals(typeToMatch.constData()))
return QVariant(10);
}
}else
{
return QVariant();
}
}
}
return NormalDeclarationCompletionItem::data(index, role, model);
}
/* EBNF: declaration-list -> declaration {declaration} */
static TreeNode * declaration_list(void)
{ TreeNode * t = declaration();
TreeNode * p = t;
TreeNode * newNode = NULL;
/* {declaration} */
while (token != ENDFILE)
{ newNode = declaration();
if ((newNode != NULL) && (p != NULL))
{ p->sibling = newNode;
p = newNode;
}
}
return t;
}
TOKEN external_declaration(void)
{
TOKEN ext_declaration = NULL;
SYMBOL sym = symalloc(); //symbol for the declaration we are dealing with
//used as a temporary place to aggregate data about the declaration until
//we can install the symbol
//NOTE: we check for a global declaration first because we can easily use
//the information we aggregate in the SYMBOL sym and pass it on rather than
//having to backtrack like we would if we looked for a function definition first
setStorageClass(sym, STATIC_STORAGE_CLASS);
ext_declaration = declaration(sym);
if( NULL == ext_declaration )
{
//we have a function definition instead of a global variable declaration
//and functions default to external storage
setStorageClass(sym, EXTERNAL_STORAGE_CLASS);
ext_declaration = function_definition(sym);
}
else
{
ext_declaration = NULL; //we don't want the variable declaration to make its way into the parse tree, so return NULL
}
return ext_declaration;
}
struct definition parse(void)
{
static struct definition last_def_returned;
struct definition def = {0};
while (!defs.len && peek().token != END) {
/* Parse a declaration, which can include definitions that will fill
* up the buffer. Tentative declarations will only affect the symbol
* table. */
declaration(NULL);
clear_definition(&fallback);
}
if (defs.cur < defs.len) {
def = defs.def[defs.cur++];
if (defs.cur == defs.len) {
/* Clear definition list once the last entry is returned. No leaks
* after everything is consumed. */
free(defs.def);
memset(&defs, 0, sizeof(defs));
}
}
/* Clear memory allocated for previous result. Parse is called until no
* more input can be consumed, letting us free all memory. */
if (last_def_returned.symbol)
clear_definition(&last_def_returned);
last_def_returned = def;
return def;
}
double statement()
//Handle 'let' and 'const' keywords
{
Token t = ts.get();
switch(t.kind) {
case let:
return declaration(false);
break;
case con:
return declaration(true);
break;
default:
ts.putback(t);
return expression();
}
}
void test_declaration()
{
const char *tokensv[] = { "int", "a" };
unsigned int tokensc = 2;
const char *expected_calls[] = {
/* eat the 'int' */
"lex_advance",
"lex_look_ahead",
"stack_assign_name",
"lex_look_ahead",
"stack_frame_size",
/* subract 4 from the stack */
"output_stack_allocate",
};
unsigned int count = 6;
ecc_context *ctx;
mock_data *data;
ctx = init_fake_context(tokensv, tokensc);
/* mock out the stack frame size response */
data = (mock_data *)ctx->data;
data->mock_return_uint_vals[0] = 1;
declaration(ctx, tokensv[0]);
check_expected_calls(ctx, "test_declaration", expected_calls, count);
}
void CodeGenerator::codeGeneration(vector<Node> parseTree)
{
// set up print function
llvmCode.push_back("@istr = private constant[4 x i8] c\"%d\\0A\\00\"\n");
llvmCode.push_back("@fstr = private constant[4 x i8] c\"%f\\0A\\00\"\n");
llvmCode.push_back("declare i32 @printf(i8*, ...)\n\n");
// scan the tree to generate the code
for (vector<Node>::iterator it = parseTree.begin(); it != parseTree.end();
it++) {
// Start analyzing the tree
if (it->symbol == "DeclList'") // declaration of variable or function
appendVectors(llvmCode, declaration(it));
else if (it->symbol == "VarDecl") // declaration of variable (could be array)
appendVectors(llvmCode,varDecl(it));
else if (it->symbol == "Stmt") // statement is appeared
appendVectors(llvmCode, statement(it));
else if (it->symbol == "{") {
llvmCode.push_back("{\n");
instruction = 0;
}
else if (it->symbol == "}")
llvmCode.push_back("}\n");
}
exportLlvmCode();
}
static
stmt_code(stream, node, brk, cont, ret) {
/* Handle the null expression. */
if ( !node ) return;
auto op = node[0];
/* For debugging purposes, put a blank line between each statement. */
fputs("\n", stream);
if ( op == 'dcls' ) declaration( stream, node );
else if ( op == 'brea' ) branch( stream, brk );
else if ( op == 'cont' ) branch( stream, cont );
else if ( op == 'retu' ) return_stmt( stream, node, ret );
else if ( op == 'goto' ) goto_stmt( stream, node );
else if ( op == 'if' ) if_stmt( stream, node, brk, cont, ret );
else if ( op == 'whil' ) while_stmt( stream, node, brk, cont, ret );
else if ( op == 'for' ) for_stmt( stream, node, brk, cont, ret );
else if ( op == 'do' ) do_stmt( stream, node, brk, cont, ret );
else if ( op == 'swit' ) switch_stmt( stream, node, brk, cont, ret );
else if ( op == 'case'
|| op == 'defa' ) case_stmt( stream, node, brk, cont, ret );
else if ( op == ':' ) label_stmt( stream, node, brk, cont, ret );
else if ( op == '{}' ) do_block( stream, node, brk, cont, ret );
else expr_code( stream, node, 0 );
}
void
bind_names ( node_t *root )
{
if (root != NULL) {
switch (root->type.index) {
case PROGRAM:
program(root);
break;
case FUNCTION_LIST:
bind_functions(root);
break;
case FUNCTION:
function(root);
break;
case VARIABLE:
variable(root);
break;
case BLOCK:
block(root);
break;
case DECLARATION:
declaration(root);
break;
case TEXT:
string(root);
break;
default:
skipNode(root);
break;
}
}
}
std::string Function::signature() const
{
std::string signature(declaration());
if (signature.compare(0, 8, "virtual ") == 0)
signature.erase(0, 8);
else if (signature.compare(0, 7, "static ") == 0)
signature.erase(0, 8);
if (signature.compare(0, 7, "inline ") == 0)
signature.erase(0, 7);
signature += "(";
bool isFirst = true;
for (Iterator it = begin(); it != end(); ++it)
{
if (isFirst)
isFirst = false;
else
signature += ", ";
std::string arg = (*it)->declaration();
std::string::size_type pos = arg.size() - 1;
while (pos > 0 && !std::isspace(arg[pos])) --pos;
while (pos > 0 && std::isspace(arg[pos])) --pos;
signature.append(arg, 0, pos + 1);
}
signature += ")";
if (_flags & FN_CONST)
signature += " const";
return signature;
}
DeclarationsPtr Parser::parseArgumentList()
{
IdentifiersPtr identifiers = parseIdentifierList();
if (m_errorCode > ErrorCodes::NoError) {
return DeclarationsPtr();
}
if (!match(TokenType::Colon)) {
reportError(ErrorCodes::ExpectedColon);
return DeclarationsPtr();
}
TypePtr type = parseType();
if (m_errorCode > ErrorCodes::NoError) {
return DeclarationsPtr();
}
DeclarationsPtr declarations(new Declarations);
for (std::vector<IdentifierPtr>::const_iterator i = identifiers->list.begin(); i != identifiers->list.end(); ++i) {
DeclarationPtr declaration(new Declaration);
declaration->id = *i;
declaration->type = type;
declarations->list.push_back(declaration);
}
DeclarationsPtr rest = parseArgumentList_r();
if (rest) {
declarations->list.insert(declarations->list.end(), rest->list.begin(), rest->list.end());
}
return declarations;
}
void program()
{
int entry_flag = 0;
Symbol *p, *q;
/* before parse insert read && write func */
p = insert_global_sym(FUNCTION,"read");
q = insert_global_sym(FUNCTION,"write");
if(!p || !q){
fprintf(stderr, "init read write function error\n");
exit(0);
}
token = get_token();
while(token == TOK_INT || token == TOK_PVOID
|| token == TOK_VOID || token == TOK_CHAR
|| token == TOK_PINT || token == TOK_PCHAR)
{
entry_flag = 1;
declaration(token);
}
if(entry_flag){
gen_code("stp\n");
printf("succeed!! exit()\n");
}else{
fprintf(stderr, "line %d: %s does not name a type\n", save_line, save_word );
}
}
void direct_declaration(void)
{
if (token.type == NAME)
strcpy(name, token.value);
else
if (token.type == LEFT_PARENS)
{
declaration();
if (token.type != RIGHT_PARENS)
{
fprintf(stderr, "missing ) on line %d\n", line);
n_errors++;
}
}
else
{
fprintf(stderr, "expected name or (dcl) on line %d\n", line);
n_errors++;
}
for(gettoken();
token.type == BOTH_PARENS || token.type == BRACKETS;
gettoken())
if (token.type == BOTH_PARENS)
strcat(description, " function returning");
else
{
strcat(description, " array");
strcat(description, token.value);
strcat(description, " of");
}
}
void Parser::parseIf(){
//then we know we have to parse an expression
getNext();
if(curr->type!=L_PAREN){
//then throw an exception
throw new YottaError(SYNTAX_ERROR, ERROR_MSG[8], curr->line, curr->ch);
}
//else start parsing an expression
expression();
//next we make sure we have a closing bracket
if(curr->type!=R_PAREN){
throw new YottaError(SYNTAX_ERROR, ERROR_MSG[9], curr->line, curr->ch);
}
getNext();
IF_STATEMENT_FLAG++;
//let's see if we have an opening left curly brace
if(curr->type==L_CURLY){
//then we would parse until we find a }
while(curr->type!=R_CURLY){
//then continue parsing
declaration();
if(curr->type==NULL_TOKEN){
throw new YottaError(SYNTAX_ERROR, ERROR_MSG[12], curr->line, curr->ch-1);
}
}
}
}
int external_declaration(void) {
if( function_definition() ) {
} else if( declaration() ) {
} else {
abort();
}
}
bool Wiinnertag::CreateExample(const string &filepath)
{
if(filepath.size() == 0)
return false;
CreateSubfolder(filepath.c_str());
string fullpath = filepath;
if(fullpath[fullpath.size()-1] != '/')
fullpath += '/';
fullpath += "Wiinnertag.xml";
TiXmlDocument xmlDoc;
TiXmlDeclaration declaration("1.0", "UTF-8", "");
xmlDoc.InsertEndChild(declaration);
TiXmlElement Tag("Tag");
Tag.SetAttribute("URL", "http://www.wiinnertag.com/wiinnertag_scripts/update_sign.php?key={KEY}&game_id={ID6}");
Tag.SetAttribute("Key", "1234567890");
xmlDoc.InsertEndChild(Tag);
xmlDoc.SaveFile(fullpath);
return true;
}
void FunctionDeclarationCompletionItem::executed(KTextEditor::View* view, const KTextEditor::Range& word)
{
qCDebug(KDEV_PYTHON_CODECOMPLETION) << "FunctionDeclarationCompletionItem executed";
KTextEditor::Document* document = view->document();
auto resolvedDecl = Helper::resolveAliasDeclaration(declaration().data());
DUChainReadLocker lock;
auto functionDecl = Helper::functionForCalled(resolvedDecl).declaration;
lock.unlock();
if ( ! functionDecl && (! resolvedDecl || ! resolvedDecl->abstractType()
|| resolvedDecl->abstractType()->whichType() != AbstractType::TypeStructure) ) {
qCritical(KDEV_PYTHON_CODECOMPLETION) << "ERROR: could not get declaration data, not executing completion item!";
return;
}
QString suffix = "()";
KTextEditor::Range checkPrefix(word.start().line(), 0, word.start().line(), word.start().column());
KTextEditor::Range checkSuffix(word.end().line(), word.end().column(), word.end().line(), document->lineLength(word.end().line()));
if ( m_doNotCall || document->text(checkSuffix).trimmed().startsWith('(')
|| document->text(checkPrefix).trimmed().endsWith('@')
|| (functionDecl && Helper::findDecoratorByName(functionDecl, QLatin1String("property"))) )
{
// don't insert brackets if they're already there,
// the item is a decorator, or if it's an import item.
suffix.clear();
}
// place cursor behind bracktes by default
int skip = 2;
if ( functionDecl ) {
bool needsArguments = false;
int argumentCount = functionDecl->type<FunctionType>()->arguments().length();
if ( functionDecl->context()->type() == KDevelop::DUContext::Class ) {
// it's a member function, so it has the implicit self
// TODO static methods
needsArguments = argumentCount > 1;
}
else {
// it's a free function
needsArguments = argumentCount > 0;
}
if ( needsArguments ) {
// place cursor in brackets if there's parameters
skip = 1;
}
}
document->replaceText(word, declaration()->identifier().toString() + suffix);
view->setCursorPosition( Cursor(word.end().line(), word.end().column() + skip) );
}
Node<MemberNode>::Link TypeParser::member(Visibility vis, bool isStatic) {
Trace mbTrace = current().trace;
auto parsedAsDecl = declaration();
auto mbNode = Node<MemberNode>::make(parsedAsDecl->getIdentifier(), parsedAsDecl->getTypeInfo().getEvalTypeList(), isStatic, vis == INVALID ? PRIVATE : vis);
mbNode->setTrace(mbTrace);
if (parsedAsDecl->getChildren().size() > 0) mbNode->setInit(Node<ExpressionNode>::staticPtrCast(parsedAsDecl->removeChild(0)));
return mbNode;
}
void declarations(void){
if(lookahead == CHAR || lookahead == INT){
declaration();
declarations();
}
}
static
void
exec(const Ast *ast) {
//printf("executing "); pn(ast);
Value *v;
switch(ast->class) {
case N_BLOCK:
block(ast);
return;
case N_IF:
ifstat(ast);
return;
case N_WHILE:
whilestat(ast);
return;
case N_DECLARATION:
declaration(ast);
return;
case N_FUNCTION:
return;
case N_RETURN:
returnstat(ast);
return;
case N_CALL:
case N_ASSIGNMENT:
case N_IDENTIFIER:
case N_NEG:
case N_NOT:
case N_EQ:
case N_NEQ:
case N_AND:
case N_IOR:
case N_XOR:
case N_LT:
case N_LE:
case N_GE:
case N_GT:
case N_ADD:
case N_SUB:
case N_MUL:
case N_DIV:
case N_POW:
case N_MOD:
case N_BOOLEAN:
case N_INTEGER:
case N_FLOAT:
case N_STRING:
case N_SET:
case N_R:
v = eval(ast);
//do { print_tree(2, ast); dprintf(2, " evaluates to "); pv(v); } while(0);
value_free(v);
return;
}
printf("EXECFAIL %d ", ast->class); pn(ast);
assert(false && "should not be reached");
}
TOKEN declaration_list(SYMBOL s)
{
TOKEN dec_list = declaration(s);
if( dec_list != NULL)
{
//FIXME this might be a bug, but I'm not sure yet
set_token_link(dec_list, declaration_list(s));
}
return dec_list;
}
double statement(){
Token t = ts.get();
switch(t.kind){
case let:
return declaration(); // 変数の宣言
default:
ts.putback(t);
return expression();
}
}
// トークンが"let"であればDecleartion
// それ以外であればExpressionとして処理
double statement()
{
Token t = ts.get();
switch(t.kind) {
case let:
return declaration();
default:
ts.unget(t);
return expression();
}
}
double statement(Token_stream& ts)
{
Token t = ts.get();
switch (t.kind) {
case let:
return declaration(ts);
default:
ts.putback(t);
return expression(ts);
}
}
/*=============================================================================
-- Returns true if the token is a declaration (#declaration).
=============================================================================*/
bool HMLFile::TokenIsDeclaration(String dec)
{
//add the # if it isn't already there
String declaration(dec);
if (declaration[0] != "#")
declaration.Insert("#", 0);
if (GetToken() == declaration.GetStd())
return true;
return false;
}
double statement()
{
Token t = ts.get();
switch (t.kind)
{
case LET: // how to get a token that is more than 1 characters long
return declaration();
default:
ts.putback(t);
return expression();
}
}
