Function ParseSelectType

NULLC/Parser.cpp:396–588

allowArray allows parsing of array types. It is disabled when parsing a type for "new" expression allowGenericType is used in parsing of generic function declaration, it allows parts of types to be "generic" allowGenericBase is used for parsing of external generic type member function definitions so that a function can be applied to all generic type instances allowExtendedTypeof is used to allow e

// instanceType is used when semi-instancing a generic function to resolve "generic" types to real types
// instanceFailure is a variable that signals if failure was during instancing, so we have to silent the error
bool ParseSelectType(Lexeme** str, bool allowArray, bool allowGenericType, bool allowGenericBase, bool allowExtendedTypeof, TypeInfo* instanceType, bool* instanceFailure)
{
	// If instance type is passed, we must remove array and pointer qualifiers and strip function type of its arguments
	TypeInfo *strippedType = instanceType;
	if(instanceType)
	{
		assert(instanceFailure);
		// remove array and pointer qualifiers
		while(strippedType->refLevel || strippedType->arrLevel)
			strippedType = strippedType->subType;
	}
	bool notType = false;
	if((*str)->type == lex_typeof)
	{
		(*str)++;
		if(!ParseLexem(str, lex_oparen))
			ThrowError((*str)->pos, "ERROR: typeof must be followed by '('");

		unsigned nodeCount = CodeInfo::nodeList.size();
		Lexeme *curr = *str;
		bool isType = ParseSelectType(str);
		if(!isType || (*str)->type != lex_cparen)
		{
			// If ParseSelectType parser extended type expression that returned a number, remove that number
			if(isType && CodeInfo::nodeList.size() == nodeCount + 1)
				CodeInfo::nodeList.pop_back();
			*str = curr;
			jmp_buf oldHandler;
			memcpy(oldHandler, CodeInfo::errorHandler, sizeof(jmp_buf));
			if(!allowGenericType || !setjmp(CodeInfo::errorHandler)) // if allowGenericType is enabled, we will set error handler
			{
				if(!ParseVaribleSet(str))
					ThrowError((*str)->pos, "ERROR: expression not found after typeof(");
				SetTypeOfLastNode();
			}else{
				// Node count shouldn't change while we did this
				if(!FunctionGeneric(false) || nodeCount != CodeInfo::nodeList.size())
				{
					memcpy(CodeInfo::errorHandler, oldHandler, sizeof(jmp_buf));
					longjmp(CodeInfo::errorHandler, 1);
				}
				SelectTypeByPointer(typeGeneric);
			}
			if(allowGenericType)
				memcpy(CodeInfo::errorHandler, oldHandler, sizeof(jmp_buf));
		}else if(!GetSelectedType()){
			ThrowError((*str)->pos, "ERROR: cannot take typeid from auto type");
		}else{
			// If there was a node pushed during type selection because of extended typeof expressions, get its type
			if(CodeInfo::nodeList.size() == nodeCount + 1)
				SetTypeOfLastNode();
		}
		if(!ParseLexem(str, lex_cparen))
			ThrowError((*str)->pos, "ERROR: ')' not found after expression in typeof");
		while(ParseTypeofExtended(str, notType));
	}else if((*str)->type == lex_auto){
		SelectTypeByPointer(NULL);
		(*str)++;