Пример #1
0
        bool Context<T>::isValueAvailable(int idx) {
            auto var = ensureVariable(idx);

            if (var->variableType() == VariableType::NDARRAY) {
                return var->getNDArray() != nullptr;
            } else if (var->variableType() == VariableType::ARRAY_LIST) {
                return var->getNDArrayList() != nullptr;
            }

            return false;
        }
Пример #2
0
void SetFieldValueAST::generateCode(CodeGenerator& codeGen, GeneratedFunction& func) {
	auto& checker = codeGen.typeChecker();

	std::shared_ptr<ClassType> objRefType;

	if (auto varRef = std::dynamic_pointer_cast<VariableReferenceExpressionAST>(mObjectRefExpression)) {
		auto varSymbol = std::dynamic_pointer_cast<VariableSymbol>(mSymbolTable->find(varRef->name()));
		objRefType = std::dynamic_pointer_cast<ClassType>(checker.findType(varSymbol->variableType()));
	} else if (auto arrayRef = std::dynamic_pointer_cast<ArrayAccessAST>(mObjectRefExpression)) {
		objRefType = std::dynamic_pointer_cast<ClassType>(arrayRef->expressionType(checker));
	}

	auto memberName = getMemberName();

	if (auto arrayMember = std::dynamic_pointer_cast<ArrayAccessAST>(mMemberExpression)) {
		mObjectRefExpression->generateCode(codeGen, func);
		func.addInstruction("LDFIELD " + objRefType->vmClassName() + "::" + memberName);
		arrayMember->accessExpression()->generateCode(codeGen, func);

		mRightHandSide->generateCode(codeGen, func);
		func.addInstruction("STELEM " + mRightHandSide->expressionType(codeGen.typeChecker())->vmType());
	} else {
		mObjectRefExpression->generateCode(codeGen, func);
		mRightHandSide->generateCode(codeGen, func);
		func.addInstruction("STFIELD " + objRefType->vmClassName() + "::" + memberName);
	}
}
Пример #3
0
void MemberAccessAST::typeCheck(TypeChecker& checker) {
	mAccessExpression->typeCheck(checker);

	if (auto varRef = std::dynamic_pointer_cast<VariableReferenceExpressionAST>(mAccessExpression)) {
		auto varSymbol = std::dynamic_pointer_cast<VariableSymbol>(mSymbolTable->find(varRef->name()));
		auto varRefType = checker.findType(varSymbol->variableType());

		std::string memberName = getMemberName();
		std::string objName = varRefType->name();

		if (std::dynamic_pointer_cast<ArrayType>(varRefType)) {
			objName = "Array";
		}

		if (!checker.objectExists(objName)) {
			checker.typeError(varRefType->name() + " is not an object type.");
		}

		auto& object = checker.getObject(objName);

		if (!object.fieldExists(memberName)) {
			checker.typeError("There exists no field '" + memberName + "' in the type '" + varRefType->name() + "'.");
		}

		if (auto arrayMember = std::dynamic_pointer_cast<ArrayAccessAST>(mMemberExpression)) {
			arrayMember->accessExpression()->typeCheck(checker);
		}
	}
}
Пример #4
0
void MemberCallExpressionAST::typeCheck(TypeChecker& checker) {
	mAccessExpression->typeCheck(checker);

	if (auto varRef = std::dynamic_pointer_cast<VariableReferenceExpressionAST>(mAccessExpression)) {
		auto varSymbol = std::dynamic_pointer_cast<VariableSymbol>(mSymbolTable->find(varRef->name()));
		auto varRefType = checker.findType(varSymbol->variableType());

		std::string objName = varRefType->name();

		if (!checker.objectExists(objName)) {
			checker.typeError(varRefType->name() + " is not an object type.");
		}

		auto classSymbol = std::dynamic_pointer_cast<ClassSymbol>(Helpers::findSymbolInNamespace(mSymbolTable, objName));
		mMemberCallExpression->setCallTable(classSymbol->symbolTable());
		mMemberCallExpression->generateSymbols(checker.binder(), mSymbolTable);
		mMemberCallExpression->typeCheck(checker);
	} else {
		auto varRefType = mAccessExpression->expressionType(checker);

		std::string objName = varRefType->name();

		if (!checker.objectExists(objName)) {
			checker.typeError(varRefType->name() + " is not an object type.");
		}

		auto classSymbol = std::dynamic_pointer_cast<ClassSymbol>(Helpers::findSymbolInNamespace(mSymbolTable, objName));
		mMemberCallExpression->setCallTable(classSymbol->symbolTable());
		mMemberCallExpression->generateSymbols(checker.binder(), mSymbolTable);
		mMemberCallExpression->typeCheck(checker);
	}
}
Пример #5
0
const Object& SetFieldValueAST::getObject(const TypeChecker& checker) const {
	std::shared_ptr<Type> objRefType;

	if (auto varRef = std::dynamic_pointer_cast<VariableReferenceExpressionAST>(mObjectRefExpression)) {
		auto varSymbol = std::dynamic_pointer_cast<VariableSymbol>(mSymbolTable->find(varRef->name()));
		objRefType = checker.findType(varSymbol->variableType());
	} else if (auto arrayRef = std::dynamic_pointer_cast<ArrayAccessAST>(mObjectRefExpression)) {
		objRefType = arrayRef->expressionType(checker);
	}

	return checker.getObject(objRefType->name());
}
Пример #6
0
const Object& MemberAccessAST::getObject(const TypeChecker& checker) const {
	std::shared_ptr<Type> varRefType = nullptr;

	if (auto varRef = std::dynamic_pointer_cast<VariableReferenceExpressionAST>(mAccessExpression)) {
		auto varSymbol = std::dynamic_pointer_cast<VariableSymbol>(mSymbolTable->find(varRef->name()));
		varRefType = checker.findType(varSymbol->variableType());
	} else {
		varRefType = mAccessExpression->expressionType(checker);
	}

	std::string objName = varRefType->name();

	if (std::dynamic_pointer_cast<ArrayType>(varRefType)) {
		objName = "Array";
	}

	return checker.getObject(objName);
}
Пример #7
0
void SetFieldValueAST::typeCheck(TypeChecker& checker) {
	mObjectRefExpression->typeCheck(checker);

	std::shared_ptr<Type> objRefType;

	if (auto varRef = std::dynamic_pointer_cast<VariableReferenceExpressionAST>(mObjectRefExpression)) {
		auto varSymbol = std::dynamic_pointer_cast<VariableSymbol>(mSymbolTable->find(varRef->name()));
		objRefType = checker.findType(varSymbol->variableType());
	} else if (auto arrayRef = std::dynamic_pointer_cast<ArrayAccessAST>(mObjectRefExpression)) {
		objRefType = arrayRef->expressionType(checker);
	} else {
		checker.typeError("Not implemented");
	}

	auto memberName = getMemberName();
	std::string objName = objRefType->name();

	if (!checker.objectExists(objName)) {
		checker.typeError(objRefType->name() + " is not an object type.");
	}

	auto& object = checker.getObject(objName);

	if (!object.fieldExists(memberName)) {
		checker.typeError("There exists no field '" + memberName + "' in the type '" + objRefType->name() + "'.");
	}

	mRightHandSide->typeCheck(checker);

	//Check rhs
	std::shared_ptr<Type> fieldType;

	if (std::dynamic_pointer_cast<ArrayAccessAST>(mMemberExpression)) {
		fieldType = std::dynamic_pointer_cast<ArrayType>(object.getField(memberName).type())->elementType();
	} else {
		fieldType = object.getField(memberName).type();
	}

	checker.assertSameType(
		*fieldType,
		*mRightHandSide->expressionType(checker),
		asString());
}
Пример #8
0
TIntermSymbol *MakeNewTemporary(const TString &name, TBasicType type)
{
    TType variableType(type, EbpHigh, EvqInternal);
    return new TIntermSymbol(-1, name, variableType);
}
Пример #9
0
ProblemInstance::ProblemInstance (RPHandle hndl, SharedPtr<ReaderPluginFunctionTable> functions)
	: handle(hndl), ftable(functions)
{
	int i;
	m_variables = ftable->variables(handle);
	m_constraints = ftable->constraints(handle);
	m_objectives  = ftable->objectives(handle);

	m_variableTypes = new char[variables()+2*constraints()+2*objectives()];
	m_functionTypes = &m_variableTypes[variables()];
	m_constraintTypes = &m_functionTypes[constraints()+objectives()];
	m_objectiveTypes = &m_constraintTypes[constraints()];
	for (i = 0; i < variables(); ++i)
	{
		m_variableTypes[i] = ftable->variableType(handle, i);
	}
	for (i = 0; i < constraints(); ++i)
	{
		m_functionTypes[i] = ftable->functionType(handle, 'c', i);
	}
	for (i = 0; i < objectives(); ++i)
	{
        m_functionTypes[constraints()+i] = ftable->functionType(handle, 'o', i);
	}
	for (i = 0; i < constraints(); ++i)
	{
		m_constraintTypes[i] = ftable->constraintType(handle, i);
	}
	for (i = 0; i < objectives(); ++i)
	{
		m_objectiveTypes[i] = ftable->objectiveType(handle, i);
	}

	int* tmp = new int[std::max(objectives()+constraints()+2, variables())];
	m_presenceIndexes = new unsigned[2*variables()+constraints()+objectives()];
	for (i = 0; i < variables(); ++i)
	{
		ftable->variablePresence(handle, i, tmp, &tmp[constraints()]);
		m_presences.reserve(m_presences.size()+2+tmp[0]+tmp[constraints()]);
		varConstrPresenceIndex(i) = m_presences.size();
		m_presences.insert(m_presences.end(), tmp, &tmp[tmp[0]+1]);
		varObjPresenceIndex(i) = m_presences.size();
		m_presences.insert(m_presences.end(), &tmp[constraints()], &tmp[constraints()+tmp[constraints()]+1]);
	}

	m_variableCounts = new int[4*(constraints()+objectives())];
	std::fill(m_variableCounts, &m_variableCounts[4*(constraints()+objectives())], 0);
	for (i = 0; i < constraints(); ++i)
	{
		int vars = ftable->constraintVariables(handle, i, tmp);
		m_presences.reserve(m_presences.size()+1+vars);
		constraintPresenceIndex(i) = m_presences.size();
		m_presences.push_back(vars);
		m_presences.insert(m_presences.end(), tmp, &tmp[vars]);

		unsigned offset = 4*i;
		m_variableCounts[offset] = vars;
		for (int j = 0; j < vars; ++j)
		{
			switch (variableType(tmp[j])) {
				case 'r': ++m_variableCounts[offset+1]; break;
				case 'b': ++m_variableCounts[offset+2]; break;
				case 'i': ++m_variableCounts[offset+3]; break;
			}
		}
	}

	for (i = 0; i < objectives(); ++i)
	{
		int vars = ftable->objectiveVariables(handle, i, tmp);
		m_presences.reserve(m_presences.size()+1+vars);
		objectivePresenceIndex(i) = m_presences.size();
		m_presences.push_back(vars);
		m_presences.insert(m_presences.end(), tmp, &tmp[vars]);

		unsigned offset = 4*(constraints()+i);
		m_variableCounts[offset] = vars;
		for (int j = 0; j < vars; ++j)
		{
			switch (variableType(tmp[j])) {
				case 'r': ++m_variableCounts[offset+1]; break;
				case 'b': ++m_variableCounts[offset+2]; break;
				case 'i': ++m_variableCounts[offset+3]; break;
			}
		}
	}
	delete [] tmp;

	m_varBounds = new Real[2*(variables()+constraints())];
	m_constrBounds = &m_varBounds[2*variables()];

	for (i = 0; i < variables(); ++i)
	{
		ftable->variableBounds(handle, i, &m_varBounds[2*i], &m_varBounds[2*i+1]);
	}

	for (i = 0; i < constraints(); ++i)
	{
		ftable->constraintBounds(handle, i, &m_constrBounds[2*i], &m_constrBounds[2*i+1]);
		switch (constraintType(i)) {
			case 'l':
				m_constrBounds[2*i] = -std::numeric_limits<Real>::infinity();
				break;
			case 'g':
				m_constrBounds[2*i+1] = std::numeric_limits<Real>::infinity();
				break;
			case 'e':
				m_constrBounds[2*i] = m_constrBounds[2*i+1];
				break;
			case 'u':
				m_constrBounds[2*i] = -std::numeric_limits<Real>::infinity();
				m_constrBounds[2*i+1] = std::numeric_limits<Real>::infinity();
				break;
			default:
				break;
		}
	}

	latestErrorType = 0;
}