kompiler 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12bbbb642809ac234ac1cfdcd59b3d43362c0ba284a6286656fecc2cf5024e99
-  data.tar.gz: 86e653003489923b7a63bd24b0d6019b07fde08c10c8dc426357dca265b3445e
+  metadata.gz: 70dad0d1372236affa1fba712fff8b5a7d07d5cb99aa13fe41f4e39b92294901
+  data.tar.gz: 38345074dffd505b6ba7f99283bc851ed17e0d7afc7df684933e8bd3420854b6
 SHA512:
-  metadata.gz: e729dfc9ee22702200ea082beef419bdbcbaa6bc2ba5a4cadbc2899f6442c6f65c163ec90675ce8d8e2fe41cd80e97cee445fb7386547e78f5569016bbba69ed
-  data.tar.gz: d88ba4f53b56086cae6e63f8308058f3f28735f8db671d122c3eecbd3270e5443a1945407b7e8e73b15859758897992f2183481f667282fea29ee57f47f2b494
+  metadata.gz: 42997a073796509d38379a196c0caafd0dfa3e5ee3c0f588072dd936dd84220e4186a963d78f75525075d79a72d549667daaae79915f60629bdca3b51b06461e
+  data.tar.gz: 925cccfb86ddd19a56798b8af0070e7217678fa4a0d3159064057885e40790a26a3b7e07ccc4775bd2a93614f428082bab8c8b68fe13c18c191fd456a1236330

data/bin/kompile

@@ -15,7 +15,7 @@
 # limitations under the License.
 
 require 'kompiler'
-
+require 'fileutils'
 
 arg_string = ARGV.join(" ")
 
@@ -26,10 +26,18 @@ arg_letters = []
 
 current_i = 0
 
-permitted_word_chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["_", ".", "-"]
+permitted_word_chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["_", ".", "-", "[", "]"]
 
 whitespace_chars = ["\t", " "]
 
+
+$positive_opts = ["true", "yes"]
+$negative_opts = ["false", "no"]
+
+$bool_opts = $positive_opts + $negative_opts
+
+
+
 def get_word string, permitted_word_chars, offset = 0
 	if string[0] == '"'
 		str_content, n_parsed = Kompiler::Parsers.parse_str(string[offset..])
@@ -77,7 +85,17 @@ while current_i < arg_string.size
 		
 		letters, current_i = get_word(arg_string, permitted_word_chars, current_i)
 
-		arg_letters += letters.chars
+		if arg_string[current_i] == "="
+			current_i += 1
+			value, current_i = get_word(arg_string, permitted_word_chars, current_i)
+
+			arg_keys << [letters, value]
+		elsif whitespace_chars.include?(arg_string[current_i]) || current_i == arg_string.size
+			arg_letters += letters.chars
+		else
+			puts "Unrecognized argument syntax at index #{current_i}"
+			exit
+		end
 
 		next
 	end
@@ -90,6 +108,44 @@ end
 
 
 
+
+def get_number str
+	bool, val = Kompiler::Parsers.check_immediate_operand(str)
+	return (bool == false) ? nil : val
+end
+
+
+def get_arg_key arg_keys, keys, default_value=0
+	keys = [keys] if !keys.is_a?(Array)
+	filtered = arg_keys.filter{keys.include? _1[0]}[0]
+	value = (filtered != nil) ? filtered[1] : default_value
+	return value
+end
+
+
+class String
+	def to_num
+		status, val = Kompiler::Parsers.check_immediate_operand(self)
+		return (status == false) ? nil : val[:value]
+	end
+end
+
+
+def is_bool_opt opt
+	$bool_opts.include?(opt)
+end
+
+def is_pos_bool opt
+	$positive_opts.include? opt
+end
+
+def is_neg_bool opt
+	$negative_opts.include? opt
+end
+
+
+
+
 # Print the help screen if requested
 if arg_opts.include?("help") || arg_letters.include?("h")
 puts """Usage: kompile <input_file> [<output_file>] [compile_options]
@@ -100,35 +156,170 @@ Compile a file:
  output_file            Path to the output file (optional, default is out.bin)
 
 Compilation options:
- --arch=<arch_name>     Compile for the specified architecture (optional, default is armv8a)
- --wrap=<format>        Wrap the compiled program in the specified format (default is none)
+ --arch=<arch_name>, -ar    Compile for the specified architecture (optional, default is armv8a)
+ --wrap=<format>, -w        Wrap the compiled program in the specified format (default is none)
+ --no-aliases, -n           Specifies whether to use the aliases configuration file (default is yes)
+ --aliases-file=<file>, -a  Loads the provided aliases file instead of the usual one
 
 Available wrapping formats:
  none
  elf.obj
  elf.exec
  mach-o.obj
- mach-o.exec [not implemented yet]
-
+ mach-o.exec
+ 
 Additional options for wrapping are:
- --elf-machine=<type>                 Specifies ELF header's e_machine to be the type provided (default is 0)
- --elf-class=<class>                  Specifies the ELF file's class to either 32 or 64 (default is 64)
- --mach-o-machine=<cputype.subtype>   Specifies Mach-O header's cputype and subtype
-                                      to be the type provided
- --mach-o-archtype=<type>             Specifies the file architecture type to either 32 or 64 (default is 64)
+ --elf-machine=<type>, -m                Specifies ELF header's e_machine to be the type provided (default is 0)
+ --elf-class=<class>, -c                 Specifies the ELF file's class to either 32 or 64 (default is 64)
+ --mach-o-machine=<cputype.subtype>, -m  Specifies Mach-O header's cputype and subtype
+                                         to be the type provided
+ --mach-o-archtype=<type>, -t            Specifies the file architecture type to either 32 or 64 (default is 64)
+ --exec-type=<type>, -et                 Used with --wrap=mach-o.exec. Specifies whether the executable is
+                                         statically (static) or dynamically (dylink) linked (default is dylink)
+ --mach-o-threadstate=<type>, -ts        Used with --wrap=mach-o.exec and --exec-type=static. Specifies which
+                                         thread state type to use (arm64, arm32, x86-64 or x86-32)
+ --codesign=<yes|no>, -cs                Used with --wrap=mach-o.*. Specifies whether to add a basic
+                                         code signature to the Mach-O file (default is no)
 
 Available options:
- --help, -h                 Prints this information
- --list-architectures       Lists available architectures
- --list-instructions [arch] Lists available instructions for the specified architecture
- --list-registers [arch]    Lists available registers for the specified architecture
+ --help, -h                      Prints this information
+ --list-architectures,-lar       Lists available architectures
+ --list-instructions [arch],-li  Lists available instructions for the specified architecture
+ --list-registers [arch],-lr     Lists available registers for the specified architecture
+ --list-aliases,-la              Lists instruction aliases in the current configuration
+ --compact,-c                    Used with --list-instructions or --list-registers to print compact information
+
+Available options for controlling aliases:
+ --add-alias[es] index keyword aliases    Add the specified aliases to the configuration
+ --remove-alias[es] index keyword aliases Remove the specified aliases from the configuration
+ --reset-aliases                          Resets aliases to an empty configuration
+ --import-aliases filename                Set the provided configuration as the default aliases
+ --export-aliases filename                Export the default aliases into a file
 """
 exit # Exit
 end
 
+no_aliases = arg_opts.include?("no-aliases") || arg_letters.include?("n")
+
+arg_opts.delete "no-aliases"
+arg_letters.delete "n"
+
+use_aliases = !no_aliases
+
+aliases_file = get_arg_key(arg_keys, ["aliases-file", "a"], nil)
+
+if aliases_file
+	aliases_file = File.expand_path(aliases_file)
+end
+
+if use_aliases
+	if aliases_file
+		Kompiler::AliasManager.import_aliases_file aliases_file
+	else
+		Kompiler::AliasManager.load_aliases()
+	end
+end
+
+
+if arg_opts == ["add-aliases"] || arg_opts == ["add-alias"]
+	idx = arg_words[0]
+	keyword = arg_words[1]
+	aliases = arg_words[2..]
+	if idx[0] == "[" && idx[-1] == "]"
+		idx = idx[1...-1]
+	end
+	idx = idx.to_i
+
+	Kompiler::AliasManager.add_alias idx, keyword, *aliases
+
+	if aliases_file
+		Kompiler::AliasManager.export_aliases_file aliases_file
+	else
+		Kompiler::AliasManager.save_aliases()
+	end
+	
+	exit
+end
+
+if arg_opts == ["remove-aliases"] || arg_opts == ["remove-alias"]
+	idx = arg_words[0]
+	keyword = arg_words[1]
+	aliases = arg_words[2..]
+	if idx[0] == "[" && idx[-1] == "]"
+		idx = idx[1...-1]
+	end
+	idx = idx.to_i
+
+	Kompiler::AliasManager.remove_alias idx, keyword, *aliases
+
+	if aliases_file
+		Kompiler::AliasManager.export_aliases_file aliases_file
+	else
+		Kompiler::AliasManager.save_aliases()
+	end
+	
+	exit
+end
+
+
+if arg_opts == ["reset-aliases"]
+	Kompiler::AliasManager.reset_aliases()
+	
+	if aliases_file
+		Kompiler::AliasManager.export_aliases_file aliases_file
+	else
+		Kompiler::AliasManager.save_aliases()
+	end
+	
+	exit
+end
+
+
+if arg_opts == ["import-aliases"]
+	filename = arg_words[0]
+	if filename == nil
+		puts "kompile: A file path must be provided with --aliases-import."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
+	filename = File.expand_path(filename)
+	if !File.exist?(filename)
+		puts "kompile: File \"#{filename}\" does not exist."
+		exit
+	end
+	Kompiler::AliasManager.import_aliases_file(filename)
+	Kompiler::AliasManager.save_aliases()
+
+	exit
+end
+
+if arg_opts == ["export-aliases"]
+	filename = arg_words[0]
+	if filename == nil
+		puts "kompile: A file path must be provided with --aliases-import."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
+	filename = File.expand_path(filename)
+
+	Kompiler::AliasManager.export_aliases_file(filename)
+
+	exit
+end
+
+if arg_opts.include?("list-aliases") || arg_letters == ["l", "a"]
+	max_index = Kompiler::AliasManager.aliases.map{_1[:index]}.max
+	pad_width = max_index.to_s.size + 2
+	Kompiler::AliasManager.aliases.each do |alias_entry|
+		idx_string = alias_entry[:index].to_s
+		puts "[#{idx_string}]" + " " * (pad_width - idx_string.size) + "#{alias_entry[:keyword]}: " + alias_entry[:aliases].join(" ")
+	end
+	exit
+end
+
 
 # Print the available architectures if requested
-if arg_opts == ["list-architectures"]
+if arg_opts.include?("list-architectures") || arg_letters == ["l", "a", "r"]
 	Kompiler::ArchManager.load_all_entries()
 	puts "Available architectures:"
 	
@@ -138,31 +329,82 @@ if arg_opts == ["list-architectures"]
 	exit # Exit
 end
 
-if arg_opts == ["list-instructions"]
+if arg_opts.include?("list-instructions") || arg_letters[...2] == ["l", "i"]
 	arch_name = arg_words[0] || "armv8a"
 	Kompiler::ArchManager.load_all_entries()
-	arch = Kompiler::ArchManager.get_arch(arch_name)
+	Kompiler::ArchManager.load_arch arch_name
+
+	Kompiler::AliasManager.apply_aliases()
+
+	if !(arg_opts.include?("compact") || arg_letters.include?("c"))
+
+		# Calculate the size of the index column
+		idx_col_width = [7, (Kompiler::Architecture.instructions.length + 1).to_s.size + 3].max
+
+		console_width = IO.console.winsize[1] rescue 80
+
+		desc_col_width = console_width - idx_col_width
+
+		desc_col_padding = " " * idx_col_width
 
-	require arch[:include_path]
+		Kompiler::Architecture.instructions.each_with_index do |instruction, index|
+
+			display_index = (index + 1).to_s
+
+			print "[#{display_index}]"
+
+			print " " * (idx_col_width - 2 - display_index.bytesize)
+			
+			print instruction[:keyword]
+
+			print " "
+
+			puts instruction[:operands].map{"<" + (_1[:name] || _1[:type] || "") + ">"}.join(" ")
+
+			desc = instruction[:description] || ""
+		
+			puts desc_col_padding + desc
+					
+
+			if instruction.keys.include?(:aliases) && instruction[:aliases].size > 0
+				aliases_str = "Aliases: " + instruction[:aliases].join(" ")
+				puts desc_col_padding + aliases_str
+			end
+
+			print "\n"
+		end
+
+	else
+
+		strings = []
+
+		Kompiler::Architecture.instructions.each_with_index do |instruction, index|
+			str = "#{index + 1} #{instruction[:keyword]}"
+			strings << str
+		end
+
+		puts strings.join(", ")
 
-	Kompiler::Architecture.instructions.each do |instr|
-		puts "#{instr[:keyword]} (#{instr[:operands].size} operands): #{instr[:name]}"
-		puts instr[:description]
-		puts
 	end
 
 	exit
 end
 
-if arg_opts == ["list-registers"]
+
+
+
+
+if arg_opts.include?("list-registers") || arg_letters[...2] == ["l", "r"]
 	arch_name = arg_words[0] || "armv8a"
 	Kompiler::ArchManager.load_all_entries()
-	arch = Kompiler::ArchManager.get_arch(arch_name)
-
-	require arch[:include_path]
+	Kompiler::ArchManager.load_arch(arch_name)
 
-	Kompiler::Architecture.registers.each do |reg|
-		puts "#{reg[:reg_name]}"
+	if !(arg_opts.include?("compact") || arg_letters.include?("c"))
+		Kompiler::Architecture.registers.each do |reg|
+			puts "#{reg[:reg_name]}"
+		end
+	else
+		puts Kompiler::Architecture.registers.map{_1[:reg_name]}.join(", ")
 	end
 
 	exit
@@ -199,19 +441,7 @@ end
 
 
 
-
-wrap_opt = arg_keys.select{_1[0] == "wrap"}
-
-
-if wrap_opt.size > 1
-	puts "kompile: Only one wrapping option can be provided with \"--wrap\"."
-	puts "Type \"kompile --help\" for more information."
-	exit
-elsif wrap_opt.size == 1
-	wrap_opt = wrap_opt[0][1]
-else
-	wrap_opt = "none"
-end
+wrap_opt = get_arg_key(arg_keys, ["wrap", "w"], "none")
 
 
 if !["elf.obj", "elf.exec", "mach-o.obj", "mach-o.exec", "none"].include?(wrap_opt)
@@ -222,18 +452,9 @@ end
 
 
 
+arch_name = get_arg_key(arg_keys, ["arch", "ar"], "armv8a")
 
-arch_opt = arg_keys.select{_1[0] == "arch"}
 
-if arch_opt.size > 1
-	puts "kompile: Only one architecture can be provided with \"--arch\"."
-	puts "Type \"kompile --help\" for more information."
-	exit
-elsif arch_opt.size == 1
-	arch_name = arch_opt[0][1]
-else
-	arch_name = "armv8a"
-end
 
 # Load all the architecture entries
 
@@ -258,6 +479,10 @@ end
 
 
 
+Kompiler::AliasManager.apply_aliases()
+
+
+
 code = File.binread(in_filename)
 
 detailed_out = Kompiler::CompilerFunctions.detailed_compile(code)
@@ -272,44 +497,119 @@ labels = detailed_out[:labels]
 labels.delete "here"
 
 
+
+add_exec_permission = false
+
+
 case wrap_opt
 when "none"
 	out = code
 when "elf.obj"
-	elf_machine = arg_keys.filter{_1[0] == "elf-machine"}[0]
-	elf_machine = (elf_machine != nil) ? elf_machine[1].to_i : 0
-	
-	elf_class = arg_keys.filter{_1[0] == "elf-class"}[0]
-	elf_class ||= ["elf-class", "64"]
-	elf_class = elf_class[1].to_i
+	elf_machine = get_arg_key(arg_keys, ["elf-machine", "m"], "0").to_num
+	elf_class = get_arg_key(arg_keys, ["elf-class", "c"], "64").to_num
+
+	if ![32, 64].include?(elf_class)
+		puts "kompile: Invalid ELF class specified."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
 	
 	symbols = Kompiler::Wrappers::ELF.labels_to_symbols(labels)
 	out = Kompiler::Wrappers::ELF.wrap_obj(code, symbols, machine: elf_machine, elf_class: elf_class)
 when "elf.exec"
-	elf_machine = arg_keys.filter{_1[0] == "elf-machine"}[0]
-	elf_machine = (elf_machine != nil) ? elf_machine[1].to_i : 0
+	vaddr = 0x80000
 
-	elf_class = arg_keys.filter{_1[0] == "elf-class"}[0]
-	elf_class ||= ["elf-class", "64"]
-	elf_class = elf_class[1].to_i
+	elf_machine = get_arg_key(arg_keys, ["elf-machine", "m"], "0").to_num
+	elf_class = get_arg_key(arg_keys, ["elf-class", "c"], "64").to_num
 
-	symbols = Kompiler::Wrappers::ELF.labels_to_symbols(labels)
-	out = Kompiler::Wrappers::ELF.wrap_exec(code, symbols, machine: elf_machine, elf_class: elf_class)
+	if ![32, 64].include?(elf_class)
+		puts "kompile: Invalid ELF class specified."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
+
+
+	symbols = Kompiler::Wrappers::ELF.labels_to_symbols(labels, vaddr: vaddr)
+	out = Kompiler::Wrappers::ELF.wrap_exec(code, symbols, machine: elf_machine, elf_class: elf_class, vaddr: vaddr)
+	
+	add_exec_permission = true
+	
 when "mach-o.obj"
-	macho_cpu = arg_keys.filter{_1[0] == "mach-o-machine"}[0]
-	macho_cpu = (macho_cpu != nil) ? macho_cpu[1] : "0.0"
-	cputype, cpusubtype = macho_cpu.split(".").map(&:to_i)
+	macho_cpu = get_arg_key(arg_keys, ["mach-o-machine", "m"], "0.0")
+	cputype, cpusubtype = macho_cpu.split(".").map(&:to_num)
+
+	if [cputype, cpusubtype].include? nil
+		puts "kompile: Invalid Mach-O machine specified."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
+
+	arch_type = get_arg_key(arg_keys, ["mach-o-archtype", "at"], "64").to_num
+
+	codesign = get_arg_key(arg_keys, ["codesign", "cs"], "false")
+	if !is_bool_opt(codesign)
+		puts "kompile: Invalid --codesign value."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
 
-	arch_type = arg_keys.filter{_1[0] == "mach-o-archtype"}[0]
-	arch_type = (arch_type != nil) ? arch_type[1].to_i : 64
+	codesign = is_pos_bool(codesign)
 
 	symbols = Kompiler::Wrappers::MachO.labels_to_symbols(labels)
 	out = Kompiler::Wrappers::MachO.wrap_obj(code, symbols, cputype: cputype, cpusubtype: cpusubtype, arch_type: arch_type)
 when "mach-o.exec"
-	puts "Mach-O executable not yet implemented."
-	exit
+	macho_cpu = get_arg_key(arg_keys, ["mach-o-machine", "m"], "0.0")
+	cputype, cpusubtype = macho_cpu.split(".").map(&:to_num)
+
+	if [cputype, cpusubtype].include? nil
+		puts "kompile: Invalid Mach-O machine specified."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
+
+	arch_type = get_arg_key(arg_keys, ["mach-o-archtype", "t"], "64").to_num
+
+	codesign = get_arg_key(arg_keys, ["codesign", "cs"], "false")
+	if !is_bool_opt(codesign)
+		puts "kompile: Invalid --codesign value."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
+
+	exec_type = get_arg_key(arg_keys, ["exec-type", "et"], "dylink")
+
+
+	codesign = is_pos_bool(codesign)
+
+
+	case exec_type
+	when "dylink"
+		symbols = Kompiler::Wrappers::MachO.labels_to_symbols(labels)
+		out = Kompiler::Wrappers::MachO.wrap_exec_dylink(code, symbols, cputype: cputype, cpusubtype: cpusubtype, arch_type: arch_type, codesign: codesign)
+	when "static"
+		symbols = Kompiler::Wrappers::MachO.labels_to_symbols(labels)
+
+		thread_state_arch = get_arg_key(arg_keys, ["mach-o-threadstate", "ts"], "arm64")
+
+		entry_address = 0x1000000
+
+		thread_state = Kompiler::Wrappers::MachO.build_thread_state arch: thread_state_arch, entry_address: 0x1000000, stack_pointer: 0
+		
+		out = Kompiler::Wrappers::MachO.wrap_exec_static(code, symbols, cputype: cputype, cpusubtype: cpusubtype, arch_type: arch_type, thread_state: thread_state, codesign: codesign, virtual_entry_address: entry_address)
+
+	else
+		puts "kompile: Invalid Mach-O executable type specified."
+		puts "Type \"kompile --help\" for more information."
+		exit
+	end
+	
+	add_exec_permission = true
 end
 
 
 File.binwrite out_filename, out
 
+if add_exec_permission
+	FileUtils.chmod "+x", out_filename
+end
+