kompiler 0.3.0.pre.3 → 0.3.0.pre.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d37e70a65615ea1b7aece9de1a2ae544a30d9f3f9f1f44d233fac8ecde023b63
-  data.tar.gz: 533a6ac4a19a03c8ca483c63bf454d4cda802943462ea23bcbc1a59688e64d8d
+  metadata.gz: b00e5940820b7f2798ede46f7014a87ab43d7ade0ca171c223eae550668673c0
+  data.tar.gz: dcd9d7bd8d170a37206d51a6b427c48217d115f048620404b045a8f6005eb6e0
 SHA512:
-  metadata.gz: ad275ed1d7bbb7dad29409b3ca2f4e061c08f4534bf7c2104d2c20c235a1030e496ae6381322042fe1d1bdd699acc5e970ef82b521031853d4222792b6bf388f
-  data.tar.gz: 9132f9c232bc01ff2ebfac62bfa09527e79f644ce0d15a360de91ece0a854187da581b6e67c2bec78e6745845fb2257c759786d71e02d44f17fbf4919e7e106c
+  metadata.gz: 023ae20fa5229d793e71ebea06bc46dea243170129e12eaf5c099c16dabdabcecb6302f0893ef17cbf0128c30a8d7d9f0b77841ecfa6ddb871d18e0c517373d4
+  data.tar.gz: ae856004b38f75b46b4b62c7455c5f94cbeb2f21dd34e54443ff776f4fbb23432eb42f389bd706f3d649c8b2d69bee3a3e2d2cf7095d24178c32e50f32b47149

data/lib/kompiler/arch_manager.rb

@@ -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/compiler_functions.rb

@@ -5,222 +5,35 @@ 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 = []
-	
-	instr_adr = 0
+	add_later_directives = []
 	
-	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 +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
@@ -246,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
@@ -280,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)			
@@ -351,17 +254,9 @@ def self.compile(code, included_files=[])
 
 	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)	
+	parsed_lines = parse_code(lines)
 	
-#	machine_code_bit_lines = construct_program_mc(parsed_lines, labels)
-#
-#	machine_code_bytes = bit_lines_to_bytes(machine_code_bit_lines)	
+	labels = get_labels(parsed_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