Exemple #1
0
IndexedTypeIdentifier typeIdentifierFromTemplateArgument(ParseSession* session, TemplateArgumentAST *node)
{
  IndexedTypeIdentifier id;
  if(node->expression) {
    id = IndexedTypeIdentifier(session->stringForNode(node), true);
  }else if(node->type_id) {
    //Parse the pointer operators
    TypeCompiler tc(session);
    tc.run(node->type_id->type_specifier);
    id = IndexedTypeIdentifier(tc.identifier());
    //node->type_id->type_specifier->cv
    
    if(node->type_id->type_specifier)
      id.setIsConstant(parseConstVolatile(session, node->type_id->type_specifier->cv) & AbstractType::ConstModifier);
    
    if(node->type_id->declarator && node->type_id->declarator->ptr_ops)
    {
      const ListNode<PtrOperatorAST*> *it = node->type_id->declarator->ptr_ops->toFront();
      const ListNode<PtrOperatorAST*> *end = it; ///@todo check ordering, eventually walk the list in reversed order
      do
        {
          if(it->element && it->element->op) { ///@todo What about ptr-to-member?
            int kind = session->token_stream->kind(it->element->op);
            if(kind == '&') {
              //We're handling a 'reference'
              id.setIsReference(true);
            } else if(kind == Token_and) {
              //We're handling an rvalue-reference
              id.setIsReference(true);
              id.setIsRValue(true);
            } else {
              //We're handling a real pointer
              id.setPointerDepth(id.pointerDepth()+1);

              if(it->element->cv) {
                id.setIsConstPointer(id.pointerDepth()-1, parseConstVolatile(session, it->element->cv) & AbstractType::ConstModifier);
              }
            }
          }
          it = it->next;
        }
      while (it != end);
    } else if (node->type_id->declarator && node->type_id->declarator->array_dimensions) {
      ///FIXME: find a way to put this information into the identifier
      ///       e.g.: id.setArrayDepth(id.arrayDepth() + 1) ?
      const ListNode< ExpressionAST* >* it = node->type_id->declarator->array_dimensions->toFront();
      const ListNode< ExpressionAST* >* end = node->type_id->declarator->array_dimensions-> toBack();
      do {
        QualifiedIdentifier qid = id.identifier();
        Identifier last = qid.last();
        qid.pop();
        last.setIdentifier(last.toString() + "[]");
        qid.push(last);
        id.setIdentifier(IndexedQualifiedIdentifier( qid ));
        it = it->next;
      } while (it != end);
    }
  }
  return id;
}