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

data/lib/kompiler/parsers.rb

@@ -3,7 +3,7 @@
 
 module Kompiler
 
-class Parsers
+module Parsers
 
 def self.parse_str(code)
 
@@ -171,6 +171,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)
 	
@@ -195,7 +218,7 @@ def self.check_label_operand(str)
 	return false if ("0".."9").to_a.include?(str[0])
 
 	# Check if it's only made up of allowed characters
-	allowed_chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["_"] 
+	allowed_chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["_", "."]
 	
 	is_each_char_allowed = str.each_char.map{|c| allowed_chars.include?(c)}
 	
@@ -231,45 +254,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 +283,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 +305,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 +362,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 +379,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
@@ -366,10 +410,9 @@ end
 
 # Returns array of [status, operands]
 # If status = false, operands = nil; otherwise, status = true, operands = instruction operands
-def self.match_instruction(line, instruction)
-
-	keyword, operands = parse_instruction_line(line)
+def self.match_parsed_line_to_instruction(parsed_line, instruction)
 
+	keyword, operands = parsed_line
 
 	# Check if the keyword matches
 	if instruction[:keyword] != keyword
@@ -396,9 +439,12 @@ def self.check_instruction(line)
 	instruction = nil
 	operands = nil
 	
+	parsed_line = Kompiler::Parsers.parse_instruction_line(line)
+	
 	Kompiler::Architecture.instructions.each do |curr_instruction|
 		# If the instruction matches - break
-		status, curr_operands = match_instruction(line, curr_instruction)
+		
+		status, curr_operands = match_parsed_line_to_instruction(parsed_line, curr_instruction)
 		if status == true
 			instruction = curr_instruction
 			operands = curr_operands
@@ -416,12 +462,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
@@ -429,16 +483,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
 

data/lib/kompiler.rb

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'kompiler/config.rb'
 require 'kompiler/mc_builder.rb'
 require 'kompiler/parsers.rb'
 require 'kompiler/compiler_functions.rb'
 require 'kompiler/architecture.rb'
 require 'kompiler/directives.rb'
-require 'kompiler/arch_manager.rb'
+require 'kompiler/arch_manager.rb'
+require 'kompiler/math_ast.rb'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kompiler
 version: !ruby/object:Gem::Version
-  version: 0.3.0.pre.2
+  version: 0.3.0.pre.4
 platform: ruby
 authors:
 - Kyryl Shyshko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-23 00:00:00.000000000 Z
+date: 2025-02-28 00:00:00.000000000 Z
 dependencies: []
 description: 'Kompiler is a low-level, modular and extendable compiler for any architecture.
   By default Kompiler supports ARMv8-a, but other architecture extensions can be downloaded
@@ -33,7 +33,9 @@ files:
 - lib/kompiler/architectures/armv8a/sys_instructions.rb
 - lib/kompiler/architectures/armv8a/sys_registers.rb
 - lib/kompiler/compiler_functions.rb
+- lib/kompiler/config.rb
 - lib/kompiler/directives.rb
+- lib/kompiler/math_ast.rb
 - lib/kompiler/mc_builder.rb
 - lib/kompiler/parsers.rb
 homepage: https://github.com/kyryloshy/kompiler