kompiler 0.3.0.pre.3 → 0.3.0

data/lib/kompiler/mc_builder.rb

@@ -1,6 +1,37 @@
 # Copyright 2024 Kyrylo Shyshko
 # Licensed under the Apache License, Version 2.0. See LICENSE file for details.
 
+#
+# Implements a custom AST structure and interpreter for instructions on how to build the instruction's machine code (MC).
+#
+# @MC_AST_NODES contains a list of all available instructions / AST nodes for building machine code.
+# Each entry's structure is:
+#  name - contains the node's / instruction's name
+#  n_args - either an integer or "any". Contains the amount of arguments this instruction must receive.
+#  func - a lambda receiving the arguments and the current program's state as inputs. Should output the instruction's result.
+#  eval_args - optional, default true. Specifies whether to pre-evaluate the node's arguments.
+#
+# A MC instruction example:
+# ["get_bits", ["get_current_address"], 0, 10]
+# Which returns an array of ten integers, or bits, of the current address.
+# 
+# Each MC instruction is in the form of an array with a string, the instruction's name, as the first element.
+# All other elements will count as arguments.
+# For most nodes, the arguments will be evaluated / computed before calling the node's logic. For example, in:
+# ["get_bits", ["get_current_address"], 0, 10]
+# ["get_current_address"] will be evaluted first, and then the result will be passed into get_bits. This is similar to a Ruby piece of code like this:
+# get_bits(get_current_address(), 0, 10)
+#
+# In more special nodes that have eval_args = false, such as the if_eq_else node, the arguments aren't pre-evaluated, which is required in an if-statement scenario. E.g., an error shouldn't be thrown before a check that the error must be raised.
+#
+#
+# Main functions are:
+#  build_mc - builds machine code from an input AST
+#  run_mc_ast - runs an MC AST node
+#  is_ast_node - returns if an object is an AST node, by checking whether it is an array with the first element being a string
+#
+
+
 module Kompiler
 
 module MachineCode_AST
@@ -44,6 +75,13 @@ module MachineCode_AST
 	{name: "raise_warning", n_args: 1, func: lambda {|args, state| puts args[0]; [] } },
 	
 	{name: "get_key", n_args: 2, func: lambda {|args, state| args[0].keys.include?(args[1]) ? args[0][args[1]] : raise("MC Constructor get_key Error: The key \"#{args[1]}\" doesn't exist - Program build not possible. This is likely a problem with the ISA configuration, not the program being compiled.") }},
+
+	# Concatenation of get_key and get_operand through get_key(get_operand(arg1), arg2)
+	{name: "get_operand_key", n_args: 2, func: lambda do |args, state|
+		op = state[:operands][args[0]][:value]
+		op.keys.include?(args[1]) ? op[args[1]] : raise("MC Constructor get_operand_key Error: key \"#{args[1]}\" doesn't exist. This is likely an error with the ISA configuration, not the program being compiled.")
+	end},
+
 	{name: "concat", n_args: "any", func: lambda {|args, state| args.flatten}},
 	{name: "set_var", n_args: 2, func: lambda {|args, state| state[:instruction_variables][args[0]] = args[1]; [] }},
 	{name: "get_var", n_args: 1, func: lambda {|args, state| state[:instruction_variables].keys.include?(args[0]) ? state[:instruction_variables][args[0]] : raise("Instruction variable \"#{args[0]}\" not found: Program build not possible. This is likely a program with the ISA configuration, not the program being compiled.") }},
@@ -54,6 +92,16 @@ module MachineCode_AST
 	# Bit manipulations
 	{name: "bit_and", n_args: 2, func: lambda {|args, state| args[0] & args[1] }},
 	{name: "bit_or", n_args: 2, func: lambda {|args, state| args[0] | args[1] }},
+
+	# Ensure equality between all arguments. Last argument provides the error message if not equal
+	{name: "ensure_eq", n_args: "any", func: lambda do |args, state|
+		args[1...-1].each do |arg|
+			if args[0] != arg
+				raise args.last
+			end
+		end
+		[]
+	end}
 ]
 
 def self.is_ast_node(val)

data/lib/kompiler/parsers.rb

@@ -1,6 +1,27 @@
 # Copyright 2024 Kyrylo Shyshko
 # Licensed under the Apache License, Version 2.0. See LICENSE file for details.
 
+#
+# Implements generic parsers used everywhere and checks specific to the compilation process
+# 
+# Functions:
+#  parse_str - parses a string definition from the input text, and returns the amount of characters parsed and the string's contents
+#  get_code_lines - parses the initial raw code text into lines, removing comments along the way
+#  
+# Compilation specific functions:
+#  check_instruction - checks whether a line is a valid instruction with the current architecture (Kompiler::Architecture)
+#  check_directive - checks whether a line is a directive call
+#  
+#  parse_instruction_line - parses an instruction line into its keyword (string) and operands with their descriptions (e.g., type of operand, content, value)
+#  extract_instruction_parts - parses an instruction line into a string keyword and a list of operand definitions (used by parse_instruction_line)
+#  extract_instruction_operands - parses the string after the keyword to extract only the operand definitions (used by extract_instruction_parts)
+#  parse_operand_str - parses an operand definition (raw string) into its type, value, and other type-dependent information (uses check_register_operand, check_immediate_operand, check_expression_operand, check_label_operand)
+#  check_operand_match - checks whether an operand's info (returned by parse_operand_str) matches the input operand description. Operand descriptions are mostly stored in instruction files (e.g., lib/kompiler/architectures/armv8a/instructions.rb) in the :operands key
+#  match_parsed_line_to_instruction - checks whether a parsed instruction line (keyword + operand info) matches an instruction entry, mostly stored in instruction files (example one line above) (used by check_instruction)
+#
+#
+
+
 module Kompiler
 
 module Parsers
@@ -171,6 +192,29 @@ def self.check_char_operand(str)
 end
 
 
+def self.check_expression_operand(str)
+	begin
+		
+		ast = Kompiler::Parsers::SymAST.parse str
+		
+		run_block = lambda do |state|
+			state[:labels]["here"] = state[:current_address]
+			
+			ast_result = Kompiler::Parsers::SymAST.run_ast state[:block_args][:ast], state[:labels], []
+			
+			return {type: "immediate", value: ast_result, def_type: "sym_ast", definition: state[:block_args][:definition]}
+		end
+		
+		return [true, {type: "run_block", block: run_block, block_args: {ast: ast, definition: str}, block_output_type: "immediate"}]
+		
+	rescue RuntimeError => e
+		p e
+		# If an error was caused, return false
+		return [false, nil]
+	end
+
+end
+
 
 def self.check_immediate_operand(operand_str)
 	
@@ -231,45 +275,22 @@ def self.parse_operand_str(operand_str)
 	return {type: "label", value: operand_str, definition: operand_str} if is_label
 	
 	
+	is_expr, expr_operand = check_expression_operand(operand_str)
+	return expr_operand if is_expr
+	
 	# If no checks succeeded, return false
 	return false
 end
 
-
-
-
-def self.parse_instruction_line(line)
-	keyword = ""
+# Extract operand strings from the structure "op1, op2, op3, ..."
+# Returns an array of the operand strings
+def self.extract_instruction_operands(line)
 	i = 0
-	
-	# Loop until a non-whitespace character
-	while i < line.size
-		break if ![" ", "\t"].include?(line[i])
-		i += 1
-	end
-
-	# Loop to get the keyword
-	loop do
-		# Exit out of the loop if the character is a whitespace
-		break if [" ", "\t"].include?(line[i]) || i >= line.size
-		# Add the character if not a whitespace
-		keyword << line[i]
-		# Proceed to the next character
-		i += 1	
-	end
-
 	operand_strings = []
 	
-	# Loop for operands
 	loop do
 		break if i >= line.size
-
-		# # Whitespace - skip
-		# if [" ", "\t"].include? line[i]
-		# 	i += 1
-		# 	next
-		# end
-
+		
 		operand_content = ""
 		
 		# Collect the operand's content until a comma or end of line
@@ -283,13 +304,13 @@ def self.parse_instruction_line(line)
 			end
 			
 			# Skip whitespace
-			if [" ", "\t"].include? line[i]
+			if Kompiler::Config.whitespace_chars.include? line[i]
 				i += 1
 				next
 			end
 			
 			# If a string definition, parse to the end of the string
-			if ["\"", "'"].include?(line[i])
+			if Kompiler::Config.string_delimiters.include?(line[i])
 				str_content, parsed_size = parse_str(line[i..])
 				operand_content += line[i] + str_content + line[i]
 				i += parsed_size
@@ -305,7 +326,45 @@ def self.parse_instruction_line(line)
 		
 		# After operand content was collected, add it to the list of operands if the content isn't empty
 		operand_strings << operand_content if operand_content.size != 0
-	end	
+	end
+
+	operand_strings
+end
+
+
+def self.extract_instruction_parts(line)
+
+	keyword = ""
+	i = 0
+	
+	# Loop until a non-whitespace character
+	while i < line.size
+		break if !Kompiler::Config.whitespace_chars.include?(line[i])
+		i += 1
+	end
+	
+	# Loop to get the keyword
+	loop do
+		# Exit out of the loop if the character is a whitespace
+		break if Kompiler::Config.whitespace_chars.include?(line[i]) || i >= line.size
+		# Add the character if not a whitespace
+		keyword << line[i]
+		# Proceed to the next character
+		i += 1	
+	end
+	
+	operand_strings = extract_instruction_operands(line[i..])
+	
+	# Loop for operands
+	
+	return keyword, operand_strings
+end
+
+
+
+def self.parse_instruction_line(line)
+	
+	keyword, operand_strings = extract_instruction_parts(line)
 	
 	# Parse operand strings into operand types and values
 	
@@ -324,8 +383,12 @@ end
 
 def self.check_operand_match(operand_description, operand)
 
-	# If operand type doesn't not match, return false
-	return false if operand[:type] != operand_description[:type]
+	if operand[:type] == "run_block" # A special check for a run block
+		return false if operand[:block_output_type] != operand_description[:type]
+	else
+		# If operand type doesn't not match, return false
+		return false if operand[:type] != operand_description[:type]
+	end
 
 	# Get the restrictions
 	operand_restrictions = operand_description[:restrictions]
@@ -337,6 +400,8 @@ def self.check_operand_match(operand_description, operand)
 		operand_encoding = operand[:value]
 	when "immediate"
 		operand_encoding = operand[:value]
+	when "run_block"
+		operand_encoding = Hash.new
 	when "string"
 		operand_encoding = Hash.new
 	end
@@ -418,12 +483,20 @@ end
 
 
 def self.check_directive(line)
-	status = parse_instruction_line(line)
-
-	return [false, nil] if status == false
-
-	keyword, operands = status
-
+	# Skip whitespace
+	char_i = 0
+	while char_i < line.size && Kompiler::Config.whitespace_chars.include?(line[char_i])
+		char_i += 1
+	end
+	
+	# Collect the keyword
+	keyword = ""
+	
+	while char_i < line.size && Kompiler::Config.keyword_chars.include?(line[char_i])
+		keyword << line[char_i]
+		char_i += 1
+	end
+	
 	if keyword[0] == "."
 		keyword = keyword[1..]
 	end
@@ -431,16 +504,35 @@ def self.check_directive(line)
 	directive = nil
 	
 	Kompiler::Directives.directives.each do |curr_directive|
-		if curr_directive[:keyword] == keyword
-			directive = curr_directive
-			break
+		if curr_directive[:keyword].is_a? String
+			if curr_directive[:keyword] == keyword
+				directive = curr_directive
+				break
+			end
+		elsif curr_directive[:keyword].is_a? Array
+			if curr_directive[:keyword].include? keyword
+				directive = curr_directive
+				break
+			end
+		else
+			raise "Directive name error"
 		end
 	end
 	
 	if directive == nil
 		return [false, nil]
+	end
+	
+	# Check if the directive requires pre-collected operands (with the :collect_operands key that is true by default)
+	if !directive.keys.include?([:collect_operands]) || directive[:collect_operands] == true
+		parse_status, operands = parse_instruction_line(line)
+		
+		return [false, nil] if parse_status == false # Return negative if operands can't be parsed
+		
+		return [true, {directive: directive, operands: operands}] # Otherwise, return the directive
 	else
-		return [true, {directive: directive, operands: operands}]
+		# If operand collection isn't required, return the directive
+		return [true, {directive: directive, operands: []}]
 	end
 end