kompiler 0.3.0.pre.2 → 0.3.0.pre.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c7b411e21f2b93443cb22e7461437c8ab98df8acc4fd56538d64c8fc0d7c828
-  data.tar.gz: 05747db808c1d5accc8b42ee6681b2a617feb89437bf244e389420740a3d4da0
+  metadata.gz: b00e5940820b7f2798ede46f7014a87ab43d7ade0ca171c223eae550668673c0
+  data.tar.gz: dcd9d7bd8d170a37206d51a6b427c48217d115f048620404b045a8f6005eb6e0
 SHA512:
-  metadata.gz: 0a302052eb6c01c1f6812e98b8492fc455077746effb6e6d6133a411eb179b157ecf3bc1a4bcd38e85e1a1dc2aea52dee4cfd7088b9212b73df6f0912ac9d1fc
-  data.tar.gz: af2d6fb1f53eae49d7121fc90048d1bc5766316bc302fd910bc1702cf4dab3f43fd09ee01433fbb11f8ec4419de7191a0cc02fd64bb43f8c998173c78acc0237
+  metadata.gz: 023ae20fa5229d793e71ebea06bc46dea243170129e12eaf5c099c16dabdabcecb6302f0893ef17cbf0128c30a8d7d9f0b77841ecfa6ddb871d18e0c517373d4
+  data.tar.gz: ae856004b38f75b46b4b62c7455c5f94cbeb2f21dd34e54443ff776f4fbb23432eb42f389bd706f3d649c8b2d69bee3a3e2d2cf7095d24178c32e50f32b47149

data/lib/kompiler/arch_manager.rb

@@ -4,7 +4,7 @@
 module Kompiler
 
 	# Object for managing architecture entries / available architectures
-	class ArchManager
+	module ArchManager
 		@arch_entries = []
 		
 		def self.add_arch(arch_name, include_path)
@@ -20,7 +20,7 @@ module Kompiler
 		end
 		
 		def self.load_all_entries
-			Dir[File.join(__dir__, 'arch_entries', '*.rb')].each { |file| require file }
+			Gem.find_files("kompiler/arch_entries/*").each { |file| require file }
 		end
 	end
 

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

@@ -954,6 +954,18 @@ end
 		],
 		bitsize: 32
 	},
+	{
+		keyword: "svc",
+		name: "Supervisor Call",
+		description: "Triggers a synchronous exception taken to EL1, passing an immediate value to the ESR_ELx system register.",
+		operands: [{type: "immediate", name: "Immediate"}],
+		mc_constructor: [
+			["bits", 1,0, 0,0,0],
+			["get_bits", ["get_operand", 0], 0, 16],
+			["bits", 0,0,0, 0,0,1,0,1,0,1,1],
+		],
+		bitsize: 32
+	},
 	
 	
 	#

data/lib/kompiler/compiler_functions.rb

@@ -3,86 +3,7 @@
 
 module Kompiler
 
-class CompilerFunctions
-
-def self.parse_includes(lines, loaded_files=[])
-	
-	final_lines = lines.dup	
-	
-	line_i = 0
-	
-	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
-	
-end
-
-
+module CompilerFunctions
 
 def self.parse_code(lines)	
 	
@@ -90,30 +11,29 @@ def self.parse_code(lines)
 	
 	instr_adr = 0
 	
-	lines.each_with_index do |line, line_i|
+	line_i = 0
+
+	extra_state = Hash.new
+	
+	add_later_directives = []
+	
+	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
 		
@@ -123,12 +43,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
@@ -139,6 +106,37 @@ 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
@@ -173,9 +171,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)			
@@ -243,17 +253,11 @@ end
 def self.compile(code, included_files=[])
 
 	lines = Kompiler::Parsers.get_code_lines(code)
-
-	final_lines = parse_includes(lines, included_files.map{|fname| File.expand_path(fname)})
-
-	parsed_lines = parse_code(final_lines)
 	
-	labels = get_labels(parsed_lines)	
+	parsed_lines = parse_code(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)	
-
 	machine_code_bytes = construct_program_mc(parsed_lines, labels)
 end
 

data/lib/kompiler/config.rb

@@ -0,0 +1,29 @@
+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"]
+		@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