view release on metacpan or  search on metacpan

generator/parser/parser.cpp  view on Meta::CPAN

        case Token_bool:
        case Token_short:
        case Token_int:
        case Token_long:
        case Token_signed:
        case Token_unsigned:
        case Token_float:
        case Token_double:
        case Token_void:
        case Token_class:
        case Token_struct:
        case Token_union:
        case Token_enum:
        case Token_scope:
        case Token_template:
        case Token_using:
          return true;

        default:
          advance();
        }
    }

  return false;
}

bool Parser::skip(int l, int r)
{
  int count = 0;
  while (session->token_stream->lookAhead())
    {
      int tk = session->token_stream->lookAhead();

      if (tk == l)
        ++count;
      else if (tk == r)
        --count;
      else if (l != '{' && (tk == '{' || tk == '}' || tk == ';'))
        return false;

      if (count == 0)
        return true;

      advance();
    }

  return false;
}

bool Parser::parseName(NameAST*& node, ParseNameAcceptTemplate acceptTemplateId)
{
  std::size_t start = session->token_stream->cursor();

  WinDeclSpecAST *winDeclSpec = 0;
  parseWinDeclSpec(winDeclSpec);

  NameAST *ast = CreateNode<NameAST>(session->mempool);

  if (session->token_stream->lookAhead() == Token_scope)
    {
      ast->global = true;
      advance();
    }

  std::size_t idx = session->token_stream->cursor();

  while (true)
    {
      UnqualifiedNameAST *n = 0;
      if (!parseUnqualifiedName(n)) {
        return false;
      }

      if (session->token_stream->lookAhead() == Token_scope)
        {
          advance();

          ast->qualified_names
            = snoc(ast->qualified_names, n, session->mempool);

          if (session->token_stream->lookAhead() == Token_template)
            {
              /// skip optional template     #### @todo CHECK
              advance();
            }
        }
      else
        {
          Q_ASSERT(n != 0);
      
          if (acceptTemplateId == DontAcceptTemplate ||
            //Eventually only accept template parameters as primary expression if the expression is followed by a function call
            (acceptTemplateId == EventuallyAcceptTemplate && n->template_arguments && session->token_stream->lookAhead() != '(' && m_primaryExpressionWithTemplateParamsNeedsFunctionCall))
            {
              rewind(n->start_token);
              parseUnqualifiedName(n, false);
            }

          ast->unqualified_name = n;
          break;
        }
    }

  if (idx == session->token_stream->cursor())
    return false;

  UPDATE_POS(ast, start, _M_last_valid_token+1);
  node = ast;

  return true;
}

bool Parser::parseTranslationUnit(TranslationUnitAST *&node)
{
  _M_problem_count = 0;
  _M_hadMismatchingCompoundTokens = false;

/*  kDebug() << "tokens:";
  for(size_t a = 0; a < session->token_stream->size(); ++a)
    kDebug() << token_name(session->token_stream->token(a).kind) << session->token_stream->token(a).symbolString();*/

generator/parser/parser.cpp  view on Meta::CPAN

  do
    {
      if (list)
        advance(); // skip ',' separator between clauses

      InitializerClauseAST *init_clause = 0;
      if (!parseInitializerClause(init_clause))
        {
          return false;
        }
      list = snoc(list,init_clause,session->mempool);
    } while (session->token_stream->lookAhead() == ',');

  node = list;

  return true;
}

bool Parser::parseInitializerClause(InitializerClauseAST *&node)
{
  std::size_t start = session->token_stream->cursor();

  InitializerClauseAST *ast = CreateNode<InitializerClauseAST>(session->mempool);

  if (session->token_stream->lookAhead() == '{')
    {
      advance();
      const ListNode<InitializerClauseAST*> *initializer_list = 0;
      if (session->token_stream->lookAhead() != '}' &&
              !parseInitializerList(initializer_list))
        {
            return false;
        }
      ADVANCE('}',"}");

      ast->initializer_list = initializer_list;
    }
  else
    {
      if (!parseAssignmentExpression(ast->expression))
        {
          reportError("Expression expected");
          return false;
        }
    }

  UPDATE_POS(ast, start, _M_last_valid_token+1);
  node = ast;

  return true;
}

bool Parser::parsePtrToMember(PtrToMemberAST *&node)
{
#if defined(__GNUC__)
#warning "implemente me (AST)"
#endif

  std::size_t start = session->token_stream->cursor();

  std::size_t global_scope = 0;
  if (session->token_stream->lookAhead() == Token_scope)
    {
      global_scope = session->token_stream->cursor();
      advance();
    }

  UnqualifiedNameAST *name = 0;
  while (session->token_stream->lookAhead() == Token_identifier)
    {
      if (!parseUnqualifiedName(name))
        break;

      if (session->token_stream->lookAhead() == Token_scope
          && session->token_stream->lookAhead(1) == '*')
        {
          advance();
          advance();

          PtrToMemberAST *ast = CreateNode<PtrToMemberAST>(session->mempool);
          UPDATE_POS(ast, start, _M_last_valid_token+1);
          node = ast;

          return true;
        }

      if (session->token_stream->lookAhead() == Token_scope)
        advance();
    }

  rewind(start);
  return false;
}

bool Parser::parseUnqualifiedName(UnqualifiedNameAST *&node,
                                  bool parseTemplateId)
{
  std::size_t start = session->token_stream->cursor();

  std::size_t tilde = 0;
  std::size_t id = 0;
  OperatorFunctionIdAST *operator_id = 0;

  if (session->token_stream->lookAhead() == Token_identifier)
    {
      id = session->token_stream->cursor();
      advance();
    }
  else if (session->token_stream->lookAhead() == '~'
           && session->token_stream->lookAhead(1) == Token_identifier)
    {
      tilde = session->token_stream->cursor();
      advance(); // skip ~

      id = session->token_stream->cursor();
      advance(); // skip classname
    }
  else if (session->token_stream->lookAhead() == Token_operator)
    {
      if (!parseOperatorFunctionId(operator_id))
        return false;
    }
  else
    {