kompiler 0.3.0.pre.3 → 0.3.0

data/lib/kompiler/architectures/armv8a/simd_fp_registers.rb

@@ -0,0 +1,23 @@
+# Copyright 2024 Kyrylo Shyshko
+# Licensed under the Apache License, Version 2.0. See LICENSE file for details.
+
+module Kompiler
+
+module ARMv8A
+
+def self.simd_fp_registers
+	@simd_fp_registers
+end	
+
+@simd_fp_registers = [
+	
+]
+
+(0..31).each do |reg_i|
+	@simd_fp_registers << {reg_name: "q#{reg_i}", reg_type: "simd_fp_reg", re_num: reg_i}
+end
+
+
+end # Kompiler::ARMv8A
+
+end # Kompiler

data/lib/kompiler/architectures/armv8a/sys_registers.rb

@@ -54,6 +54,9 @@ end
 	
 	{reg_name: "ISR_EL1", reg_size: 64, reg_type: "sr", reg_encoding: {"op0"=>0b11, "op1"=>0b000, "CRn"=>0b1100, "CRm"=>0b0001, "op2"=>0b000}},
 	
+	{reg_name: "CPACR_EL1", reg_size: 64, reg_type: "sr", reg_encoding: {"op0"=>0b11, "op1"=>0b000, "CRn"=>0b0001, "CRm"=>0b0000, "op2"=>0b010}},
+	{reg_name: "CPACR_EL12", reg_size: 64, reg_type: "sr", reg_encoding: {"op0"=>0b11, "op1"=>0b101, "CRn"=>0b0001, "CRm"=>0b0000, "op2"=>0b010}},
+	
 	# Special registers for the MSR (immediate) instruction (some of them were previously defined already)
 	{reg_name: "SPSel", reg_type: "pstate_reg"},
 	{reg_name: "DAIFSet", reg_type: "pstate_reg"},

data/lib/kompiler/compiler_functions.rb

@@ -1,226 +1,49 @@
 # Copyright 2024 Kyrylo Shyshko
 # Licensed under the Apache License, Version 2.0. See LICENSE file for details.
 
+#
+# Implements main logic happening during compilation.
+# Main functions:
+#  parse_code - main code parser that turns all lines into an abstract structure (determining types of lines and connecting them into a program)
+#  construct_program_mc - transforms the parse_code's AST into machine code (MC)
+#  detailed_compile - stitches parse_code and construct_program_mc to fully compile a program with a detailed output
+#  compile - calls detailed_compile and removes the extra output information
+#
+
+
 module Kompiler
 
 module CompilerFunctions
 
-def self.parse_includes(lines, loaded_files=[])
-	
-	final_lines = lines.dup	
+def self.parse_code(lines)	
 	
-	line_i = 0
+	parsed_lines = []
 	
-	loop do
-		break if line_i >= final_lines.size
-		
-		line = final_lines[line_i]
-		
-		keyword, operands = Kompiler::Parsers.parse_instruction_line(line)
-		
-		if keyword == false
-			line_i += 1
-			next
-		end
-		
-		if keyword.start_with? "."
-			keyword = keyword[1..]
-		end
-		
-		if !["load", "include", "load_end", "include_end"].include?(keyword)
-			line_i += 1
-			next
-		end
-		
-		raise "Incorrect use of the \"#{keyword}\" directive: requires a filename in a string." if operands.size != 1 || (operands.size == 1 && operands[0][:type] != "string")
-		
-		load_file_name_selector = operands[0][:string]
-
-
-		# Remove the include code line from the lines array
-		final_lines.delete_at line_i
-
-		# If ends with _end, that means that the file contents should be appended at the end of the current lines
-		if keyword.end_with? "_end"
-			next_i_insert = final_lines.size
-		else
-			# If doesn't end with _end, files should be loaded in-place of the current line
-			next_i_insert = line_i
-		end
-		
-		
-		Dir[load_file_name_selector].each do |load_file_name|
-			# Get the absolute path filename
-			full_file_name = File.expand_path(load_file_name)
-			
-			raise "#{keyword} \"#{load_file_name}\": File not found." if !File.exist?(full_file_name)
-			
-			# Check if the file was already loaded (stop recursive loading)
-			if loaded_files.include?(full_file_name)
-				next
-			end
-			
-			# Read the file to load
-			include_code = File.read(full_file_name)
-			
-			# Separate the lines inside it
-			include_code_lines = Kompiler::Parsers.get_code_lines(include_code)
-			
-			# Add the lines from the load file to the lines array at the line_i index, effectively replacing the load command with the content of the load file
-			final_lines.insert next_i_insert, *include_code_lines
-			
-			next_i_insert += include_code_lines.size
-			
-			# Add the filename (absolute path) to the list of included files
-			loaded_files << full_file_name
-		end
-		
-		# Don't increment line_i, since the new loop will now start include-parsing the newly loaded file in the same program
-	end
-
-	final_lines
+	instr_adr = 0
 	
-end
-
-
-def self.parse_macros(lines)
-
-	macros = []
-
 	line_i = 0
-	
-	loop do
-		break if line_i >= lines.size
-		
-		line = lines[line_i]
-		
-		keyword, operands = Kompiler::Parsers.parse_instruction_line line
-		
-		keyword = keyword[1..] if keyword.start_with? "."
-		
-		if keyword == 'macro'
-			raise "Macro definition error: Expected two operands to be provided, while #{operands.size} were given" if operands.size != 2
-			raise "Macro definition error: The macro name must either be a word or a string" if !["label", "string"].include?(operands[0][:type])
-			
-			case operands[0][:type]
-			when "label"
-				macro_name = operands[0][:value]
-			when "string"
-				macro_name = operands[0][:value]
-			end
-			
-			macro_definition = operands[1][:definition]
-			
-			macros << {name: macro_name, definition: macro_definition}
-			
-			lines.delete_at line_i
-		else
-			line_i += 1
-		end
-	end
-	
-	# Apply the macros to all lines, and then the lines that were changed, and than again, and so on (iterative loop until none of the lines need to be checked)
-	
-	lines_to_check = (0...lines.size).to_a
-	
-	while lines_to_check.size != 0 # Repeat until no more lines to check		
-
-		# Define restricted separators characters (characters that CAN'T separate a macro from everything else)
-		restricted_separator_chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["_", "."]
-		
-		# Create an array for the lines to check once again
-		new_lines_to_check = []
-		
-		lines_to_check.each do |line_i|
-			line = lines[line_i]
-			
-			char_i = 0
-			
-			# Create a variable to indicate if a macro was used on the current line 
-			line_macro_used = false
-			
-			loop do
-				break if char_i >= line.size
-				
-				if ['"', "'"].include? line[char_i]
-					# If a string, skip it
-					str, parsed_length = Kompiler::Parsers.parse_str line[char_i..]
-					char_i += parsed_length
-					next
-				end
-				
-				cut_line = line[char_i..]			
-				
-				# Create a variable to indicate if a macro was used in the current position
-				macro_used = false			
-				
-				macros.each do |macro|
-					macro_name = macro[:name]
-					macro_def = macro[:definition]
-					next if !cut_line.start_with?(macro_name) # Skip if doesn't begin with the macro's name
-					next if (cut_line.size > macro_name.size) && restricted_separator_chars.include?(cut_line[macro_name.size]) # Skip if there is a character after the macro name, and the character is not permitted
-					next if (char_i > 0) && restricted_separator_chars.include?(line[char_i - 1]) # Skip if there is a character before the checking sequence, and the character is not permitted
-					
-					# Here if the macro is 'accepted'
-					line = line[...char_i] + macro_def + line[(char_i + macro_name.size)..]
-					# Indicate that a macro was used
-					macro_used = true
-				end
-				
-				if macro_used
-					# If a macro was used, indicate that on line level
-					line_macro_used = true
-				else
-					# If a macro wasn't used, proceed to the next character
-					char_i += 1
-				end
-			end # line characters loop
-			
-			if line_macro_used
-				# If a macro was used on the current line, update the lines array, and add the line to check for macros again
-				lines[line_i] = line
-				new_lines_to_check << line_i
-			end
-		end # lines_to_check.each loop
-		
-		lines_to_check = new_lines_to_check # Update lines to check with the new ones
-	
-	end # while lines_to_check.size != 0 loop
 
-	lines
-end
-
-
-def self.parse_code(lines)	
+	extra_state = Hash.new
 	
-	parsed_lines = []
+	add_later_directives = []
 	
-	instr_adr = 0
-	
-	lines.each_with_index do |line, line_i|
+	while line_i < lines.size
+		line = lines[line_i]
 		
 		# Check if line is not just whitespace
-		is_char_whitespace = line.each_char.map{|c| [" ", "\t"].include? c}
+		is_char_whitespace = line.each_char.map{|c| Kompiler::Config.whitespace_chars.include? c}
 		if !is_char_whitespace.include?(false) # If only whitespace
+			line_i += 1
 			next # Skip
 		end
 		
-		#
-		# Label definitions are now a directive, so this isn't needed
-		#
-		
-		# is_label, label_name = check_label(line)
-		# if is_label
-		# 	# labels[label_name] = instr_adr
-		# 	parsed_lines << {type: "label", label_name: label_name, label_address: instr_adr, address: instr_adr}
-		# 	next
-		# end
-	
 		is_instruction, exec_instruction = Kompiler::Parsers.check_instruction(line)
 		if is_instruction
 			parsed_lines << {type: "instruction", instruction: exec_instruction[:instruction], operands: exec_instruction[:operands], address: instr_adr}			
 			instr_adr += exec_instruction[:instruction][:bitsize] / 8
-			
+
+			line_i += 1
+		
 			next # Go to the next line
 		end
 		
@@ -230,12 +53,59 @@ def self.parse_code(lines)
 			directive = directive_hash[:directive]
 			operands = directive_hash[:operands]
 			
-			state = {current_address: instr_adr, parsed_lines: parsed_lines}
+			state = {current_address: instr_adr, parsed_lines: parsed_lines, lines: lines, line_i: line_i, extra_state: extra_state}
+			
+			add_later_directive = false
+			
+			if directive.keys.include?(:add_later_directive) && directive[:add_later_directive] == true
+				add_later_directive = true
+			end
+			
+			new_operands = operands.map do |op|
+				if op[:type] == "run_block"
+					begin
+						block_state = state.dup
+						block_state[:block_args] = op[:block_args]
+						block_state[:labels] = self.get_labels(parsed_lines)
+						op = op[:block].call(block_state)
+					rescue
+						add_later_directive = true
+						op = {type: "immediate", value: 0, def_type: "kompiler_test_value", definition: "0"}
+					end
+				end
+				op
+			end
+			
+			
+			if add_later_directive
+				
+				try_state = {current_address: instr_adr, parsed_lines: parsed_lines.dup, lines: lines.dup, line_i: line_i, extra_state: extra_state.dup}
+				
+				try_state = directive[:func].call(new_operands, try_state)
+				
+				
+				instr_adr = try_state[:current_address]
+				line_i = try_state[:line_i]
+				
+				raise "Directive error 1.1" if !(lines == try_state[:lines])
+				raise "Directive error 1.2" if !(extra_state == try_state[:extra_state])
+				raise "Directive error 1.3" if !(parsed_lines == try_state[:parsed_lines][...parsed_lines.size]) # Check that the previous parsed lines were not changed by the directive
+				
+				state.delete :parsed_lines
+				state.delete :lines
+				
+				add_later_directives << {directive_hash: directive_hash, insert_i: parsed_lines.size, run_state: state, return_line_i: line_i, return_current_address: instr_adr}
+				
+				next
+			end
 			
-			state = directive[:func].call(operands, state)
+			state = directive[:func].call(new_operands, state)
 		
 			instr_adr = state[:current_address]
 			parsed_lines = state[:parsed_lines]
+			lines = state[:lines]
+			line_i = state[:line_i]
+			extra_state = state[:extra_state]
 			
 			next # Skip to the next lime
 		end
@@ -246,9 +116,43 @@ def self.parse_code(lines)
 		
 		raise "\"#{line}\" - Unknown syntax: Program build not possible"
 		
+	end	
+
+	add_later_directives.sort_by{|hash| hash[:insert_i]}.reverse.each do |add_later_directive|
+		directive_hash = add_later_directive[:directive_hash]
+		insert_i = add_later_directive[:insert_i]
+		state = add_later_directive[:run_state]
+		
+		state[:parsed_lines] = parsed_lines[...insert_i]
+		state[:lines] = lines
+		
+		directive = directive_hash[:directive]
+		operands = directive_hash[:operands]
+		
+		new_operands = operands.map do |op|
+			if op[:type] == "run_block"
+				block_state = state.dup
+				block_state[:block_args] = op[:block_args]
+				block_state[:labels] = self.get_labels(parsed_lines)
+				op = op[:block].call(block_state)
+			end
+			op
+		end
+		
+		state = directive[:func].call(new_operands, state)
+		
+		
+		raise "Directive error 2.1" if add_later_directive[:return_current_address] != state[:current_address]
+		raise "Directive error 2.2" if add_later_directive[:return_line_i] != state[:line_i]
+		
+		
+		parsed_lines = state[:parsed_lines] + parsed_lines[insert_i..]
 	end
-	
-	parsed_lines
+
+
+	state = {parsed_lines: parsed_lines, current_address: instr_adr, lines: lines, line_i: line_i, extra_state: extra_state}
+
+	return state
 end
 
 
@@ -280,9 +184,21 @@ def self.construct_program_mc(parsed_lines, labels)
 	parsed_lines.each do |line|
 		case line[:type]
 		when "instruction"
-			program_state[:operands] = line[:operands]
 			program_state[:current_address] = line[:address]
 			
+			operands = line[:operands]
+			operands.map! do |op|
+				if op[:type] == "run_block"
+					state = program_state.dup
+					state[:block_args] = op[:block_args]
+					op = op[:block].call(state)
+				end
+				op
+			end
+			
+			program_state[:operands] = operands
+			
+			
 			mc_constructor = line[:instruction][:mc_constructor]
 			
 			instr_bits = Kompiler::MachineCode_AST.build_mc(mc_constructor, program_state)			
@@ -301,7 +217,7 @@ def self.construct_program_mc(parsed_lines, labels)
 			end
 		end
 	end
-	
+
 	lines_bytes
 end
 
@@ -347,23 +263,26 @@ def self.bit_lines_to_bytes(bit_lines)
 end
 
 
-def self.compile(code, included_files=[])
+def self.compile(code)
+	detailed_result = detailed_compile(code)
+
+	return detailed_result[:machine_code]
+end
 
+def self.detailed_compile(code)
 	lines = Kompiler::Parsers.get_code_lines(code)
-	
-	included_lines = parse_includes(lines, included_files.map{|fname| File.expand_path(fname)})
-	
-	macroed_lines = parse_macros(included_lines)
-	
-	parsed_lines = parse_code(macroed_lines)
-	
-	labels = get_labels(parsed_lines)	
-	
-#	machine_code_bit_lines = construct_program_mc(parsed_lines, labels)
-#
-#	machine_code_bytes = bit_lines_to_bytes(machine_code_bit_lines)	
-	
+
+	parsed_state = parse_code(lines)
+
+	# pp parsed_state
+
+	parsed_lines = parsed_state[:parsed_lines]
+
+	labels = get_labels(parsed_lines)
+
 	machine_code_bytes = construct_program_mc(parsed_lines, labels)
+
+	return {machine_code: machine_code_bytes, labels: labels, parsed_state: parsed_state}
 end
 
 

data/lib/kompiler/config.rb

@@ -0,0 +1,40 @@
+
+# 
+# Contains config options for how Kompiler interprets different characters.
+# 
+# Main config options:
+#  keyword_chars - list of characters that a keyword can contain
+#  label_chars - list of characters that a label name can contain
+#  whitespace_chars - list of characters that qualify as whitespace / separators of words
+#  string_delimiters - a list of characters that denote the start and end of a string
+#
+
+module Kompiler
+
+	module Config
+
+		@keyword_chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["_", "."]
+		@label_chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["_", "."]
+		@whitespace_chars = [" ", "\t", "\r"]
+		@string_delimiters = ['"', "'"]
+		
+		# Returns the permittable keyword characters
+		def self.keyword_chars
+			@keyword_chars
+		end
+		
+		# Returns the permittable label characters
+		def self.label_chars
+			@label_chars
+		end
+
+		def self.whitespace_chars
+			@whitespace_chars
+		end
+		
+		def self.string_delimiters
+			@string_delimiters
+		end
+	end
+	
+end