Beispiel #1
0
//while-condition -> expression  declaration
ExpressionPtr Parser::parseConditionExpression()
{
    Token token;
    expect_next(token);
    if(token.type == TokenType::Identifier && token.identifier.keyword != Keyword::_)
    {
        Keyword::T keyword = token.identifier.keyword;
        tassert(token, keyword == Keyword::Var || keyword == Keyword::Let, Errors::E_EXPECTED_EXPRESSION_VAR_OR_LET_IN_A_CONDITION_1, L"if");
        ValueBindingPatternPtr value = nodeFactory->createValueBindingPattern(token.state);
        value->setReadOnly(keyword == Keyword::Let);
        PatternPtr binding = parsePattern();
        value->setBinding(binding);
        if(binding->getNodeType() == NodeType::TypedPattern)
        {
            TypedPatternPtr tpattern = std::static_pointer_cast<TypedPattern>(binding);
            value->setBinding(tpattern->getPattern());
            value->setDeclaredType(tpattern->getDeclaredType());
        }
        if (!match(L"=", token))
        {
            tassert(token, false, Errors::E_VARIABLE_BINDING_IN_A_CONDITION_REQUIRES_AN_INITIALIZER);
        }
        AssignmentPtr assignment = nodeFactory->createAssignment(token.state);
        ExpressionPtr expr = parseExpression();
        assignment->setLHS(value);
        assignment->setRHS(expr);
        return assignment;
    }
    else
    {
        restore(token);
        return parseExpression();
    }
}
Beispiel #2
0
ValueBindingPtr Parser::parseVariableDeclaration()
{
    Token token;
    Attributes attrs;
    
    PatternPtr key = parsePattern();
    TypeNodePtr type = NULL;
    ExpressionPtr val = NULL;
    if(match(L":"))
    {
        type = parseTypeAnnotation();
    }
    if(match(L"="))
    {
        Flags flags(this, SUPPRESS_TRAILING_CLOSURE);
        val = parseExpression();
    }
    ValueBindingPtr ret = nodeFactory->createValueBinding(*key->getSourceInfo());
    if(TypedPatternPtr p = std::dynamic_pointer_cast<TypedPattern>(key))
    {
        ret->setName(p->getPattern());
        ret->setDeclaredType(p->getDeclaredType());
    }
    else
    {
        ret->setName(key);
        ret->setDeclaredType(type);
    }
    ret->setTypeAttributes(attrs);
    ret->setInitializer(val);
    return ret;
}
/*
  GRAMMAR OF A CONSTANT DECLARATION
 
 ‌ constant-declaration → attributes opt declaration-specifiers opt let pattern-initializer-list
 ‌ pattern-initializer-list → pattern-initializer | pattern-initializer,pattern-initializer-list
 ‌ pattern-initializer → pattern initializer opt
 ‌ initializer → =expression
*/
DeclarationPtr Parser::parseLet(const std::vector<AttributePtr>& attrs, int specifiers)
{
    Token token;
    Flags flag(this, UNDER_LET);
    expect(Keyword::Let, token);
    ValueBindingsPtr ret = nodeFactory->createValueBindings(token.state);
    ret->setReadOnly(true);
    ret->setAttributes(attrs);
    ret->setSpecifiers(specifiers);
    do
    {
        PatternPtr pattern = parsePattern();
        ExpressionPtr initializer = NULL;
        if(match(L"="))
        {
            initializer = parseExpression();
        }

        ValueBindingPtr constant = nodeFactory->createValueBinding(*pattern->getSourceInfo());
        constant->setAttributes(attrs);
        constant->setSpecifiers(specifiers);
        constant->setName(pattern);
        TypedPatternPtr typedPattern = std::dynamic_pointer_cast<TypedPattern>(pattern);
        if(typedPattern)
        {
            //promote typed pattern
            constant->setDeclaredType(typedPattern->getDeclaredType());
            constant->setName(typedPattern->getPattern());
        }
        constant->setInitializer(initializer);
        ret->add(constant);
    }while(match(L","));
    return ret;
}
Beispiel #4
0
static void initVariantInstance(InstancePtr x) {
    EnvPtr env = new Env(x->env);
    const vector<PatternVar> &pvars = x->patternVars;
    for (unsigned i = 0; i < pvars.size(); ++i) {
        if (pvars[i].isMulti) {
            MultiPatternCellPtr cell = new MultiPatternCell(NULL);
            addLocal(env, pvars[i].name, cell.ptr());
        }
        else {
            PatternCellPtr cell = new PatternCell(NULL);
            addLocal(env, pvars[i].name, cell.ptr());
        }
    }
    PatternPtr pattern = evaluateOnePattern(x->target, env);
    ObjectPtr y = derefDeep(pattern);
    if (y.ptr()) {
        if (y->objKind != TYPE)
            error(x->target, "not a variant type");
        Type *z = (Type *)y.ptr();
        if (z->typeKind != VARIANT_TYPE)
            error(x->target, "not a variant type");
        VariantType *vt = (VariantType *)z;
        vt->variant->instances.push_back(x);
    }
    else {
        if (pattern->kind != PATTERN_STRUCT)
            error(x->target, "not a variant type");
        PatternStruct *ps = (PatternStruct *)pattern.ptr();
        if ((!ps->head) || (ps->head->objKind != VARIANT))
            error(x->target, "not a variant type");
        Variant *v = (Variant *)ps->head.ptr();
        v->instances.push_back(x);
    }
}
Beispiel #5
0
void EventHandler::processPattern_mergeTracks(const ConstMusicPtr& music,
        const PatternPtr& pattern, unsigned int patternIndex)
{
    // Merge all the tracks together into one big track, with all events in
    // chronological order
    std::list<MergedEvent> full;

    unsigned int trackIndex = 0;
    // For each track
    for (Pattern::const_iterator
            pt = pattern->begin(); pt != pattern->end(); pt++, trackIndex++
        ) {
        std::list<MergedEvent> ltrack;

        unsigned long trackTime = 0;
        // For each event in the track
        for (Track::const_iterator
                ev = (*pt)->begin(); ev != (*pt)->end(); ev++
            ) {
            const TrackEvent& te = *ev;
            // If this assertion is thrown, it's because the format reader or
            // some processing function got events out of order.  They must be
            // chronological.
            trackTime += te.delay;
            MergedEvent mevent(te.event);
            mevent.absTime = trackTime;
            mevent.trackIndex = trackIndex;
            ltrack.push_back(mevent);
        }
        // Merge in with master list
        full.merge(ltrack, trackMergeByTime);
    }

    unsigned long trackTime = 0;
    // Now run through the master list, which has all events sorted
    for (std::list<MergedEvent>::const_iterator
            fev = full.begin(); fev != full.end(); fev++
        ) {
        const MergedEvent& me = *fev;
        unsigned long deltaTime = me.absTime - trackTime;
        trackTime = me.absTime;
        me.event->processEvent(deltaTime, me.trackIndex, patternIndex, this);
    }
    assert(trackTime <= music->ticksPerTrack);
    this->endOfPattern(music->ticksPerTrack - trackTime);
    return;
}
Beispiel #6
0
void patternPrint(llvm::raw_ostream &out, PatternPtr x)
{
    switch (x->kind) {
    case PATTERN_CELL : {
        PatternCell *y = (PatternCell *)x.ptr();
        out << "PatternCell(" << y->obj << ")";
        break;
    }
    case PATTERN_STRUCT : {
        PatternStruct *y = (PatternStruct *)x.ptr();
        out << "PatternStruct(" << y->head << ", " << y->params << ")";
        break;
    }
    default :
        assert(false);
    }
}
Beispiel #7
0
void EventHandler::processPattern_separateTracks(const ConstMusicPtr& music,
        const PatternPtr& pattern, unsigned int patternIndex)
{
    unsigned int trackIndex = 0;
    unsigned long maxTrackTime = 0;
    // For each track
    for (Pattern::const_iterator
            pt = pattern->begin(); pt != pattern->end(); pt++, trackIndex++
        ) {
        unsigned long trackTime = 0;
        // For each event in the track
        for (Track::const_iterator
                ev = (*pt)->begin(); ev != (*pt)->end(); ev++
            ) {
            const TrackEvent& te = *ev;
            trackTime += te.delay;
            te.event->processEvent(te.delay, trackIndex, patternIndex, this);
        }
        if (trackTime > maxTrackTime) maxTrackTime = trackTime;
        this->endOfTrack(music->ticksPerTrack - trackTime);
    }
    this->endOfPattern(music->ticksPerTrack - maxTrackTime);
    return;
}
void SemanticAnalyzer::visitValueBinding(const ValueBindingPtr& node)
{
    PatternPtr name = node->getName();
    //tuple was already exploded in declaration analyzer
    if(name->getNodeType() == NodeType::Tuple)
    {
        validateTupleTypeDeclaration(node);
    }
    if (name->getNodeType() != NodeType::Identifier)
        return;
    if(node->getOwner()->isReadOnly() && !node->getInitializer() && ctx->currentType == nullptr)
    {
        error(node, Errors::E_LET_REQUIRES_INITIALIZER);
        return;
    }
    //handle type inference for temporary variable
    if(node->isTemporary() && node->getInitializer())
    {
        //temporary variable always has an initializer
        TypePtr initializerType;
        TypePtr declaredType = node->getType();

        SCOPED_SET(ctx->contextualType, declaredType);
        node->getInitializer()->accept(this);
        initializerType = node->getInitializer()->getType();
        assert(initializerType != nullptr);

        if(declaredType)
        {
            //it has both type definition and initializer, then we need to check if the initializer expression matches the type annotation
            if(!initializerType->canAssignTo(declaredType))
            {
                error(node, Errors::E_CANNOT_CONVERT_EXPRESSION_TYPE_2, initializerType->toString(), declaredType->toString());
                return;
            }
        }
        else
        {
            node->setType(initializerType);
        }
    }
    

    //add implicitly constructor for Optional
    IdentifierPtr id = static_pointer_cast<Identifier>(node->getName());
    SymbolScope* currentScope = symbolRegistry->getCurrentScope();


    TypePtr declaredType = node->getType() ? node->getType() : lookupType(node->getDeclaredType());
    SCOPED_SET(ctx->contextualType, declaredType);
    if(!declaredType && !node->getInitializer())
    {
        error(node, Errors::E_TYPE_ANNOTATION_MISSING_IN_PATTERN);
        return;
    }
    SymbolPtr sym = currentScope->lookup(id->getIdentifier());
    assert(sym != nullptr);
    SymbolPlaceHolderPtr placeholder = std::dynamic_pointer_cast<SymbolPlaceHolder>(sym);
    assert(placeholder != nullptr);
    if(declaredType)
    {
        placeholder->setType(declaredType);
    }
    ExpressionPtr initializer = node->getInitializer();
    if(initializer)
    {
        placeholder->setFlags(SymbolFlagInitializing, true);
        ExpressionPtr initializer = transformExpression(declaredType, node->getInitializer());
        node->setInitializer(initializer);
        TypePtr actualType = initializer->getType();
        assert(actualType != nullptr);
        if(declaredType)
        {
            if(!Type::equals(actualType, declaredType) && !canConvertTo(initializer, declaredType))
            {
                error(initializer, Errors::E_CANNOT_CONVERT_EXPRESSION_TYPE_2, actualType->toString(), declaredType->toString());
                return;
            }
        }

        if(!declaredType)
            placeholder->setType(actualType);
    }
    assert(placeholder->getType() != nullptr);
    placeholder->setFlags(SymbolFlagInitializing, false);
    //optional type always considered initialized, compiler will make it has a default value nil
    TypePtr symbolType = sym->getType();
    GlobalScope* global = symbolRegistry->getGlobalScope();
    if(initializer || global->isOptional(symbolType) || global->isImplicitlyUnwrappedOptional(symbolType))
        markInitialized(placeholder);

    if (initializer)
        placeholder->setFlags(SymbolFlagHasInitializer, true);
    if(node->isTemporary())
    {
        placeholder->setFlags(SymbolFlagTemporary, true);
        markInitialized(placeholder);
    }

    if(!node->isTemporary())
    {
        //check access control level
        DeclarationType decl = ctx->currentType ? DeclarationTypeProperty : DeclarationTypeVariable;
        declarationAnalyzer->verifyAccessLevel(node->getOwner(), placeholder->getType(), decl, ComponentTypeType);
    }
    if(ctx->currentType && ctx->currentType->getCategory() == Type::Protocol)
    {
        error(node, Errors::E_PROTOCOL_VAR_MUST_BE_COMPUTED_PROPERTY_1);
    }
}
void SemanticAnalyzer::validateTupleTypeDeclaration(const PatternPtr& name, const TypePtr& declType, const TypePtr& initType)
{
    switch(name->getNodeType())
    {
        case NodeType::Identifier:
        {
            if(initType && declType && !initType->canAssignTo(declType))
            {
                error(name, Errors::E_CANNOT_CONVERT_EXPRESSION_TYPE_2, initType->toString(), declType->toString());
            }
            break;
        }
        case NodeType::TypedPattern:
        {
            TypedPatternPtr pat = static_pointer_cast<TypedPattern>(name);
            assert(pat->getDeclaredType());
            TypePtr nameType = lookupType(pat->getDeclaredType());
            assert(nameType != nullptr);
            if(declType && !Type::equals(nameType, declType))
            {
                error(name, Errors::E_TYPE_ANNOTATION_DOES_NOT_MATCH_CONTEXTUAL_TYPE_A_1, declType->toString());
                abort();
                return;
            }

            break;
        }
        case NodeType::Tuple:
        {
            TuplePtr tuple = static_pointer_cast<Tuple>(name);
            if(declType)
            {
                if((declType->getCategory() != Type::Tuple) || (tuple->numElements() != declType->numElementTypes()))
                {
                    error(name, Errors::E_TYPE_ANNOTATION_DOES_NOT_MATCH_CONTEXTUAL_TYPE_A_1, declType->toString());
                    abort();
                    return;
                }
            }
            int elements = tuple->numElements();
            for(int i = 0; i < elements; i++)
            {
                PatternPtr element = tuple->getElement(i);
                TypePtr elementDecl = declType ? declType->getElementType(i) : nullptr;
                TypePtr elementInit = initType ? initType->getElementType(i) : nullptr;
                validateTupleTypeDeclaration(element, elementDecl, elementInit);
            }
            break;
        }
        case NodeType::ValueBindingPattern:
            break;
        case NodeType::EnumCasePattern:
        {
            
            break;
        }
        case NodeType::TypeCase:
        case NodeType::TypeCheck:
        default:
            error(name, Errors::E_EXPECT_TUPLE_OR_IDENTIFIER);
            break;
    }
    
}