kompiler 0.0.0

data/lib/kompiler/compiler_functions.rb

@@ -0,0 +1,262 @@
+# Copyright 2024 Kyrylo Shyshko
+# Licensed under the Apache License, Version 2.0. See LICENSE file for details.
+
+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
+
+
+
+def self.parse_code(lines)	
+	
+	parsed_lines = []
+	
+	instr_adr = 0
+	
+	lines.each_with_index do |line, line_i|
+		
+		# Check if line is not just whitespace
+		is_char_whitespace = line.each_char.map{|c| [" ", "\t"].include? c}
+		if !is_char_whitespace.include?(false) # If only whitespace
+			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
+			
+			next # Go to the next line
+		end
+		
+		
+		is_directive, directive_hash = Kompiler::Parsers.check_directive(line)
+		if is_directive
+			directive = directive_hash[:directive]
+			operands = directive_hash[:operands]
+			
+			state = {current_address: instr_adr, parsed_lines: parsed_lines}
+			
+			state = directive[:func].call(operands, state)
+		
+			instr_adr = state[:current_address]
+			parsed_lines = state[:parsed_lines]
+			
+			next # Skip to the next lime
+		end
+		
+		
+		# Line wasn't classified
+		# Throw an error
+		
+		raise "\"#{line}\" - Unknown syntax: Program build not possible"
+		
+	end
+	
+	parsed_lines
+end
+
+
+def self.get_labels(parsed_lines)
+
+	label_definitions = parsed_lines.filter{|line| line[:type] == "label"}
+	
+	labels_hash = Hash.new
+	
+	label_definitions.each do |label_def|
+		if labels_hash.keys.include?(label_def[:label_name])
+			puts "Warning: Label #{label_def[:label_name]} was aleady defined. Label is now re-defined"
+		end
+		
+		labels_hash[label_def[:label_name]] = label_def[:label_address]
+	end
+
+	labels_hash
+end
+
+
+def self.construct_program_mc(parsed_lines, labels)
+	
+	lines_bytes = ""
+	
+	
+	program_state = {labels: labels, current_address: 0}
+	
+	parsed_lines.each do |line|
+		case line[:type]
+		when "instruction"
+			program_state[:operands] = line[:operands]
+			program_state[:current_address] = line[:address]
+			
+			mc_constructor = line[:instruction][:mc_constructor]
+			
+			instr_bits = Kompiler::MachineCode_AST.build_mc(mc_constructor, program_state)			
+
+			instr_bytes = bits_to_bytes(instr_bits)
+			
+			lines_bytes += instr_bytes.map(&:chr).join
+		when "insert"
+			if line[:bits]
+				lines_bytes += bits_to_bytes(line[:bits]).map(&:chr).join
+			elsif line[:bytes]
+				lines_bytes += line[:bytes].map(&:chr).join
+			elsif line[:byte_string]
+				lines_bytes += line[:byte_string]
+			end
+		end
+	end
+	
+	lines_bytes
+end
+
+
+def self.bits_to_bytes(bits)
+
+	bit_byte_groups = (0...(bits.size / 8)).map{|byte_i| bits[(byte_i * 8)...(byte_i * 8 + 8)] }
+
+	bytes = []
+
+
+	bit_byte_groups.each do |byte_bits|
+		byte_val = 0
+		byte_bits.each_with_index do |bit, bit_i|
+			byte_val += bit * 2 ** bit_i
+		end
+		bytes << byte_val
+	end
+
+	bytes
+end
+
+
+def self.bit_lines_to_bytes(bit_lines)
+	
+	bits_flat = bit_lines.flatten
+	
+	bit_byte_groups = (0...(bits_flat.size / 8)).map{|byte_i| bits_flat[(byte_i * 8)...(byte_i * 8 + 8)] }
+	
+	bytes = []
+	
+	bit_byte_groups.each do |byte_bits|
+		byte_val = 0
+		
+		byte_bits.each_with_index do |bit, bit_index|
+			byte_val += bit * 2 ** bit_index
+		end
+		
+		bytes << byte_val
+	end
+	
+	bytes
+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)	
+	
+#	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
+
+
+end # Kompiler::CompilerFunctions
+
+end # Kompiler

data/lib/kompiler/directives.rb

@@ -0,0 +1,167 @@
+# Copyright 2024 Kyrylo Shyshko
+# Licensed under the Apache License, Version 2.0. See LICENSE file for details.
+
+module Kompiler
+
+class Directives
+
+def self.directives
+	@@DIRECTIVES
+end
+
+@@DIRECTIVES = [
+	{
+		keyword: "zeros",
+		func: lambda do |operands, state|
+			raise "Incorrect use of the \"zeros\" directive." if operands.size > 1 || (operands[0] && operands[0][:type] != "immediate")
+			n_zeros = operands[0][:value]
+			state[:current_address] += n_zeros
+			state[:parsed_lines] << {type: "insert", bits: (n_zeros*8).times.map{0} }
+			state
+		end
+	},
+	{
+		keyword: "ascii",
+		func: lambda do |operands, state|
+			raise "Incorrect use of the \"ascii\" directive." if operands.size > 1 || (operands[0] && operands[0][:type] != "string")
+			
+			insert_bytes = operands[0][:string].encode("ascii").bytes
+			insert_bits = insert_bytes.map{|byte| 8.times.map{|bit_i| byte[bit_i]}}.flatten
+			
+			state[:parsed_lines] << {type: "insert", bits: insert_bits, address: state[:current_address]}
+			state[:current_address] += insert_bytes.size
+			
+			state
+		end
+	},
+	{
+		keyword: "align",
+		func: lambda do |operands, state|
+			raise "Incorrect use of the \"align\" directive." if operands.size > 1 || (operands[0] && operands[0][:type] != "immediate")
+			
+			alignment = operands[0][:value]
+			to_add = alignment - (state[:current_address] % alignment)			
+			
+			# If aligned, do nothing
+			return state if to_add == alignment
+			
+			# Else add stuff
+			
+			state[:current_address] += to_add
+			state[:parsed_lines] << {type: "insert", bits: (to_add * 8).times.map{0} }
+			
+			state
+		end
+	},
+	{
+		keyword: "label",
+		func: lambda do |operands, state|
+			
+			raise "Incorrect use of the \"label\" directive." if (operands.size < 1 || operands.size > 2) || (operands[0] && operands[0][:type] != "label")
+			
+			raise "Incorrect use of the \"label\" directive: second argument must be an immediate value" if operands[1] && operands[1][:type] != "immediate"
+			
+			label_name = operands[0][:value]
+			
+			# If a second argument is provided, use it as the label value; otherwise use the current instruction address (PC)
+			if operands[1] && operands[1][:type] == "immediate"
+				label_value = operands[1][:value]
+			else
+				label_value = state[:current_address]
+			end
+			
+			# Add the label definition
+			state[:parsed_lines] << {type: "label", label_name: label_name, label_address: label_value, address: state[:current_address]}
+			
+			state
+		end
+	},
+	{
+		keyword: "8byte",
+		func: lambda do |operands, state|
+			
+			raise "Incorrect use of the \"8byte\" directive." if (operands.size != 1) || (operands[0] && operands[0][:type] != "immediate")			
+			
+			value = operands[0][:value]
+			
+			value_bits = (0...(8 * 8)).map{|bit_i| value[bit_i]}
+			
+			# Insert 64 bits of the value into the program
+			state[:current_address] += 8
+			state[:parsed_lines] << {type: "insert", bits: value_bits}
+			
+			state
+		end
+	},
+	{
+		keyword: "4byte",
+		func: lambda do |operands, state|
+			
+			raise "Incorrect use of the \"4byte\" directive." if (operands.size != 1) || (operands[0] && operands[0][:type] != "immediate")			
+			
+			value = operands[0][:value]
+			
+			value_bits = (0...(4 * 8)).map{|bit_i| value[bit_i]}
+			
+			# Insert 64 bits of the value into the program
+			state[:current_address] += 4
+			state[:parsed_lines] << {type: "insert", bits: value_bits}
+			
+			state
+		end
+	},
+	{
+		keyword: "bytes",
+		func: lambda do |operands, state|
+			
+			raise "Incorrect use of the \"bytes\" directive." if (operands.size != 2) || (operands[0][:type] != "immediate" && operands[1][:type] != "immediate")			
+			
+			n_bytes = operands[0][:value]
+			value = operands[1][:value]
+			
+			value_bits = (0...(n_bytes * 8)).map{|bit_i| value[bit_i]}
+			
+			# Insert the input amount of bytes of the value into the program
+			state[:current_address] += n_bytes
+			state[:parsed_lines] << {type: "insert", bits: value_bits}
+			
+			state
+		end
+	},
+	{
+		keyword: "set_pc",
+		func: lambda do |operands, state|
+			
+			raise "Incorrect use of the \"set_pc\" directive." if (operands.size != 1) || (operands[0][:type] != "immediate")			
+			
+			new_pc = operands[0][:value]
+
+			state[:current_address] = new_pc
+			
+			state
+		end
+	},
+	{
+		keyword: "insert_file",
+		func: lambda do |operands, state|
+			raise "Incorrect use of the \"insert_file\" directive" if (operands.size != 1) || (operands[0][:type] != "string")
+
+			filename = operands[0][:string]
+
+			file_content = ""
+			File.open(filename, "rb") do |f|
+				file_content = f.read()
+			end
+
+			state[:current_address] += file_content.bytes.size
+			state[:parsed_lines] << {type: "insert", byte_string: file_content}
+
+			state
+		end
+	}
+]
+
+
+end # Kompiler::Directives
+
+end # Kompiler

data/lib/kompiler/mc_builder.rb

@@ -0,0 +1,88 @@
+# Copyright 2024 Kyrylo Shyshko
+# Licensed under the Apache License, Version 2.0. See LICENSE file for details.
+
+module Kompiler
+
+class MachineCode_AST
+
+MC_AST_NODES = [
+	{name: "get_operand", n_args: 1, func: lambda {|args, state| state[:operands][args[0]][:value]} },
+	{name: "get_bits", n_args: 3, func: lambda {|args, state| (args[1]...(args[1] + args[2])).map{|bit_i| args[0][bit_i]} } },
+	{name: "get_bits_signed", n_args: 3, func: lambda do |args, state|
+		if args[1] == 0
+			# If sign should be included
+			(args[0] >= 0 ? [0] : [1]) + (0...(args[2] - 1)).map{|bit_i| args[0].abs[bit_i]}
+		else
+			# If sign shouldn't be included, since the bit range omits it
+			((args[1] - 1)...(args[1] + args[2] - 1)).map{|bit_i| args[0].abs[bit_i]}
+		end
+	end},
+	{name: "reverse", n_args: 1, func: lambda {|args, state| args[0].reverse } },
+	{name: "encode_gp_register", n_args: 1, func: lambda {|args, state| args[0][:reg_value] } },
+	{name: "add", n_args: 2, func: lambda {|args, state| args[0] + args[1] } },
+	{name: "subtract", n_args: 2, func: lambda {|args, state| args[0] - args[1] } },
+	{name: "multiply", n_args: 2, func: lambda {|args, state| args[0] * args[1] } },
+	{name: "divide", n_args: 2, func: lambda {|args, state| args[0] / args[1] } },
+	{name: "modulo", n_args: 2, func: lambda {|args, state| args[0] % args[1] } },
+	{name: "get_current_address", n_args: 0, func: lambda {|args, state| state[:current_address] } },
+	{name: "get_label_address", n_args: 1, func: lambda {|args, state| state[:labels].include?(args[0]) ? state[:labels][args[0]] : raise("Label \"#{args[0]}\" not found: Program build not possible") } },
+	{name: "bits", n_args: "any", func: lambda {|args, state| args } },
+	{name: "if_eq_else", n_args: 4, eval_args: false, func: lambda {|args, state| (eval_mc_node_arg(args[0], state) == eval_mc_node_arg(args[1], state)) ? eval_mc_node_arg(args[2], state) : eval_mc_node_arg(args[3], state) }},
+	{name: "raise_error", n_args: 1, func: lambda {|args, state| raise args[0] } },
+]
+
+def self.is_ast_node(val)
+	val.is_a?(Array) && (val.size >= 1) && val[0].is_a?(String)
+end
+
+# If an argument is a node, evaluates it. Otherwise just returns the argument
+def self.eval_mc_node_arg(arg, state)
+	is_ast_node(arg) ? run_mc_ast(arg, state) : arg
+end
+
+def self.run_mc_ast(node, state)
+	
+	node_name = node[0]
+	node_args = node[1..]
+	
+	node_logic = MC_AST_NODES.filter{|any_node| any_node[:name] == node_name}[0]
+	
+	if !node_logic
+		raise "MC Node \"#{node_name}\" wasn't found. Cannot build the program"
+	end
+	
+	if !node_logic.keys.include?(:eval_args) || node_logic[:eval_args] != false
+		node_args.map!{|arg| eval_mc_node_arg(arg, state) }
+	end
+	
+	raise "Undefined node \"#{node_name}\"" if !node_logic
+	
+	# Check if the amount of arguments is correct for the node
+	raise "Incorrect node use for \"#{node_name}\": Expected #{node_logic[:n_args]} operands, but received #{node_args.size}" if (node_logic[:n_args] != "any") && (node_logic[:n_args] != node_args.size)
+	
+	node_logic[:func].call(node_args, state)
+end
+
+
+def self.build_mc(mc_constructor, state)
+	final = []
+	mc_constructor.each do |ast_node|		
+		
+		ast_result = run_mc_ast(ast_node, state)
+		
+		# Check if ast_result is only zeros and ones
+		is_element_zero_or_one = ast_result.map{|el| [0, 1].include?(el)}
+		if is_element_zero_or_one.include?(false)
+			raise "MC AST Build resulted in a non-bit value (#{ast_result}): Cannot build the program"
+		end
+		
+		final += ast_result
+	end
+	
+	return final
+end
+
+
+end # Kompiler::MC_AST
+
+end # Kompiler