Added while and boolean expression tests for the LLVM compiler. (b7826f0a) · Commits · Vít Starý Novotný / pa037-project

LLVMParser.cpp

+114 −86

Original line number	Original line	Diff line number	Diff line
	@@ -48,13 +48,13 @@ size_t LLVMParser::llvm_store(size_t storage_offset, DataType type)
	assert(type != DT_ARBITRARY);		assert(type != DT_ARBITRARY);
	size_t new_storage_offset = get_next_offset();		size_t new_storage_offset = get_next_offset();
	if (type == DT_INTEGER)		if (type == DT_INTEGER)
	get_current_out() << "%" << new_storage_offset << " = alloca i32, align 4" << std::endl		get_current_out() << "%identifier." << new_storage_offset << " = alloca i32, align 4" << std::endl
	<< "store i32 %" << storage_offset << ", i32* %"		<< "store i32 %identifier." << storage_offset
	<< new_storage_offset << ", align 4" << std::endl;		<< ", i32* %identifier." << new_storage_offset << ", align 4" << std::endl;
	else		else
	get_current_out() << "%" << new_storage_offset << " = alloca double, align 8" << std::endl		get_current_out() << "%identifier." << new_storage_offset << " = alloca double, align 8" << std::endl
	<< "store double %" << storage_offset << ", double* %"		<< "store double %identifier." << storage_offset
	<< new_storage_offset << ", align 8" << std::endl;		<< ", double* %identifier." << new_storage_offset << ", align 8" << std::endl;
	return new_storage_offset;		return new_storage_offset;
	}		}
	size_t LLVMParser::llvm_load(size_t storage_offset, DataType type)		size_t LLVMParser::llvm_load(size_t storage_offset, DataType type)
	@@ -62,10 +62,12 @@ size_t LLVMParser::llvm_load(size_t storage_offset, DataType type)
	assert(type != DT_ARBITRARY);		assert(type != DT_ARBITRARY);
	size_t new_storage_offset = get_next_offset();		size_t new_storage_offset = get_next_offset();
	if (type == DT_INTEGER)		if (type == DT_INTEGER)
	get_current_out() << "%" << new_storage_offset << " = load i32, i32* %"		get_current_out() << "%identifier." << new_storage_offset
			<< " = load i32, i32* %identifier."
	<< storage_offset << ", align 4" << std::endl;		<< storage_offset << ", align 4" << std::endl;
	else		else
	get_current_out() << "%" << new_storage_offset << " = load double, double* %"		get_current_out() << "%identifier." << new_storage_offset
			<< " = load double, double* %identifier."
	<< storage_offset << ", align 8" << std::endl;		<< storage_offset << ", align 8" << std::endl;
	return new_storage_offset;		return new_storage_offset;
	}		}
	@@ -73,11 +75,27 @@ size_t LLVMParser::llvm_coerce_i32_to_double(size_t storage_offset)
	{		{
	size_t loaded_storage_offset = llvm_load(storage_offset, DT_INTEGER);		size_t loaded_storage_offset = llvm_load(storage_offset, DT_INTEGER);
	size_t offset = get_next_offset();		size_t offset = get_next_offset();
	get_current_out() << "%" << offset << " = sitofp i32 %"		get_current_out() << "%identifier." << offset << " = sitofp i32 %identifier."
	<< loaded_storage_offset << " to double" << std::endl;		<< loaded_storage_offset << " to double" << std::endl;
	return llvm_store(offset, DT_DOUBLE);		return llvm_store(offset, DT_DOUBLE);
	}		}

			void LLVMParser::llvm_write_label(size_t label)
			{
			get_current_out() << "label." << label << ":" << std::endl;
			}
			void LLVMParser::llvm_goto(size_t label)
			{
			get_current_out() << "br label %label." << label << std::endl;
			}
			void LLVMParser::llvm_conditional_goto(
			size_t loaded_storage_offset, size_t label_false, size_t label_true)
			{
			get_current_out() << "br i1 %identifier." << loaded_storage_offset
			<< ", label %label." << label_true
			<< ", label %label." << label_false << std::endl;
			}

	void LLVMParser::run()		void LLVMParser::run()
	{		{
	grammar_init();		grammar_init();
	@@ -87,7 +105,6 @@ void LLVMParser::grammar_init()
	{		{
	symbols.push("");		symbols.push("");
	assert(symbols.insert("metadata::return_data_type", { ST_METADATA, { DT_ARBITRARY }, 0 }));		assert(symbols.insert("metadata::return_data_type", { ST_METADATA, { DT_ARBITRARY }, 0 }));
	assert(symbols.insert("metadata::current_offset", { ST_METADATA, { DT_ARBITRARY }, 1 }));
	get_current_out() << "declare i32 @printf(i8*, ...)" << std::endl		get_current_out() << "declare i32 @printf(i8*, ...)" << std::endl
	<< "@.print_integer = private unnamed_addr constant [4 x i8] c\"%d\\0A\\00\", align 1" << std::endl		<< "@.print_integer = private unnamed_addr constant [4 x i8] c\"%d\\0A\\00\", align 1" << std::endl
	<< "@.print_double = private unnamed_addr constant [5 x i8] c\"%lf\\0A\\00\", align 1" << std::endl;		<< "@.print_double = private unnamed_addr constant [5 x i8] c\"%lf\\0A\\00\", align 1" << std::endl;
	@@ -104,11 +121,11 @@ void LLVMParser::grammar_block()
	grammar_variable_declaration_list();		grammar_variable_declaration_list();
	if (symbols.scope_name().empty())		if (symbols.scope_name().empty())
	grammar_callable_declaration_list();		grammar_callable_declaration_list();
	std::string label_next = make_label();		size_t label_next = get_next_label();
	if (symbols.scope_name().empty())		if (symbols.scope_name().empty())
	get_current_out() << "define i32 @main() {" << std::endl;		get_current_out() << "define i32 @main() {" << std::endl;
	grammar_statement_list(label_next);		grammar_statement_list(label_next);
	write_label(label_next);		llvm_write_label(label_next);
	if (symbols.scope_name().empty())		if (symbols.scope_name().empty())
	get_current_out() << "ret i32 0" << std::endl		get_current_out() << "ret i32 0" << std::endl
	<< "}" << std::endl;		<< "}" << std::endl;
	@@ -153,13 +170,15 @@ void LLVMParser::grammar_variable_declaration()
	else		else
	get_current_out() << "double 0.000000e+00, align 8" << std::endl;		get_current_out() << "double 0.000000e+00, align 8" << std::endl;
	} else {		} else {
	get_current_out() << "%" << name_token.term.payload << " = alloca ";		get_current_out() << "%identifier." << name_token.term.payload << " = alloca ";
	if (type == DT_INTEGER)		if (type == DT_INTEGER)
	get_current_out() << "i32, align 4" << std::endl		get_current_out() << "i32, align 4" << std::endl
	<< "store i32 0, i32* %" << name_token.term.payload << ", align 4" << std::endl;		<< "store i32 0, i32* %identifier."
			<< name_token.term.payload << ", align 4" << std::endl;
	else		else
	get_current_out() << "double, align 8" << std::endl		get_current_out() << "double, align 8" << std::endl
	<< "store double 0.000000e+00, double* %" << name_token.term.payload << ", align 8" << std::endl;		<< "store double 0.000000e+00, double* %identifier."
			<< name_token.term.payload << ", align 8" << std::endl;
	}		}
	}		}

	@@ -218,7 +237,6 @@ void LLVMParser::grammar_callable_declaration()
	throw expected_tokens(token, { Term::from_character.find(':')->second });		throw expected_tokens(token, { Term::from_character.find(':')->second });
	DataType return_type = grammar_type();		DataType return_type = grammar_type();
	assert(symbols.insert("metadata::return_data_type", { ST_METADATA, { return_type }, 0 }));		assert(symbols.insert("metadata::return_data_type", { ST_METADATA, { return_type }, 0 }));
	assert(symbols.insert("metadata::current_offset", { ST_METADATA, { DT_ARBITRARY }, 1 }));
	parameter_types.push_back(return_type);		parameter_types.push_back(return_type);
	get_current_out() << "define ";		get_current_out() << "define ";
	if (return_type == DT_INTEGER)		if (return_type == DT_INTEGER)
	@@ -284,10 +302,10 @@ void LLVMParser::grammar_parameter(std::vector<DataType>& parameter_types)
	get_current_out() << "i32";		get_current_out() << "i32";
	else		else
	get_current_out() << "double";		get_current_out() << "double";
	get_current_out() << " %" << name_token.term.payload;		get_current_out() << " %identifier." << name_token.term.payload;
	}		}

	void LLVMParser::grammar_statement_list(const std::string& label_next)		void LLVMParser::grammar_statement_list(size_t label_next)
	{		{
	auto token = lexer.peekNext();		auto token = lexer.peekNext();
	auto eof = std::char_traits<char>::eof();		auto eof = std::char_traits<char>::eof();
	@@ -298,45 +316,52 @@ void LLVMParser::grammar_statement_list(const std::string& label_next)
	\|\| !(token.term.payload == "end" \|\| token.term.payload == "fi"		\|\| !(token.term.payload == "end" \|\| token.term.payload == "fi"
	\|\| token.term.payload == "else" \|\| token.term.payload == "done"))		\|\| token.term.payload == "else" \|\| token.term.payload == "done"))
	&& token.term.type != TT_EOF) {		&& token.term.type != TT_EOF) {
	grammar_statement(label_next);		grammar_statement();
	token = lexer.getNext();		token = lexer.getNext();
	if (token.term.type != TT_SEMICOLON)		if (token.term.type != TT_SEMICOLON)
	throw expected_tokens(token, { Term::from_character.find(';')->second });		throw expected_tokens(token, { Term::from_character.find(';')->second });
	grammar_statement_list(label_next);		grammar_statement_list(label_next);
	} else {		} else {
	get_current_out() << "br label %" << label_next << std::endl;		llvm_goto(label_next);
	}		}
	}		}

	void LLVMParser::grammar_statement(const std::string& label_next)		void LLVMParser::grammar_statement()
	{		{
	auto token = lexer.getNext();		auto token = lexer.getNext();
	if (token.term.type != TT_ID)		if (token.term.type != TT_ID)
	throw expected_tokens(token, { { TT_ID, "(arbitrary)" } });		throw expected_tokens(token, { { TT_ID, "(arbitrary)" } });
	if (token.term.payload == "if") {		if (token.term.payload == "if") {
	std::string label_true = make_label();		size_t label_nested_next = get_next_label();
	std::string label_false = make_label();		size_t label_true = get_next_label();
			size_t label_false = get_next_label();
	grammar_bool_expression(label_true, label_false);		grammar_bool_expression(label_true, label_false);
	token = lexer.getNext();		token = lexer.getNext();
	if (token.term.type != TT_ID && token.term.payload != "then")		if (token.term.type != TT_ID && token.term.payload != "then")
	throw expected_tokens(token, { { TT_ID, "then" } });		throw expected_tokens(token, { { TT_ID, "then" } });
	write_label(label_true);		llvm_write_label(label_true);
	grammar_statement_list(label_next);		grammar_statement_list(label_nested_next);
	write_label(label_false);		llvm_write_label(label_false);
	grammar_statement_if_tail(label_next);		grammar_statement_if_tail(label_nested_next);
			llvm_goto(label_nested_next);
			llvm_write_label(label_nested_next);
	} else if (token.term.payload == "while") {		} else if (token.term.payload == "while") {
	std::string label_true = make_label();		size_t label_nested_next = get_next_label();
	std::string label_loop = make_label();		size_t label_true = get_next_label();
	write_label(label_loop);		size_t label_loop = get_next_label();
	grammar_bool_expression(label_true, label_next);		llvm_goto(label_loop);
			llvm_write_label(label_loop);
			grammar_bool_expression(label_true, label_nested_next);
	token = lexer.getNext();		token = lexer.getNext();
	if (token.term.type != TT_ID && token.term.payload != "do")		if (token.term.type != TT_ID && token.term.payload != "do")
	throw expected_tokens(token, { { TT_ID, "do" } });		throw expected_tokens(token, { { TT_ID, "do" } });
	write_label(label_true);		llvm_write_label(label_true);
	grammar_statement_list(label_loop);		grammar_statement_list(label_loop);
	token = lexer.getNext();		token = lexer.getNext();
	if (token.term.type != TT_ID && token.term.payload != "done")		if (token.term.type != TT_ID && token.term.payload != "done")
	throw expected_tokens(token, { { TT_ID, "done" } });		throw expected_tokens(token, { { TT_ID, "done" } });
			llvm_goto(label_nested_next);
			llvm_write_label(label_nested_next);
	} else if (token.term.payload == "return") {		} else if (token.term.payload == "return") {
	SymbolData& data = symbols.find("metadata::return_data_type").second;		SymbolData& data = symbols.find("metadata::return_data_type").second;
	assert(data.data_type.size() == 1);		assert(data.data_type.size() == 1);
	@@ -352,19 +377,20 @@ void LLVMParser::grammar_statement(const std::string& label_next)
	get_current_out() << "i32";		get_current_out() << "i32";
	else		else
	get_current_out() << "double";		get_current_out() << "double";
	get_current_out() << " %" << loaded_storage_offset << std::endl;		get_current_out() << " %identifier." << loaded_storage_offset << std::endl;
	get_next_offset();		get_next_offset();
	} else { // Print the returned value, when we are in the global scope.		} else { // Print the returned value, when we are in the global scope.
	get_current_out() << "call i32 (i8, ...) @printf(i8 getelementptr inbounds (";		get_current_out() << "call i32 (i8, ...) @printf(i8 getelementptr inbounds (";
	if (coerced_type == DT_INTEGER)		if (coerced_type == DT_INTEGER)
	get_current_out() << "[4 x i8], [4 x i8]* @.print_integer, i32 0, i32 0), i32 %";		get_current_out() << "[4 x i8], [4 x i8]* @.print_integer, i32 0, i32 0), i32 %identifier.";
	else		else
	get_current_out() << "[5 x i8], [5 x i8]* @.print_double, i32 0, i32 0), double %";		get_current_out() << "[5 x i8], [5 x i8]* @.print_double, i32 0, i32 0), double %identifier.";
	get_current_out() << loaded_storage_offset << ")" << std::endl		get_current_out() << loaded_storage_offset << ")" << std::endl;
	<< "ret i32 0" << std::endl;		get_next_offset();
			get_current_out() << "ret i32 0" << std::endl;
	get_next_offset();		get_next_offset();
	}		}
	} else {		} else { // Variable assignment
	auto name_token = token;		auto name_token = token;
	SymbolData data;		SymbolData data;
	bool is_identifier_global;		bool is_identifier_global;
	@@ -383,13 +409,14 @@ void LLVMParser::grammar_statement(const std::string& label_next)
	size_t loaded_storage_offset = llvm_load(storage_offset, coerced_type);		size_t loaded_storage_offset = llvm_load(storage_offset, coerced_type);
	get_current_out() << "store ";		get_current_out() << "store ";
	if (coerced_type == DT_INTEGER)		if (coerced_type == DT_INTEGER)
	get_current_out() << "i32 %" << loaded_storage_offset << ", i32* ";		get_current_out() << "i32 %identifier." << loaded_storage_offset << ", i32* ";
	else		else
	get_current_out() << "double %" << loaded_storage_offset << ", double* ";		get_current_out() << "double %identifier." << loaded_storage_offset
			<< ", double* ";
	if (is_identifier_global)		if (is_identifier_global)
	get_current_out() << "@GLOBAL_" << name_token.term.payload;		get_current_out() << "@GLOBAL_" << name_token.term.payload;
	else		else
	get_current_out() << "%" << name_token.term.payload;		get_current_out() << "%identifier." << name_token.term.payload;
	get_current_out() << ", align ";		get_current_out() << ", align ";
	if (coerced_type == DT_INTEGER)		if (coerced_type == DT_INTEGER)
	get_current_out() << 4;		get_current_out() << 4;
	@@ -399,7 +426,7 @@ void LLVMParser::grammar_statement(const std::string& label_next)
	}		}
	}		}

	void LLVMParser::grammar_statement_if_tail(const std::string& label_next)		void LLVMParser::grammar_statement_if_tail(size_t label_next)
	{		{
	auto token = lexer.getNext();		auto token = lexer.getNext();
	if (token.term.type != TT_ID \|\| !(token.term.payload == "fi" \|\| token.term.payload == "else"))		if (token.term.type != TT_ID \|\| !(token.term.payload == "fi" \|\| token.term.payload == "else"))
	@@ -446,7 +473,7 @@ DataType LLVMParser::grammar_arithmetic_expression(size_t& storage_offset)
	throw expected_tokens(token, { Term::from_character.find(')')->second });		throw expected_tokens(token, { Term::from_character.find(')')->second });
	size_t loaded_storage_offset = get_next_offset();		size_t loaded_storage_offset = get_next_offset();
	DataType return_type = data.data_type.back();		DataType return_type = data.data_type.back();
	get_current_out() << "%" << loaded_storage_offset << " = call ";		get_current_out() << "%identifier." << loaded_storage_offset << " = call ";
	if (return_type == DT_INTEGER)		if (return_type == DT_INTEGER)
	get_current_out() << "i32";		get_current_out() << "i32";
	else		else
	@@ -513,7 +540,7 @@ DataType LLVMParser::grammar_arithmetic_expression_tail(DataType left_operand_ty
	size_t loaded_right_operand_storage_offset = llvm_load(		size_t loaded_right_operand_storage_offset = llvm_load(
	right_operand_storage_offset, coerced_type);		right_operand_storage_offset, coerced_type);
	size_t loaded_offset = get_next_offset();		size_t loaded_offset = get_next_offset();
	get_current_out() << "%" << loaded_offset << " = ";		get_current_out() << "%identifier." << loaded_offset << " = ";
	if (coerced_type == DT_INTEGER)		if (coerced_type == DT_INTEGER)
	get_current_out() << "add";		get_current_out() << "add";
	else		else
	@@ -523,8 +550,8 @@ DataType LLVMParser::grammar_arithmetic_expression_tail(DataType left_operand_ty
	get_current_out() << "i32";		get_current_out() << "i32";
	else		else
	get_current_out() << "double";		get_current_out() << "double";
	get_current_out() << " %" << loaded_left_operand_storage_offset		get_current_out() << " %identifier." << loaded_left_operand_storage_offset
	<< ", %" << loaded_right_operand_storage_offset << std::endl;		<< ", %identifier." << loaded_right_operand_storage_offset << std::endl;
	storage_offset = llvm_store(loaded_offset, coerced_type);		storage_offset = llvm_store(loaded_offset, coerced_type);
	return coerced_type;		return coerced_type;
	} else {		} else {
	@@ -635,7 +662,7 @@ DataType LLVMParser::grammar_arithmetic_factor_tail(DataType left_operand_type,
	size_t loaded_right_operand_storage_offset = llvm_load(		size_t loaded_right_operand_storage_offset = llvm_load(
	right_operand_storage_offset, coerced_type);		right_operand_storage_offset, coerced_type);
	size_t loaded_offset = get_next_offset();		size_t loaded_offset = get_next_offset();
	get_current_out() << "%" << loaded_offset << " = ";		get_current_out() << "%identifier." << loaded_offset << " = ";
	if (token.term.type == TT_ARITHOP_MUL) {		if (token.term.type == TT_ARITHOP_MUL) {
	if (coerced_type == DT_INTEGER)		if (coerced_type == DT_INTEGER)
	get_current_out() << "mul";		get_current_out() << "mul";
	@@ -658,8 +685,8 @@ DataType LLVMParser::grammar_arithmetic_factor_tail(DataType left_operand_type,
	get_current_out() << "i32";		get_current_out() << "i32";
	else		else
	get_current_out() << "double";		get_current_out() << "double";
	get_current_out() << " %" << loaded_left_operand_storage_offset		get_current_out() << " %identifier." << loaded_left_operand_storage_offset
	<< ", %" << loaded_right_operand_storage_offset << std::endl;		<< ", %identifier." << loaded_right_operand_storage_offset << std::endl;
	storage_offset = llvm_store(loaded_offset, coerced_type);		storage_offset = llvm_store(loaded_offset, coerced_type);
	return coerced_type;		return coerced_type;
	} else {		} else {
	@@ -691,10 +718,11 @@ DataType LLVMParser::grammar_arithmetic_operand(size_t& storage_offset)
	size_t loaded_nested_storage_offset = llvm_load(nested_storage_offset, type);		size_t loaded_nested_storage_offset = llvm_load(nested_storage_offset, type);
	size_t loaded_storage_offset = get_next_offset();		size_t loaded_storage_offset = get_next_offset();
	if (type == DT_INTEGER)		if (type == DT_INTEGER)
	get_current_out() << "%" << loaded_storage_offset << " = sub i32 0, %"		get_current_out() << "%identifier." << loaded_storage_offset
	<< loaded_nested_storage_offset << std::endl;		<< " = sub i32 0, %identifier." << loaded_nested_storage_offset << std::endl;
	else		else
	get_current_out() << "%" << loaded_storage_offset << " = fsub double -0.000000e+00, %"		get_current_out() << "%identifier." << loaded_storage_offset
			<< " = fsub double -0.000000e+00, %identifier."
	<< loaded_nested_storage_offset << std::endl;		<< loaded_nested_storage_offset << std::endl;
	storage_offset = llvm_store(loaded_storage_offset, type);		storage_offset = llvm_store(loaded_storage_offset, type);
	return type;		return type;
	@@ -707,7 +735,7 @@ DataType LLVMParser::grammar_arithmetic_operand(size_t& storage_offset)
	throw undefined_variable(token);		throw undefined_variable(token);
	assert(data.data_type.size() == 1);		assert(data.data_type.size() == 1);
	DataType type = data.data_type.back();		DataType type = data.data_type.back();
	get_current_out() << "%" << loaded_storage_offset << " = load ";		get_current_out() << "%identifier." << loaded_storage_offset << " = load ";
	if (type == DT_INTEGER)		if (type == DT_INTEGER)
	get_current_out() << "i32, i32*";		get_current_out() << "i32, i32*";
	else		else
	@@ -716,21 +744,23 @@ DataType LLVMParser::grammar_arithmetic_operand(size_t& storage_offset)
	if (is_identifier_global)		if (is_identifier_global)
	get_current_out() << "@GLOBAL_";		get_current_out() << "@GLOBAL_";
	else		else
	get_current_out() << "%";		get_current_out() << "%identifier.";
	get_current_out() << token.term.payload << ", align 4" << std::endl;		get_current_out() << token.term.payload << ", align 4" << std::endl;
	storage_offset = llvm_store(loaded_storage_offset, type);		storage_offset = llvm_store(loaded_storage_offset, type);
	return type;		return type;
	} else if (token.term.type == TT_INTEGER) {		} else if (token.term.type == TT_INTEGER) {
	storage_offset = get_next_offset();		storage_offset = get_next_offset();
	get_current_out() << "%" << storage_offset << " = alloca i32, align 4" << std::endl		get_current_out() << "%identifier." << storage_offset
	<< "store i32 " << token.term.payload << ", i32* %"		<< " = alloca i32, align 4" << std::endl
	<< storage_offset << ", align 4" << std::endl;		<< "store i32 " << token.term.payload
			<< ", i32* %identifier." << storage_offset << ", align 4" << std::endl;
	return DT_INTEGER;		return DT_INTEGER;
	} else if (token.term.type == TT_REAL) {		} else if (token.term.type == TT_REAL) {
	storage_offset = get_next_offset();		storage_offset = get_next_offset();
	get_current_out() << "%" << storage_offset << " = alloca double, align 8" << std::endl		get_current_out() << "%identifier." << storage_offset
	<< "store double " << token.term.payload << ", double* %"		<< " = alloca double, align 8" << std::endl
	<< storage_offset << ", align 8" << std::endl;		<< "store double " << token.term.payload
			<< ", double* %identifier." << storage_offset << ", align 8" << std::endl;
	return DT_DOUBLE;		return DT_DOUBLE;
	}		}
	assert(false); // Should never reach here.		assert(false); // Should never reach here.
	@@ -738,16 +768,16 @@ DataType LLVMParser::grammar_arithmetic_operand(size_t& storage_offset)
	}		}

	void LLVMParser::grammar_bool_expression(		void LLVMParser::grammar_bool_expression(
	const std::string& label_true, const std::string& label_false)		size_t label_true, size_t label_false)
	{		{
	std::string label_nested_false = make_label();		size_t label_nested_false = get_next_label();
	grammar_bool_factor(label_true, label_nested_false);		grammar_bool_factor(label_true, label_nested_false);
	grammar_bool_expression_tail(label_true, label_false, label_nested_false);		grammar_bool_expression_tail(label_true, label_false, label_nested_false);
	}		}

	void LLVMParser::grammar_bool_expression_tail(		void LLVMParser::grammar_bool_expression_tail(
	const std::string& label_true,		size_t label_true,
	const std::string& label_false, const std::string& label_nested_false)		size_t label_false, size_t label_nested_false)
	{		{
	auto token = lexer.peekNext();		auto token = lexer.peekNext();
	if ((token.term.type != TT_ID		if ((token.term.type != TT_ID
	@@ -759,25 +789,25 @@ void LLVMParser::grammar_bool_expression_tail(
	Term::from_character.find(']')->second });		Term::from_character.find(']')->second });
	if (token.term.type == TT_ID && token.term.payload == "or") {		if (token.term.type == TT_ID && token.term.payload == "or") {
	lexer.getNext();		lexer.getNext();
	write_label(label_nested_false);		llvm_write_label(label_nested_false);
	grammar_bool_expression(label_true, label_false);		grammar_bool_expression(label_true, label_false);
	} else {		} else {
	write_label(label_nested_false);		llvm_write_label(label_nested_false);
	get_current_out() << "br label %" << label_false << std::endl;		llvm_goto(label_false);
	}		}
	}		}

	void LLVMParser::grammar_bool_factor(		void LLVMParser::grammar_bool_factor(
	const std::string& label_true, const std::string& label_false)		size_t label_true, size_t label_false)
	{		{
	std::string label_nested_true = make_label();		size_t label_nested_true = get_next_label();
	grammar_bool_operand(label_nested_true, label_false);		grammar_bool_operand(label_nested_true, label_false);
	grammar_bool_factor_tail(label_true, label_nested_true, label_false);		grammar_bool_factor_tail(label_true, label_nested_true, label_false);
	}		}

	void LLVMParser::grammar_bool_factor_tail(		void LLVMParser::grammar_bool_factor_tail(
	const std::string& label_true, const std::string& label_nested_true,		size_t label_true, size_t label_nested_true,
	const std::string& label_false)		size_t label_false)
	{		{
	auto token = lexer.peekNext();		auto token = lexer.peekNext();
	if ((token.term.type != TT_ID		if ((token.term.type != TT_ID
	@@ -789,16 +819,16 @@ void LLVMParser::grammar_bool_factor_tail(
	Term::from_character.find(']')->second });		Term::from_character.find(']')->second });
	if (token.term.type == TT_ID && token.term.payload == "and") {		if (token.term.type == TT_ID && token.term.payload == "and") {
	lexer.getNext();		lexer.getNext();
	write_label(label_nested_true);		llvm_write_label(label_nested_true);
	grammar_bool_factor(label_true, label_false);		grammar_bool_factor(label_true, label_false);
	} else {		} else {
	write_label(label_nested_true);		llvm_write_label(label_nested_true);
	get_current_out() << "br label %" << label_true << std::endl;		llvm_goto(label_true);
	}		}
	}		}

	void LLVMParser::grammar_bool_operand(		void LLVMParser::grammar_bool_operand(
	const std::string& label_true, const std::string& label_false)		size_t label_true, size_t label_false)
	{		{
	auto token = lexer.peekNext();		auto token = lexer.peekNext();
	if (token.term.type != TT_ID && token.term.type != TT_INTEGER		if (token.term.type != TT_ID && token.term.type != TT_INTEGER
	@@ -822,14 +852,12 @@ void LLVMParser::grammar_bool_operand(
	&& (token.term.payload == "true" \|\| token.term.payload == "false")) {		&& (token.term.payload == "true" \|\| token.term.payload == "false")) {
	lexer.getNext();		lexer.getNext();
	if (token.term.payload == "true")		if (token.term.payload == "true")
	get_current_out() << "br label %" << label_true << std::endl;		llvm_goto(label_true);
	else		else
	get_current_out() << "br label %" << label_false << std::endl;		llvm_goto(label_false);
	} else {		} else {
	size_t loaded_storage_offset = grammar_relation_expression();		size_t loaded_storage_offset = grammar_relation_expression();
	get_current_out() << "br i1 %" << loaded_storage_offset		llvm_conditional_goto(loaded_storage_offset, label_false, label_true);
	<< ", label %" << label_true
	<< ", label %" << label_false << std::endl;
	}		}
	}		}

	@@ -851,8 +879,6 @@ size_t LLVMParser::grammar_relation_expression_tail(
	Term::from_character.find('>')->second });		Term::from_character.find('>')->second });
	size_t right_operand_storage_offset;		size_t right_operand_storage_offset;
	DataType right_operand_type = grammar_arithmetic_expression(right_operand_storage_offset);		DataType right_operand_type = grammar_arithmetic_expression(right_operand_storage_offset);
	size_t loaded_storage_offset = get_next_offset();
	get_current_out() << "%" << loaded_storage_offset << " = ";
	DataType coerced_type = arithmetic_binary_operator_coerce(		DataType coerced_type = arithmetic_binary_operator_coerce(
	left_operand_type, right_operand_type,		left_operand_type, right_operand_type,
	left_operand_storage_offset, right_operand_storage_offset);		left_operand_storage_offset, right_operand_storage_offset);
	@@ -860,6 +886,8 @@ size_t LLVMParser::grammar_relation_expression_tail(
	left_operand_storage_offset, left_operand_type);		left_operand_storage_offset, left_operand_type);
	size_t loaded_right_operand_storage_offset = llvm_load(		size_t loaded_right_operand_storage_offset = llvm_load(
	right_operand_storage_offset, right_operand_type);		right_operand_storage_offset, right_operand_type);
			size_t loaded_storage_offset = get_next_offset();
			get_current_out() << "%identifier." << loaded_storage_offset << " = ";
	if (coerced_type == DT_INTEGER) {		if (coerced_type == DT_INTEGER) {
	get_current_out() << "icmp ";		get_current_out() << "icmp ";
	switch (token.term.type) {		switch (token.term.type) {
	@@ -875,8 +903,8 @@ size_t LLVMParser::grammar_relation_expression_tail(
	default:		default:
	assert(false); // Should never reach here.		assert(false); // Should never reach here.
	}		}
	get_current_out() << " i32 %" << loaded_left_operand_storage_offset		get_current_out() << " i32 %identifier." << loaded_left_operand_storage_offset
	<< ", %" << loaded_right_operand_storage_offset << std::endl;		<< ", %identifier." << loaded_right_operand_storage_offset << std::endl;
	} else {		} else {
	get_current_out() << "fcmp ";		get_current_out() << "fcmp ";
	switch (token.term.type) {		switch (token.term.type) {
	@@ -892,8 +920,8 @@ size_t LLVMParser::grammar_relation_expression_tail(
	default:		default:
	assert(false); // Should never reach here.		assert(false); // Should never reach here.
	}		}
	get_current_out() << " double %" << loaded_left_operand_storage_offset		get_current_out() << " double %identifier." << loaded_left_operand_storage_offset
	<< ", %" << loaded_right_operand_storage_offset << std::endl;		<< ", %identifier." << loaded_right_operand_storage_offset << std::endl;
	}		}
	return loaded_storage_offset;		return loaded_storage_offset;
	}		}

LLVMParser.hpp

+20 −22

File changed.

Preview size limit exceeded, changes collapsed.

tests/Phase03_LLVMParser.cpp

+33 −2

File changed.

Preview size limit exceeded, changes collapsed.

Admin message