alphalang 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f7356e9bd0fa5e53d01733fa3266b7294f969037c665941daaac523e50e3b9f
-  data.tar.gz: '060006929bc0e33a766c001622f0079f9f3c3c51163138c867cc5bb67f31755d'
+  metadata.gz: 1c31a662b58f22db4c35e2e784739c0c0def7b9ccef89ad3f06292581dfdf28d
+  data.tar.gz: bc02c5bfcdac5985367a5c722b88b01a4d95d35c973dcb6e61d1a05c66de23e2
 SHA512:
-  metadata.gz: c1e5673759a21f75cc4d7fa14147b5a60fab5319e07ebce2349cdf35121e6a79bb1e78714c641c9061806c50ff1d9d60c2ca0c615c09f13c32f08a38eb812fb7
-  data.tar.gz: 53a824dd4c27bd9cf3ffb35d9db46a7b98a67b2ffd095d365cd1cc569faa835fa2d41e4e0752f3d4ba2b0c31825fd8e1000e0aca4a3e62686187ef66916e35e8
+  metadata.gz: 7c104ae659e875f33f9b3d9ac8f358613feab8dfe56b2b166b580626994a9089c8e6ecdb307cee7b8d64e80ba0e1b63f7be7380360cf427bc18e0eb34469d966
+  data.tar.gz: 30f09cb6a7a6c914b0be2d84a50cd88495e482fdec29c06c49fc8d2d9bd306795a86cf26d08065b6d0da8b0b0a8458fa06cc664694c72fe546abd6f1e3adbb41

data/bin/alphalang

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
 require 'optparse'
 require File.expand_path('../lib/alpha', __dir__)
+ALPHA_VER = '0.1.3'.freeze
+ABORT_ANSWERS = [' ', '', 'none', 'abort'].freeze # something here? Some cases empty means yes tho..
 
 basic_error_msg = "Usage: alphalang [options] file.alpha\nUsage: alphalang -h for the help menu."
 
@@ -20,19 +22,52 @@ OptionParser.new do |opts|
     options[:lang] = lang
   end
 
-  opts.on('--createlocale', 'Creates a new locale-file for all program keywords available.') do
+  opts.on('--createlocale', 'Creates a new locale file for all program keywords available.') do
     options[:createlocale] = true
   end
+
+  opts.on('--deletelocale', 'Deletes a locale file from your locales directory.') do
+    options[:deletelocale] = true
+  end
+
+  opts.on('--listlocales', 'Lists all available locale files from your locales directory.') do
+    options[:listlocales] = true
+  end
+
+  opts.on('--listlocale', 'Lists all keywords from a specific locale file from your locales directory.') do
+    options[:listlocale] = true
+  end
 end.parse!
 
 verbose = options[:verbose]
 verify = options[:verify]
 language = options[:lang] || 'en'
-createlocale = options[:createlocale]
+create_locale_flag = options[:createlocale]
+delete_locale_flag = options[:deletelocale]
+list_locales_flag = options[:listlocales]
+list_locale_flag = options[:listlocale]
+
+if create_locale_flag
+  require_relative '../lib/lang_creator'
+  create_locale_file
+  return
+end
+
+if delete_locale_flag
+  require_relative '../lib/locale_deleter'
+  delete_locale_file
+  return
+end
+
+if list_locales_flag
+  require_relative '../lib/locale_lister'
+  list_locale_files
+  return
+end
 
-if createlocale
-  require_relative'../lib/lang_creator'
-  create()
+if list_locale_flag
+  require_relative '../lib/locale_lister'
+  list_specific_locale_file
   return
 end
 
@@ -49,7 +84,7 @@ else
 end
 
 if verify
-  if !ARGV.empty?
+  unless ARGV.empty?
     puts 'Flag for verification found. Ignoring input file.'
     sleep 1
   end

data/lib/alpha.rb

@@ -1,7 +1,8 @@
 require_relative './nodes/stmtnodes'
 
 class LangParser
-  def initialize(locale='en')
+  def initialize(locale = 'en')
+    ScopeManager.new
     @langParser = Parser.new('lang parser', locale) do
       token(/while/) { |_| :WHILE }
       token(/print/) { |_| :PRINT }
@@ -81,11 +82,6 @@ class LangParser
         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
@@ -109,6 +105,15 @@ class LangParser
         match(:NOT, :expr_stmt) { |_, b| NotNode.new(b) }
       end
 
+      rule :array_stmt do
+        match('[', :arg_list, ']') { |_, array, _| array }
+      end
+
+      rule :arg_list do
+        match(:expr, ',', :arg_list) { |a, _, b| ArrayNode.new(a, b) }
+        match(:expr) { |a| ArrayNode.new(a, NilClass) }
+      end
+
       rule :expr do
         match(:expr, /(<|>)/, :expr) { |a, op, b| CompareNode.new(a, op, b) }
         match(/(<|>)/, :expr) { |op, b| CompareNode.new(nil, op, b) }
@@ -141,14 +146,11 @@ class LangParser
       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]/, '[', '-', /\d+/, ']') { |var, _, neg, index, _| ArrayCallNode.new(var, (neg+index)) }
+        match(/[a-z]/, '[', /\d+/, ']') { |var, _, index, _| ArrayCallNode.new(var, index) }
         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

data/lib/lang_creator.rb

@@ -4,86 +4,82 @@
 def read_translation(line)
   puts "Enter the translation for: '#{line}'        <RET> to accept '#{line}'"
   translation = gets.chomp
-  translation = line if translation.empty?
-  translation
+  translation.empty? ? line : 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}'"
+  words = line.scan(/true|false/)
   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
+  words.each do |word|
+    puts "Enter the translation for: '#{word}'        <RET> to accept '#{word}'"
+    input = gets.chomp
+    translation += input.empty? ? word : input
+    translation += '|'
   end
+  translation.chop!
   translation += ')'
   translation
 end
 
 def read_translation_not_and_or(line)
-  word = /\w+/.match(line)
+  word = line.match(/\w+/)[0]
+  postfix = line.match(/\|.+/)[0]
   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
+  return "(#{input.empty? ? word : input}#{postfix}"
 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
+def prompt_user(locale_template, file)
   counter = 0
-  locale_thingies = File.readlines(locale_path)
-  locale_thingies.each do |line|
-
+  locale_template.each do |line|
     counter += 1
     break if counter == 14
-    if counter < 9 
+
+    if counter < 9
       translation = read_translation(line.chomp)
-  
-      # Save translation after the original line
-      File.open(name, 'a') { |f| f.puts "#{line.chomp} #{translation}" }
+      File.open(file, 'a') { |f| f.puts "#{line.chomp} #{translation}" }
     end
-    if counter == 9 
+    if counter == 9
       translation = read_translation_true_false(line.chomp)
-      File.open(name, 'a') { |f| f.puts "#{line.chomp} #{translation}" }
+      File.open(file, 'a') { |f| f.puts "#{line.chomp} #{translation}" }
     end
     if counter == 10
-      File.open(name, 'a') { |f| f.puts "#{line.chomp} (==|<=|>=)" }
+      File.open(file, 'a') { |f| f.puts "#{line.chomp} (==|<=|>=)" }
     end
-    if counter > 10 
+    if counter > 10
       translation = read_translation_not_and_or(line.chomp)
-      File.open(name, 'a') { |f| f.puts "#{line.chomp} #{translation}" }
+      File.open(file, 'a') { |f| f.puts "#{line.chomp} #{translation}" }
     end
+  end
+end
 
+def save_file(file)
+  ruby_version = "#{RUBY_VERSION}"
+  ruby_version[-1] = '0'
+  install_path = "/home/#{ENV['USER']}/.local/share/gem/ruby/#{ruby_version}/gems/alphalang-#{ALPHA_VER}"
+
+  if File.exist?(install_path)
+    File.rename(file, "#{install_path}/lib/locales/#{file}")
+    puts "Locale/syntax saved to #{install_path}/lib/locales/#{file}"
+  else
+    raise ArgumentError, "Didn't find your #{install_path}.\nTried #{ruby_version} as <VERSION>"
   end
+end
+
+def create_locale_file()
+  puts 'Choose a filename for your locale/syntax:'
+  filename = gets.chomp
+  File.open(filename, 'w') {}
+
+  # import locale template
+  locale_path = File.join(__dir__, 'locales', 'locale_template')
+  token_template = File.readlines(locale_path)
+
+  # prompt user for translations
+  prompt_user(token_template, filename)
 
   # Append additional translations
-  File.open(name, 'a') do |f|
+  File.open(filename, 'a') do |f|
     f.puts '\s+ \s+'
     f.puts '\d+ \d+'
     f.puts '\w+ \w+'
@@ -91,34 +87,19 @@ def create()
   end
 
   # Clear the screen
-  system("clear")
+  system('clear')
 
   # Display the contents of the translation file
-  puts File.read(name)
+  puts File.read(filename)
 
   # Ask user if the translation is correct
-  puts "Is this correct? [Y/n]"
+  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
-
+    save_file(filename)
   else
     puts 'Translation removed'
-    File.delete(name)
+    File.delete(filename)
   end
-end
+end

data/lib/locale_deleter.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+def prompt_user_for_deletion(locales, install_path, protected_paths)
+  puts 'Which locale would you like to delete?:                    RET or "none" to abort'
+
+  locales.each do |locale|
+    puts locale
+  end
+
+  locale_file = gets.chomp
+
+  return if ABORT_ANSWERS.include?(locale_file)
+
+  if protected_paths.include?(locale_file)
+    puts 'You may not delete a default locale.'
+    return
+  else
+    File.delete("#{install_path}/#{locale_file}")
+    puts "Successfully deleted #{install_path}/#{locale_file}"
+  end
+end
+
+def delete_locale_file()
+  locale_path = File.join(__dir__, 'locales')
+  protected_locales = ['.', '..', 'locale_template', 'en', 'sv', 'de']
+
+  imported_locales = Dir.entries(locale_path).reject { |entry| protected_locales.include?(entry) }
+
+  if imported_locales.empty?
+    puts '[alphalang] There are no locale files to delete. Default locale files are protected.'
+    return
+  else
+    prompt_user_for_deletion(imported_locales, locale_path, protected_locales)
+  end
+end

data/lib/locale_lister.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+# extra_entries_array in case we wanna make a "protected locale" function later on
+def get_locale_files(extra_entries_array = [])
+  locale_path = File.join(__dir__, 'locales')
+  protected_locales = ['.', '..', 'locale_template', extra_entries_array].flatten
+  Dir.entries(locale_path).reject { |entry| protected_locales.include?(entry) }
+end
+
+def list_locale_files()
+  locales = get_locale_files
+  puts '[alphalang] These are the available locales.'
+  locales.each do |locale|
+    puts locale
+  end
+  puts
+end
+
+def list_specific_locale_file()
+  list_locale_files
+  specific_locale = gets.chomp
+
+  return if ABORT_ANSWERS.include?(specific_locale)
+
+  locale_path = File.join(__dir__, 'locales')
+  locale_file = File.readlines("#{locale_path}/#{specific_locale}")
+
+  clean_locale_file_array = []
+  locale_file.each do |line|
+    line.scan(/\b\p{L}+\b/) do |word|
+      clean_locale_file_array << word if word.size > 1
+    end
+  end
+
+  header = "\n[alphalang] Syntax for locale <#{specific_locale}>."
+  puts header
+  puts '+' * (header.size - 2)
+  clean_line = ''
+  clean_locale_file_array.each_with_index do |word, index|
+    if index.even?
+      clean_line += "+        #{word}"
+    else
+      clean_line += (' ' * (20 - clean_line.size)) + "#{word}"
+      clean_line += (' ' * (header.size - clean_line.size - 3) + '+')
+      puts clean_line
+      clean_line = ''
+    end
+  end
+  puts '+' * (header.size - 2)
+end

data/lib/nodes/basenodes.rb

@@ -1,9 +1,4 @@
 #!/usr/bin/env ruby
-####################################################
-
-$scopes = [{}]
-$scope_lvl = 0
-$test_nodes = false
 
 ####################################################
 
@@ -38,6 +33,10 @@ class Node
     @value = value
   end
 
+  def to_s
+    @value
+  end
+
   def evaluate
     @value.evaluate
   end
@@ -143,7 +142,6 @@ end
 ####################################################
 
 class CompStmtNode < Node
-
   def initialize(stmt_compstmt)
     super
     @comp_statements = stmt_compstmt
@@ -155,10 +153,9 @@ class CompStmtNode < Node
   end
 end
 
-
 ####################################################
 
-class ArgListNode < Node
+class ArrayNode < Node
   attr_accessor :lhs, :rhs
 
   def initialize(lhs, rhs)

data/lib/nodes/stmtnodes.rb

@@ -1,26 +1,65 @@
 require_relative 'basenodes'
 
 ####################################################
-class VariableCallNode < Node
-  attr_accessor :name
 
-  def initialize(name)
-    @name = name
+$scopes = [{}]
+$scope_lvl = 0
+$test_nodes = false
+
+# Need to expand this to actually handle scopes, not just lookups
+class ScopeManager
+  def self.scope_lvl
+    $scope_lvl
   end
 
-  def lookup_var(name)
+  def self.lookup_var(name)
     temp_scope_lvl = $scope_lvl
     while temp_scope_lvl >= 0
-      if not $scopes[temp_scope_lvl].has_key?(name)
+      if !$scopes[temp_scope_lvl].key?(name)
         temp_scope_lvl -= 1
       else
         return $scopes[temp_scope_lvl][name]
       end
     end
+    raise ArgumentError, "Variable '#{name}' is not defined" unless @value
+  end
+
+  def self.increment_scope_level
+    $scope_lvl += 1
+    $scopes.push({})
+  end
+
+  def self.decrement_scope_level
+    $scope_lvl -= 1
+    $scopes.pop
+  end
+
+  def self.lookup_func(name)
+    raise ArgumentError, "Function '#{name}' is not defined" if $scopes[0][name].is_a?(NilClass)
+    return $scopes[0][name]
+  end
+
+  def self.add_to_current_scope(name, value)
+    $scopes[$scope_lvl][name.name] = value.evaluate
+  end
+
+  def self.add_func_to_global_scope(name, value, args)
+    $scopes[0][name.name] = [value, args]
+  end
+end
+
+####################################################
+
+class VariableCallNode < Node
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
   end
 
   def evaluate
-    return @value = lookup_var(@name)
+    @value = ScopeManager.lookup_var(@name)
+    return @value
   end
 end
 
@@ -33,9 +72,8 @@ class VariableDecNode < Node
   end
 
   def evaluate
-    $scopes[$scope_lvl][@name.name] = @value.evaluate
+    ScopeManager.add_to_current_scope(name, @value)
     self
-    # return nil
   end
 end
 
@@ -49,7 +87,7 @@ class FunctionDecNode < Node
   end
 
   def evaluate
-    $scopes[0][@name.name] = [@value, @args]
+    ScopeManager.add_func_to_global_scope(@name, @value, @args)
     return nil
   end
 end
@@ -62,39 +100,33 @@ class FuncCallNode < Node
     @args = args
   end
 
-  def lookup_var(name)
-    return $scopes[0][name]
-  end
-
   def evaluate
-    $scopes.push({})
-    func = lookup_var(@name)
+    func = ScopeManager.lookup_func(@name)
+
     function_body = func[0]
     function_param = func[1]
 
-    return nil if func.is_a?(NilClass)
-
-    $scope_lvl += 1
+    ScopeManager.increment_scope_level
 
-    if function_param.is_a?(ArgListNode)
+    if function_param.is_a?(ArrayNode)
       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
-    # Om en assign är returnvärde så declareras variablen i globalt scope
-    if func_result.is_a?(VariableDecNode)
-      $scope_lvl = 0
-      func_result.evaluate
-      $scope_lvl = old_scope_lvl
-    end
+    func_return_value = function_body.evaluate
 
-    $scope_lvl -= 1
-    $scopes.pop
-    return func_result
+    ScopeManager.decrement_scope_level
+
+    # If function return value is an "Assign" then we declare that variable in the global scope.
+    old_scope_lvl = ScopeManager.scope_lvl
+    if func_return_value.is_a?(VariableDecNode)
+      ScopeManager.scope_lvl = 0
+      func_return_value.evaluate
+      ScopeManager.scope_lvl = old_scope_lvl
+    end
+    return func_return_value
   end
 end
 
@@ -176,6 +208,23 @@ end
 
 ####################################################
 
+class ArrayCallNode < Node
+  def initialize(array, index)
+    super(array)
+    @index = index.to_i
+  end
+
+  def evaluate
+    arr = ScopeManager.lookup_var(@value)
+    if @index > arr.size - 1
+      raise ArgumentError, "You are trying to access an out of bounds index. Here -> #{@value}[#{@index}]"
+    end
+    @value = arr[@index]
+  end
+end
+
+####################################################
+
 class PrintNode
   attr_accessor :value
 
@@ -185,7 +234,7 @@ class PrintNode
 
   def evaluate
     puts @value.evaluate
-    self.class # detta kanske är trevligare än nil, åter igen den diskussionen.
+    self.class
   end
 end
 

data/lib/tester/demo_de.alpha

@@ -0,0 +1,12 @@
+x = 1
+
+während x < 10
+      drucken x
+
+      wenn x > 5 und < 10
+        pause 1
+      ende
+    x = x + 1
+ende
+
+drucken x

data/lib/tester/demo_sv.alpha

@@ -0,0 +1,12 @@
+x = 1
+
+medan x < 10
+      skriv x
+
+      om x > 5 och < 10
+        vänta 1
+      slut
+    x = x + 1
+slut
+
+skriv x

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: alphalang
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - mattias
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-03 00:00:00.000000000 Z
+date: 2024-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: optparse
+  name: logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '1.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 1.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '1.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
-  name: logger
+  name: optparse
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '0.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '0.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 0.3.0
 description: Abstract Syntax Tree building language with a recursive descent parser
 email:
 - mattiasreuterskiold@gmail.com
@@ -61,15 +61,20 @@ files:
 - bin/alphalang
 - lib/alpha.rb
 - lib/lang_creator.rb
+- lib/locale_deleter.rb
+- lib/locale_deleter.rb~
+- lib/locale_lister.rb
+- lib/locale_lister.rb~
 - lib/locales/de
 - lib/locales/en
 - lib/locales/locale_template
 - lib/locales/sv
-- lib/nodes/#stmtnodes.rb#
 - lib/nodes/basenodes.rb
 - lib/nodes/stmtnodes.rb
 - lib/rdparse.rb
 - lib/rdparse_quiet.rb
+- lib/tester/demo_de.alpha
+- lib/tester/demo_sv.alpha
 - lib/tester/fibonacci.alpha
 - lib/tester/test_unit.rb
 homepage: https://portfolio.reuterskiold.dev

data/lib/nodes/#stmtnodes.rb#

@@ -1,196 +0,0 @@
-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