alphalang 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2f7356e9bd0fa5e53d01733fa3266b7294f969037c665941daaac523e50e3b9f
+  data.tar.gz: '060006929bc0e33a766c001622f0079f9f3c3c51163138c867cc5bb67f31755d'
+SHA512:
+  metadata.gz: c1e5673759a21f75cc4d7fa14147b5a60fab5319e07ebce2349cdf35121e6a79bb1e78714c641c9061806c50ff1d9d60c2ca0c615c09f13c32f08a38eb812fb7
+  data.tar.gz: 53a824dd4c27bd9cf3ffb35d9db46a7b98a67b2ffd095d365cd1cc569faa835fa2d41e4e0752f3d4ba2b0c31825fd8e1000e0aca4a3e62686187ef66916e35e8

data/bin/alphalang

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require File.expand_path('../lib/alpha', __dir__)
+
+basic_error_msg = "Usage: alphalang [options] file.alpha\nUsage: alphalang -h for the help menu."
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = basic_error_msg
+
+  opts.on('-l', '--logger', 'Run program in a very verbose manner') do
+    options[:verbose] = true
+  end
+
+  opts.on('-v', '--verify', 'Run syntax verification. Does not require a file input.') do
+    options[:verify] = true
+  end
+
+  opts.on('--lang=LOCALE', 'Set the locale language for all program keywords. Available: en, sv, de') do |lang|
+    options[:lang] = lang
+  end
+
+  opts.on('--createlocale', 'Creates a new locale-file for all program keywords available.') do
+    options[:createlocale] = true
+  end
+end.parse!
+
+verbose = options[:verbose]
+verify = options[:verify]
+language = options[:lang] || 'en'
+createlocale = options[:createlocale]
+
+if createlocale
+  require_relative'../lib/lang_creator'
+  create()
+  return
+end
+
+raise OptionParser::MissingArgument, "No file provided.
+Usage: alphalang my_file.alpha | alphalang -h" if ARGV.empty? unless verify
+raise OptionParser::InvalidArgument, 'Too many files provided.
+Did you mean to use an --[option]? | alphalang -h' if ARGV.length > 1
+raise OptionParser::InvalidArgument, 'File must end with .alpha' unless verify or ARGV[0].end_with?('.alpha')
+
+if verbose
+  require_relative '../lib/rdparse'
+else
+  require_relative '../lib/rdparse_quiet'
+end
+
+if verify
+  if !ARGV.empty?
+    puts 'Flag for verification found. Ignoring input file.'
+    sleep 1
+  end
+  require_relative '../lib/tester/test_unit'
+else
+  LangParser.new(language).parse_file(ARGV[0])
+end

data/lib/alpha.rb

@@ -0,0 +1,168 @@
+require_relative './nodes/stmtnodes'
+
+class LangParser
+  def initialize(locale='en')
+    @langParser = Parser.new('lang parser', locale) do
+      token(/while/) { |_| :WHILE }
+      token(/print/) { |_| :PRINT }
+      token(/pause/) { |_| :PAUSE }
+      token(/def/) { |_| :DEF }
+      token(/end/) { |_| :STOP }
+      token(/if/) { |_| :IF }
+      token(/elseif/) { |_| :ELSEIF }
+      token(/else/) { |_| :ELSE }
+      token(/(false|true)/) { |m| m }
+      token(/(==|<=|>=)/) { |m| m }
+      token(/(not|!)/) { |_| :NOT }
+      token(/(and|&&)/) { |_| :AND }
+      token(/(or|\|\|)/) { |_| :OR }
+      token(/\s+/)
+      token(/\d+/) { |m| m }
+      token(/\w+/) { |m| m }
+      token(/./) { |m| m }
+
+      start :program do
+        match(:comp_stmt) { |comp_stmt| comp_stmt }
+        match(:terminal)
+      end
+
+      rule :terminal do
+        match(/\n|;/)
+      end
+
+      rule :comp_stmt do
+        match(:stmt, :comp_stmt) { |a, b| CompStmtNode.new([a, b]) }
+        match(:stmt)
+      end
+
+      rule :stmt do
+        match(:if_comp_stmt)
+        match(:while_stmt)
+        match(:func_dec)
+        match(:ass_stmt)
+        match(:pause_stmt)
+        match(:expr_stmt)
+      end
+
+      rule :if_comp_stmt do
+        match(:if_stmt, :comp_elseif, :else_stmt, :STOP) { |a, b, c| IfCompStmtNode.new(a, b, c) }
+        match(:if_stmt, :else_stmt, :STOP) { |a, b| IfCompStmtNode.new(a, b) }
+        match(:if_stmt, :STOP) { |a| IfCompStmtNode.new(a) }
+      end
+
+      rule :comp_elseif do
+        match(:elseif_stmt, :comp_elseif) { |a, b| [a, b] }
+        match(:elseif_stmt)
+      end
+
+      rule :if_stmt do
+        match(:IF, :expr_stmt, :and, :expr_stmt, :comp_stmt) { |_, a, b, c, d| IfCompactNode.new(a, b, c, d) }
+        match(:IF, :expr_stmt, :comp_stmt) { |_, a, b| IfNode.new(a, b) }
+      end
+
+      rule :elseif_stmt do
+        match(:ELSEIF, :expr_stmt, :comp_stmt) { |_, a, b| ElseifNode.new(a, b) }
+      end
+
+      rule :else_stmt do
+        match(:ELSE, :comp_stmt) { |_, b| ElseNode.new(b) }
+      end
+
+      rule :while_stmt do
+        match(:WHILE, :expr_stmt, :comp_stmt, :STOP) { |_, a, b| WhileLoopNode.new(a, b) }
+      end
+
+      rule :func_dec do
+        match(:DEF, :member, :comp_stmt, :STOP) { |_, name, value, _| FunctionDecNode.new(name, value) }
+      end
+
+      rule :ass_stmt do
+        match(:member, '=', :expr) { |var, _, value, _| VariableDecNode.new(var, value) }
+        match(:member, '=', :array_stmt) { |var, _, value| VariableDecNode.new(var, value) }
+      end
+
+      #array inte klar kan assigna till vaiabel men inte kolla upp än
+      rule :array_stmt do
+        match('[', :arg_list, ']') { |_, array, _| array }
+      end
+
+      rule :pause_stmt do
+        match(:PAUSE, :expr) { |_, a| PauseNode.new(a) }
+      end
+
+      rule :expr_stmt do
+        match(:or_stmt)
+        match(:and_stmt)
+        match(:not_stmt)
+        match(:expr)
+      end
+
+      rule :or_stmt do
+        match(:expr, :OR, :expr_stmt) { |a, _, b| OrNode.new(a, b) }
+      end
+
+      rule :and_stmt do
+        match(:expr, :AND, :expr_stmt) { |a, _, b| AndNode.new(a, b) }
+      end
+
+      rule :not_stmt do
+        match(:NOT, :expr_stmt) { |_, b| NotNode.new(b) }
+      end
+
+      rule :expr do
+        match(:expr, /(<|>)/, :expr) { |a, op, b| CompareNode.new(a, op, b) }
+        match(/(<|>)/, :expr) { |op, b| CompareNode.new(nil, op, b) }
+        match(:expr, /(<=|>=)/, :expr) { |a, op, b| CompareNode.new(a, op, b) }
+        match(/(<=|>=)/, :expr) { |op, b| CompareNode.new(nil, op, b) }
+        match(:expr, '==', :expr) { |a, op, b| CompareNode.new(a, op, b) }
+        match(:expr, '+', :term) { |a, op, b| BinaryOperationNode.new(a, op, b) }
+        match(:expr, '-', :term) { |a, op, b| BinaryOperationNode.new(a, op, b) }
+        match(:term)
+      end
+
+      rule :term do
+        match(:term, '*', :atom) { |a, op, b| BinaryOperationNode.new(a, op, b) }
+        match(:term, '/', :atom) { |a, op, b| BinaryOperationNode.new(a, op, b) }
+        match(:atom)
+      end
+
+      rule :atom do
+        match('-', /\d+/, '.', /\d+/) { |neg, a, dot, b| NumberNode.new((neg+a+dot+b)) }
+        match(/\d+/, '.', /\d+/) { |a, dot, b| NumberNode.new((a+dot+b)) }
+        match('-', /\d+/) { |neg, a| NumberNode.new(neg + a) }
+        match(/\d+/) { |a| NumberNode.new(a) }
+        match(/(false|true)/) { |a| BoolNode.new(a) }
+        match(:PRINT, :member) { |_, a| PrintNode.new(a) }
+        match(:PRINT, :expr) { |_, a| PrintNode.new(a) }
+        match(:member)
+        match(:prio_stmt)
+      end
+
+      rule :member do
+        match(/[a-z]/, '(', :arg_list, ')') { |var, _, args, _| FuncCallNode.new(var, args) }
+        match(/[a-z]/, '(', ')') { |var, _, _| FuncCallNode.new(var, NilClass) }
+        match(/[a-z]/) { |var| VariableCallNode.new(var) }
+      end
+
+      rule :arg_list do
+        match(:expr, ',', :arg_list) { |a, _, b| ArgListNode.new(a, b) }
+        match(:expr) { |a| ArgListNode.new(a, NilClass) }
+      end
+
+      rule :prio_stmt do
+        match('(', :stmt, ')') { |_, a, _| a }
+      end
+    end
+  end
+
+  def parse_file(filename)
+    file = File.read(filename)
+    root = @langParser.parse file
+    root.evaluate
+  end
+
+  def calc_test(str)
+    root = @langParser.parse str
+    root.evaluate
+  end
+end

data/lib/lang_creator.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+
+# Function to read user input for translation
+def read_translation(line)
+  puts "Enter the translation for: '#{line}'        <RET> to accept '#{line}'"
+  translation = gets.chomp
+  translation = line if translation.empty?
+  translation
+end
+
+def read_translation_true_false(line)
+  word1 = /false/.match(line)
+  word2 = /true/.match(line)
+  puts "Enter the translation for: '#{word1}'        <RET> to accept '#{word1}'"
+  translation = '('
+  input = gets.chomp
+  if input.empty?
+    translation += word1.to_s
+  else
+    translation += input
+  end
+  translation += '|'
+  puts "Enter the translation for: '#{word2}'        <RET> to accept '#{word2}'"
+  input2 = gets.chomp
+  if input2.empty?
+    translation += word2.to_s
+  else
+    translation += input2
+  end
+  translation += ')'
+  translation
+end
+
+def read_translation_not_and_or(line)
+  word = /\w+/.match(line)
+  puts "Enter the translation for: '#{word}'        <RET> to accept '#{word}'"
+  translation = '('
+  input = gets.chomp
+  if input.empty?
+    translation += word.to_s
+  else
+    translation += input
+  end
+  translation += /\|.+/.match(line).to_s
+  translation
+end
+def create()
+  # Prompt the user to choose a name for the translation file
+  puts "Choose a name for your translation file:"
+  name = gets.chomp
+
+  # Create an empty file to store translations
+  File.open(name, 'w') {}
+
+  # Read each line from the input file
+  locale_path = File.join(__dir__, "locales", 'locale_template')
+
+  # Prompt the user to translate the line
+  counter = 0
+  locale_thingies = File.readlines(locale_path)
+  locale_thingies.each do |line|
+
+    counter += 1
+    break if counter == 14
+    if counter < 9 
+      translation = read_translation(line.chomp)
+  
+      # Save translation after the original line
+      File.open(name, 'a') { |f| f.puts "#{line.chomp} #{translation}" }
+    end
+    if counter == 9 
+      translation = read_translation_true_false(line.chomp)
+      File.open(name, 'a') { |f| f.puts "#{line.chomp} #{translation}" }
+    end
+    if counter == 10
+      File.open(name, 'a') { |f| f.puts "#{line.chomp} (==|<=|>=)" }
+    end
+    if counter > 10 
+      translation = read_translation_not_and_or(line.chomp)
+      File.open(name, 'a') { |f| f.puts "#{line.chomp} #{translation}" }
+    end
+
+  end
+
+  # Append additional translations
+  File.open(name, 'a') do |f|
+    f.puts '\s+ \s+'
+    f.puts '\d+ \d+'
+    f.puts '\w+ \w+'
+    f.puts '. .'
+  end
+
+  # Clear the screen
+  system("clear")
+
+  # Display the contents of the translation file
+  puts File.read(name)
+
+  # Ask user if the translation is correct
+  puts "Is this correct? [Y/n]"
+  answer = gets.chomp
+
+  if answer.downcase == /y|Y/ or answer.empty?
+    puts "Translation saved to #{name}"
+
+    # Move the translation file to the desired directory
+    ruby_version = "" + RUBY_VERSION.to_s
+    ruby_version[-1] = '0'
+
+    # Find the users installation directory and place the locale file there
+    if File.exist?("/home/#{ENV['USER']}/.local/share/gem/ruby/#{ruby_version}/gems/alphalang-0.1.0/lib/locales/")
+      File.rename(name, "/home/#{ENV['USER']}/.local/share/gem/ruby/#{ruby_version}/gems/alphalang-0.1.0/lib/locales/#{name}")
+    # elsif File.exist?("~/var/lib/gems/#{ruby_version}/gems/alphalang-0.1.0/lib/locales/")
+    #   File.rename(name, "~/var/lib/gems/#{ruby_version}/gems/alphalang-0.1.0/lib/locales/#{name}")
+    else
+      raise ArgumentError, "Didn't find your .local/share/gem/ruby/<VERSION>/gems/alphalang-0.1.0
+Tried Ruby <VERSION> = #{ruby_version} "
+    end
+
+  else
+    puts 'Translation removed'
+    File.delete(name)
+  end
+end

data/lib/locales/de

@@ -0,0 +1,17 @@
+while während
+print drucken
+pause pause
+def def
+end ende
+if wenn
+elseif andernfalls
+else sonst
+(false|true) (falsch|wahr)
+(==|<=|>=) (==|<=|>=)
+(not|!) (nicht|!)
+(and|&&) (und|&&)
+(or|\|\|) (oder|\|\|)
+\s+ \s+
+\d+ \d+
+\w+ \w+
+. .

data/lib/locales/en

@@ -0,0 +1,17 @@
+while while
+print print
+pause pause
+def def
+end end
+if if
+elseif elseif
+else else
+(false|true) (false|true)
+(==|<=|>=) (==|<=|>=)
+(not|!) (not|!)
+(and|&&) (and|&&)
+(or|\|\|) (or|\|\|)
+\s+ \s+
+\d+ \d+
+\w+ \w+
+. .

data/lib/locales/locale_template

@@ -0,0 +1,17 @@
+while
+print
+pause
+def
+end
+if
+elseif
+else
+(false|true)
+(==|<=|>=)
+(not|!)
+(and|&&)
+(or|\|\|)
+\s+
+\d+
+\w+
+.

data/lib/locales/sv

@@ -0,0 +1,17 @@
+while medan
+print skriv
+pause vänta
+def def
+end slut
+if om
+elseif annarsom
+else annars
+(false|true) (falskt|sant)
+(==|<=|>=) (==|<=|>=)
+(not|!) (inte|!)
+(and|&&) (och|&&)
+(or|\|\|) (eller|\|\|)
+\s+ \s+
+\d+ \d+
+\w+ \w+
+. .

data/lib/nodes/#stmtnodes.rb#

@@ -0,0 +1,196 @@
+require_relative 'basenodes'
+
+####################################################
+class VariableCallNode < Node
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def lookup_var(name)
+    temp_scope_lvl = $scope_lvl
+    while temp_scope_lvl >= 0
+      if not $scopes[temp_scope_lvl].has_key?(name)
+        temp_scope_lvl -= 1
+      else
+        return $scopes[temp_scope_lvl][name]
+      end
+    end
+  end
+
+  def evaluate
+    return @value = lookup_var(@name)
+  end
+end
+
+class VariableDecNode < Node
+  attr_accessor :name
+
+  def initialize(name, value)
+    super(value)
+    @name = name
+  end
+
+  def evaluate
+    $scopes[$scope_lvl][@name.name] = @value.evaluate
+    self
+    # return nil
+  end
+end
+
+####################################################
+
+class FunctionDecNode < Node
+  def initialize(node, value)
+    super(value)
+    @name = node
+    @args = node.args
+  end
+
+  def evaluate
+    $scopes[0][@name.name] = [@value, @args]
+    return nil
+  end
+end
+
+class FuncCallNode < Node
+  attr_accessor :name, :args
+
+  def initialize(name, args)
+    @name = name
+    @args = args
+  end
+
+  def lookup_var(name)
+    return $scopes[0][name]
+  end
+
+  def evaluate
+    $scopes.push({})
+    func = lookup_var(@name)
+    function_body = func[0]
+    function_param = func[1]
+
+    return nil if func.is_a?(NilClass)
+
+    $scope_lvl += 1
+
+    if function_param.is_a?(ArgListNode)
+      function_param.each do |val, index|
+        function_param[index] = VariableDecNode.new(function_param[index].name, @args[index])
+        function_param[index].evaluate
+      end
+    end
+
+    func_result = function_body.evaluate
+    old_scope_lvl = $scope_lvl
+
+    if func_result.is_a?(VariableDecNode)
+      $scope_lvl = 0
+      func_result.evaluate
+      $scope_lvl = old_scope_lvl
+    end
+
+    $scope_lvl -= 1
+    $scopes.pop
+    return func_result
+  end
+end
+
+####################################################
+
+class IfNode < Node
+  attr_accessor :argument
+
+  def initialize(argument, node)
+    @argument, @node = argument, node
+  end
+
+  def evaluate
+    if @argument.evaluate
+      @value = @node.evaluate
+    else
+      @value = nil
+    end
+    @value
+  end
+end
+
+class ElseifNode < Node
+  def initialize(argument, node)
+    @argument, @node = argument, node
+  end
+  def evaluate
+    if @argument.evaluate
+      @value = @node.evaluate
+    end
+  end
+end
+
+class ElseNode < Node
+  def initialize(node)
+    @node = node
+  end
+
+  def evaluate
+    @value = @node.evaluate
+  end
+end
+ 
+class IfCompStmtNode < Node
+  def initialize(*nodes)
+    @nodes = nodes
+  end
+  def evaluate
+   if @nodes[0].argument.evaluate
+     return @nodes[0].evaluate
+   else
+     return nil if @nodes[1] == nil  # hmm??
+     return @nodes[1].evaluate
+   end
+  end
+end
+
+####################################################
+
+class WhileLoopNode < Node
+  attr_accessor :condition
+
+  def initialize(condition, statement)
+    @condition = condition
+    super(statement)
+  end
+
+  def evaluate
+    while @condition.evaluate
+      @value.evaluate
+    end
+    self.class
+  end
+end
+
+####################################################
+
+class PrintNode
+  attr_accessor :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def evaluate
+    puts @value.evaluate
+    self.class # detta kanske är trevligare än nil, åter igen den diskussionen.
+  end
+end
+
+class PauseNode < Node
+  def initialize(value)
+    super(value)
+  end
+
+  def evaluate
+    sleep @value.evaluate
+  end
+end