kompiler 0.3.0.pre.4 → 0.3.1

data/lib/kompiler/architectures/armv8a/simd_fp_registers.rb

@@ -0,0 +1,23 @@
+# Copyright 2024 Kyrylo Shyshko
+# Licensed under the Apache License, Version 2.0. See LICENSE file for details.
+
+module Kompiler
+
+module ARMv8A
+
+def self.simd_fp_registers
+	@simd_fp_registers
+end	
+
+@simd_fp_registers = [
+	
+]
+
+(0..31).each do |reg_i|
+	@simd_fp_registers << {reg_name: "q#{reg_i}", reg_type: "simd_fp_reg", re_num: reg_i}
+end
+
+
+end # Kompiler::ARMv8A
+
+end # Kompiler

data/lib/kompiler/architectures/armv8a/sys_registers.rb

@@ -54,6 +54,9 @@ end
 	
 	{reg_name: "ISR_EL1", reg_size: 64, reg_type: "sr", reg_encoding: {"op0"=>0b11, "op1"=>0b000, "CRn"=>0b1100, "CRm"=>0b0001, "op2"=>0b000}},
 	
+	{reg_name: "CPACR_EL1", reg_size: 64, reg_type: "sr", reg_encoding: {"op0"=>0b11, "op1"=>0b000, "CRn"=>0b0001, "CRm"=>0b0000, "op2"=>0b010}},
+	{reg_name: "CPACR_EL12", reg_size: 64, reg_type: "sr", reg_encoding: {"op0"=>0b11, "op1"=>0b101, "CRn"=>0b0001, "CRm"=>0b0000, "op2"=>0b010}},
+	
 	# Special registers for the MSR (immediate) instruction (some of them were previously defined already)
 	{reg_name: "SPSel", reg_type: "pstate_reg"},
 	{reg_name: "DAIFSet", reg_type: "pstate_reg"},

data/lib/kompiler/compiler_functions.rb

@@ -1,6 +1,16 @@
 # Copyright 2024 Kyrylo Shyshko
 # Licensed under the Apache License, Version 2.0. See LICENSE file for details.
 
+#
+# Implements main logic happening during compilation.
+# Main functions:
+#  parse_code - main code parser that turns all lines into an abstract structure (determining types of lines and connecting them into a program)
+#  construct_program_mc - transforms the parse_code's AST into machine code (MC)
+#  detailed_compile - stitches parse_code and construct_program_mc to fully compile a program with a detailed output
+#  compile - calls detailed_compile and removes the extra output information
+#
+
+
 module Kompiler
 
 module CompilerFunctions
@@ -138,8 +148,11 @@ def self.parse_code(lines)
 		
 		parsed_lines = state[:parsed_lines] + parsed_lines[insert_i..]
 	end
-	
-	parsed_lines
+
+
+	state = {parsed_lines: parsed_lines, current_address: instr_adr, lines: lines, line_i: line_i, extra_state: extra_state}
+
+	return state
 end
 
 
@@ -204,7 +217,7 @@ def self.construct_program_mc(parsed_lines, labels)
 			end
 		end
 	end
-	
+
 	lines_bytes
 end
 
@@ -250,15 +263,26 @@ def self.bit_lines_to_bytes(bit_lines)
 end
 
 
-def self.compile(code, included_files=[])
+def self.compile(code)
+	detailed_result = detailed_compile(code)
+
+	return detailed_result[:machine_code]
+end
 
+def self.detailed_compile(code)
 	lines = Kompiler::Parsers.get_code_lines(code)
-	
-	parsed_lines = parse_code(lines)
-	
+
+	parsed_state = parse_code(lines)
+
+	# pp parsed_state
+
+	parsed_lines = parsed_state[:parsed_lines]
+
 	labels = get_labels(parsed_lines)
-	
+
 	machine_code_bytes = construct_program_mc(parsed_lines, labels)
+
+	return {machine_code: machine_code_bytes, labels: labels, parsed_state: parsed_state}
 end
 
 

data/lib/kompiler/config.rb

@@ -1,10 +1,21 @@
+
+# 
+# Contains config options for how Kompiler interprets different characters.
+# 
+# Main config options:
+#  keyword_chars - list of characters that a keyword can contain
+#  label_chars - list of characters that a label name can contain
+#  whitespace_chars - list of characters that qualify as whitespace / separators of words
+#  string_delimiters - a list of characters that denote the start and end of a string
+#
+
 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"]
+		@whitespace_chars = [" ", "\t", "\r"]
 		@string_delimiters = ['"', "'"]
 		
 		# Returns the permittable keyword characters

data/lib/kompiler/directives.rb

@@ -1,6 +1,19 @@
 # Copyright 2024 Kyrylo Shyshko
 # Licensed under the Apache License, Version 2.0. See LICENSE file for details.
 
+#
+# Implements all directives available in programs.
+#
+# Kompiler::Directives.directives is a list of all available directives.
+#
+# An entry's structure is:
+#  keyword - string or list of strings specifying the keywords by which the directive can be accessed.
+#  func - a Ruby lambda that receives the call operands and current state as arguments, and outputs the new state.
+#  collect_operands - optional (default is true). Specifies whether the operands should be parsed before calling the :func key lambda.
+#                     If false, operands will be a raw string containing the string after the keyword.
+#
+
+
 module Kompiler
 
 module Directives

data/lib/kompiler/math_ast.rb

@@ -1,3 +1,31 @@
+
+#
+# Implements logic to parse math-like expressions into an ASTs.
+#
+# Main functions:
+#  str_to_ast - converts a raw string into an AST.
+#  run_ast - runs the AST created by str_to_ast.
+#
+# Config options are available in Kompiler::Parsers::SymAST::Config :
+#  word_begin_chars - a list of characters that a word can begin with
+#  word_chars - a list of characters that a word can contain
+#  number_begin_chars - a list of characters that a number can begin with
+#  number_chars - a list of characters that a number can contain
+#  whitespace_chars - a list of whitespace / separator characters
+#  parse_functions - a boolean specifying whether functions with syntax func(x + 2) should be parsed or throw an error
+#  sign_types - a list of available signs, their names and character sequences that qualify as the sign.
+#               Entries appearing earlier in the list are prioritized.
+#  one_element_ast_operations - a list of one element operations, their names, sign types, and checking direction (1 for left to right, -1 for right to left).
+#                               For example, the negation "-x" is a one element operation, with the sign type "sub", and check_direction -1 (checks from right to left) because it is on the left of the 'x'
+#                               Entries appearing earlier in the list are prioritized.
+#  two_element_ast_operations - a list of two element operation 'groups'. Groups are implemented to list operations on the same priority level with the same check direction.
+#                               Each group has a check_direction (1 for left to right, -1 for opposite), and a list of operations in this group, their names and sign types, similar to one element operations.
+#                               Entries appearing earlier in the list are prioritized.
+#                               An example group could be multiplication and division. The check_direction will be 1, and there will be two operations (mul and div). This group will be below the power (a ** b) group.
+#  functions - a list of available functions in expressions in Kompiler programs
+#
+
+
 module Kompiler
 
 module Parsers
@@ -662,4 +690,4 @@ end # Kompiler::Parsers::SymAST
 
 end # Kompiler::Parsers
 
-end # Kompiler
+end # Kompiler

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