kompiler 0.3.0.pre.2 → 0.3.0.pre.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c7b411e21f2b93443cb22e7461437c8ab98df8acc4fd56538d64c8fc0d7c828
-  data.tar.gz: 05747db808c1d5accc8b42ee6681b2a617feb89437bf244e389420740a3d4da0
+  metadata.gz: d37e70a65615ea1b7aece9de1a2ae544a30d9f3f9f1f44d233fac8ecde023b63
+  data.tar.gz: 533a6ac4a19a03c8ca483c63bf454d4cda802943462ea23bcbc1a59688e64d8d
 SHA512:
-  metadata.gz: 0a302052eb6c01c1f6812e98b8492fc455077746effb6e6d6133a411eb179b157ecf3bc1a4bcd38e85e1a1dc2aea52dee4cfd7088b9212b73df6f0912ac9d1fc
-  data.tar.gz: af2d6fb1f53eae49d7121fc90048d1bc5766316bc302fd910bc1702cf4dab3f43fd09ee01433fbb11f8ec4419de7191a0cc02fd64bb43f8c998173c78acc0237
+  metadata.gz: ad275ed1d7bbb7dad29409b3ca2f4e061c08f4534bf7c2104d2c20c235a1030e496ae6381322042fe1d1bdd699acc5e970ef82b521031853d4222792b6bf388f
+  data.tar.gz: 9132f9c232bc01ff2ebfac62bfa09527e79f644ce0d15a360de91ece0a854187da581b6e67c2bec78e6745845fb2257c759786d71e02d44f17fbf4919e7e106c

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)

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,7 +3,7 @@
 
 module Kompiler
 
-class CompilerFunctions
+module CompilerFunctions
 
 def self.parse_includes(lines, loaded_files=[])
 	
@@ -83,6 +83,113 @@ def self.parse_includes(lines, loaded_files=[])
 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)	
 	
@@ -97,7 +204,7 @@ def self.parse_code(lines)
 		if !is_char_whitespace.include?(false) # If only whitespace
 			next # Skip
 		end
-	
+		
 		#
 		# Label definitions are now a directive, so this isn't needed
 		#
@@ -243,17 +350,19 @@ 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)
+	
+	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)	
 	
 #	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/parsers.rb

@@ -3,7 +3,7 @@
 
 module Kompiler
 
-class Parsers
+module Parsers
 
 def self.parse_str(code)
 
@@ -195,7 +195,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)}
 	
@@ -366,10 +366,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 +395,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

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.3
 platform: ruby
 authors:
 - Kyryl Shyshko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-23 00:00:00.000000000 Z
+date: 2025-01-17 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