pycplus 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ba4de43decc549bf60ae97669e59b7e8dc597897d9f9f943c9547e93f260880
-  data.tar.gz: a8e6c2e1815da2725a6f5af2841a6d9ff7db0bf5ec58fd6a05ccde637df12a96
+  metadata.gz: 573f59a30af939f137fba7684ca507a4c0726598b9b98a9596761be93ced4906
+  data.tar.gz: 4158857a428507fa891adfb036516ff7cdd242532d69f68b8203e5131de34ed3
 SHA512:
-  metadata.gz: 1fdf3493c38f21ed5d515f1b4ea4c80849913ac6a4b6398bc6000a27df445ffa8161222cc9115d9bae0162b06809dc5531576d5182e0525ca998f74ad3f6895d
-  data.tar.gz: d51d284dac74989f444902c43ff177e706daf2887bf4e6fd80aae0aa250c744d6b6f9d979d61862ecc8353195b12c91cfaeacec0a8e77cd7eb974c759aafa412
+  metadata.gz: a43a5652ee52fe8bf6fe771ee78ca88ee4a695f8cee399994fc86d722437ccef6e09ccb66367066da7823b506d8a9ec96597b765a8288385e11c8f48a526b824
+  data.tar.gz: cbbd8b500dc0fc67bc3bc55936c67acdf2e324436ddcdde6951ff95ff6c479a2275afd193f4fba3139ad291e13ec2d2fcaa12abcdfafedd075e44ed8905aac41

data/README.md

@@ -1,3 +1,23 @@
-# TDP019
+# PyCPlus
 
-TODO
+PyCPlus is a custom programming language constructed on Ruby for a first-year school project at Linköping University, 
+part of the IP-program. 
+
+It includes common functionalities found in programming languages, featuring a clear and concise syntax.
+
+## Installation
+
+To install PyCPlus, you can simply use RubyGems:
+
+```bash
+gem install pycplus
+```
+
+
+## Unit testing
+
+Unit tests can be ran from the projects test directory.
+
+```bash
+rake
+```

data/bin/pycplus

@@ -7,59 +7,67 @@ require_relative '../lib/pcpparse'
 
 # Method to print gem version
 def print_version
-    spec = Gem.loaded_specs['pycplus']
-    puts "#{spec.name} version #{spec.version}"
+    begin
+        spec = Gem.loaded_specs['pycplus']
+        puts "#{spec.name} version #{spec.version}"
+    rescue
+        begin
+            path = File.expand_path('../pycplus.gemspec', __dir__)
+            spec = Gem::Specification.load(path)
+            puts "#{spec.name} version #{spec.version}"
+        rescue
+            puts "Error: Unable to find version for pycplus gem"
+        end
+    end
 end
 
-def main
-    # Parse other command-line options using OptionParser
-    options = {}
-    OptionParser.new do |opts|
 
-        opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} [options] filename"
-
-        # version is handled as a special case as it doesn't make sense to use it alongside the other options
-        opts.on("-v", "--version", "Display version information") do
-            print_version
-            exit
-        end
+# Parse other command-line options using OptionParser
+options = {}
+OptionParser.new do |opts|
 
-        opts.on("-d", "--debug", "Enable debug mode") do
-            options[:debug] = true
-            print("dhsdhshdshds")
-        end
-    end.parse!
+    opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} [options] filename"
 
-    # Check if a filename argument is provided
-    if ARGV.empty?
-        puts "Error: No filename or arguments provided."
-        exit 1
+    opts.on("-h", "--help", "Display this help message") do
+        puts opts
+        exit
     end
 
-    filename = ARGV.shift
-    @lang_parser = Pycplus.new
+    # version is handled as a special case as it doesn't make sense to use it alongside the other options
+    opts.on("-v", "--version", "Display version information") do
+        print_version
+        exit
+    end
 
-    # Enable debug mode if specified
-    if options[:debug]
-        @lang_parser.log(true)
-    else
-        @lang_parser.log(false)
+    opts.on("-d", "--debug", "Enable debug mode") do
+        options[:debug] = true
     end
+end.parse!
 
-    if File.file?(filename)
-        extension = File.extname(filename)
+# Check if a filename argument is provided
+if ARGV.empty?
+    puts "Error: No filename or arguments provided."
+    exit 1
+end
 
-        if extension == ".pcp"
-            @lang_parser.parse_file(filename)
-        else
-            puts "Error: File is not a .pcp file. Please provide a file with the correct extension."
-        end
-    else
-        puts "Error: Unable to find file #{filename}"
-    end
+filename = ARGV.shift
+@lang_parser = Pycplus.new
+
+# Enable debug mode if specified
+if options[:debug]
+    @lang_parser.log(true)
+else
+    @lang_parser.log(false)
 end
 
+if File.file?(filename)
+    extension = File.extname(filename)
 
-if __FILE__ == $PROGRAM_NAME
-    main
-end
+    if extension == ".pcp"
+        @lang_parser.parse_file(filename)
+    else
+        puts "Error: File is not a .pcp file. Please provide a file with the correct extension."
+    end
+else
+    puts "Error: Unable to find file #{filename}"
+end

data/lib/STL.rb

@@ -1,16 +1,18 @@
 
+
+# Module for built-in functions.
 module STL
   def self.print(x)
     pp x
     return nil
   end
 
-  def self.size(array)
-    unless array.is_a?(Array)
-      raise TypeError, "Function #{__method__} must be used on an array."
+  def self.size(x)
+    unless x.is_a?(Array) || x.is_a?(String) 
+      raise TypeError, "Function #{__method__} must be used on a string or array."
     end
     
-    return array.count
+    return x.length
   end
 
   def self.pop(array)

data/lib/nodes.rb

@@ -13,25 +13,36 @@ class Scope
 
   # Set variable in current scope
   def set_variable(name, op, expression)
+
+    # Checks if the variable has been used as a non-local variable, if true: raise NameError
     if @non_local_variables.include?(name)
-      raise NameError, "local identifier #{name} referenced before assignment"
+      raise NameError, "Local identifier #{name} referenced before assignment"
     end
+
     if op == '='
       @identifiers[name] = expression
     else
+
+      # Checks if the variable is local, raise NameError if otherwise
       unless @identifiers.has_key?(name)
-        raise NameError, "local identifier #{name} referenced before assignment"
+        raise NameError, "Local identifier #{name} referenced before assignment"
       end
+
       if op == '+='
         @identifiers[name] += expression
       else
-        @identifiers[name] -= expression
+        if @identifiers[name].is_a?(String) || expression.is_a?(String)
+          raise TypeError, "Operation #{op} is not allowed for identifier #{name} or the expression as they must not be strings"
+        else
+          @identifiers[name] -= expression
+        end
       end
     end
   end
 
+  # Add non local variable used in scope
   def set_non_local_variable(name)
-    unless @non_local_variables.include?(name) && is_function(name)
+    unless @non_local_variables.include?(name) || is_function?(name)
       @non_local_variables.append(name)
     end
   end
@@ -58,7 +69,9 @@ class Scope
   # Checks if a identifier is a function.
   def is_function?(name)
     scope = get_scope(name)
-    id_value = scope.get_identifier(name) if scope
+    return false unless scope
+
+    id_value = scope.get_identifier(name)
     return id_value.is_a?(Hash) 
   end
 
@@ -68,23 +81,29 @@ class Scope
   end
 end
 
+# **********************************************************************************
 
+# Class for statements to be evaluated as a code-block.
 class BlockNode
   def initialize(statements = nil)
     @block = statements
   end
 
+  # Evaluate block based on scope.
   def evaluate(scope)
-    return unless @block
+    return nil unless @block
     result = nil
     @block.each do |statement|
       result = statement.evaluate(scope)
+
+      # Returns the result if the value is a return value. Needed for returns in nestled blocks.
       return result if result.is_a?(ReturnValue)
     end
     return result
   end
 end
 
+# Class for defining functions.
 class FunctiondefNode
   def initialize(identifier, block, parameters = [])
     @identifier = identifier.value
@@ -92,34 +111,46 @@ class FunctiondefNode
     @block = block
   end
 
+  # Saves identifier with code-block and parameters in current scope
   def evaluate(scope)
     params = @parameters.map {|parameter| parameter.value}
     scope.set_function(@identifier, @block, params)
   end
 end
 
+
+# Class for calling functions.
 class FunctioncallNode
-  include STL
+
+  include STL   # Standard template library for the language (builtin-functions).
+
   def initialize(identifier, object = nil, arguments = [])
     @identifier = identifier.value
     @arguments = arguments
     @object = object
   end
 
+  # Checks if the arguments given is the same number of expected parameters.
   def validate_arguments(parameters)
     if @arguments.size != parameters.size
       raise ArgumentError, "Wrong number of arguments (given: #{@arguments.size} expected: #{parameters.size})."
     end
   end
 
-  def evaluate_method(scope)
+  # Calls builtin-function.
+  def evaluate_STL_function(scope)
     args = @arguments.map {|arg| arg.evaluate(scope)}
     result = STL.send(@identifier, *args)
     return result
   end
 
-  def evaluate_block(parameters, block, current_scope, id_scope)
-    new_scope = Scope.new(id_scope)
+  # Evaluate code-block of user defined function.
+  def evaluate_block(parameters, block, current_scope, declared_scope)
+    
+    # Create new scope for function with the scope where the function was declared as its parent scope. 
+    new_scope = Scope.new(declared_scope)
+
+    # Set local variables for function with values from arguments
     parameters.zip(@arguments).each do |parameter, argument|
       new_scope.set_variable(parameter, '=', argument.evaluate(current_scope))
     end
@@ -130,22 +161,33 @@ class FunctioncallNode
 
   def evaluate(scope)
 
+    # Check if scope of identifier. If it exist but is not defined as a function: raise TypeError
     id_scope = scope.get_scope(@identifier)
     if id_scope && !id_scope.is_function?(@identifier)
       raise TypeError, "Identifier #{@identifier} is not defined as a function."
     end
-    if @object
+
+    
+    # Check if the function has been called as a method on a object (Ex. a.print();). Add object as a argument if true.
+
+    if @object && !@arguments.include?(@object)
       @arguments.unshift(@object)
     end
+
+    # Check if no identifier has been found in scope.
     if !id_scope
+
+      # Check if function part of STL. if true: call function, else raise NameError.
       if STL.respond_to?(@identifier)
         method = STL.method(@identifier)
         parameters = method.parameters
         validate_arguments(parameters)
-        evaluate_method(scope)
+        evaluate_STL_function(scope)
       else
         raise NameError, "Function #{@identifier} not defined."
       end
+
+      # If identifier is user defined function, call it.
     else
       function = id_scope.get_identifier(@identifier)
       parameters = function[:parameters]
@@ -156,6 +198,8 @@ class FunctioncallNode
   end
 end
 
+
+# Root node for program. Stores statements and evaluates them.
 class ProgramNode
   attr_reader :statements
   def initialize(statements)
@@ -169,10 +213,15 @@ class ProgramNode
       result = statement.evaluate(global_scope)
       return result.value if statement.is_a?(ReturnNode)
     end
-    return result
+    if result.is_a?(ReturnValue)
+      return result.value
+    else
+      return result
+    end
   end
 end
 
+# Wrapper class for specifying that a value is a return value.
 class ReturnValue
   attr_accessor :value
   def initialize(value)
@@ -180,6 +229,8 @@ class ReturnValue
   end
 end
 
+
+# Class for return statements.
 class ReturnNode
   def initialize(expression)
     @expression = expression
@@ -190,6 +241,8 @@ class ReturnNode
   end
 end
 
+
+# Super class for arithmetic and logical expressions.
 class BinaryexpressionNode
   def initialize(lhs, op, rhs)
     @lhs = lhs
@@ -199,6 +252,8 @@ class BinaryexpressionNode
 
   def evaluate(scope)
     rhs_value = @rhs.evaluate(scope)
+
+    # Dividing by 0 using using fdiv returns Infinity, raise ZeroDivisionError instead.
     if @op == :fdiv && rhs_value == 0
       raise ZeroDivisionError,"Division by 0 not possible."
     end
@@ -206,29 +261,35 @@ class BinaryexpressionNode
   end
 end
 
+# Class for logical expressions.
 class LogicalNode < BinaryexpressionNode
   def evaluate(scope)
-    return eval("#{@lhs.evaluate(scope)}#{@op}#{@rhs.evaluate(scope)}") # Not possible to use send-method since ruby TrueClass (Ruby bools) has no method for && or ||.
+
+    # Not possible to use send-method since ruby TrueClass/FalseClass has no method for && or ||.
+    return eval("#{@lhs.evaluate(scope)}#{@op}#{@rhs.evaluate(scope)}")
   end
 end
 
+# Wrapper class for comparison expressions
 class ComparisonNode < BinaryexpressionNode
 end
 
+# Wrapper class for arithmetic expressions.
 class ArithmeticNode < BinaryexpressionNode
 end
 
-
+# Class for unary expressions.
 class UnaryNode
   def initialize(op, operand)
     @op = op
     @operand = operand
   end
   def evaluate(scope)
-    return eval("#{@op}#{@operand.evaluate(scope)}") # Not possible to use send-method.
+    return eval("#{@op}#{@operand.evaluate(scope)}")
   end
 end
 
+# Class for assignment statements.
 class AssignmentNode
   def initialize(identifier, op, expression)
     @identifier = identifier.value
@@ -236,12 +297,13 @@ class AssignmentNode
     @expression = expression
   end
 
+  # Set identifier based on operator.
   def evaluate(scope)
     scope.set_variable(@identifier, @op, @expression.evaluate(scope))
   end
 end
 
-
+# Superclass for control flow statements (if/while).
 class ControlflowNode
   def initialize(expression, block)
     @expression = expression
@@ -249,7 +311,10 @@ class ControlflowNode
   end
 end
 
+# Class for if-statements.
 class IfNode < ControlflowNode
+
+  # Evaluate if expression is true, if so evaluate block.
   def evaluate(scope)
     if @expression.evaluate(scope)
       @block.evaluate(scope)
@@ -257,24 +322,31 @@ class IfNode < ControlflowNode
   end
 end
 
+# Class for while-statements. 
 class WhileNode < ControlflowNode
+
+  # Evaluates the expression as a condition in a while-loop. If true -> continue iterations.
   def evaluate(scope)
     while @expression.evaluate(scope)
-      @block.evaluate(scope)
+      result = @block.evaluate(scope)
+      return result if result.is_a?(ReturnValue)
     end
   end
 end
 
+# Class for arrays. 
 class ArrayNode
   def initialize(elements = [])
     @elements = elements
   end
 
+  # Evaluate each object in elements and return array.
   def evaluate(scope)
     return @elements.map {|element| element.evaluate(scope)}
   end
 end
 
+# Superclass for primitive data-types.
 class PrimitiveNode
   attr_reader :value
   def initialize(value)
@@ -286,25 +358,41 @@ class PrimitiveNode
   end
 end
 
+# Class for identifiers (functions and variables).
 class IdentifierNode < PrimitiveNode
   def evaluate(scope)
+    
+    # Checks if the identifier is a function. If true raise SyntaxError. 
     if scope.is_function?(@value)
       raise SyntaxError, "Identifier #{@value} is assigned to a function. Please use correct syntax for function call."
     end
+
+    # Checks if the identifier is a local variable. If false, add it to non-local list.
     id_value = scope.get_identifier(@value)
     unless scope.identifiers.has_key?(@value)
       scope.set_non_local_variable(@value)
     end
+    
     return id_value
   end
 end
 
-class CharNode < PrimitiveNode
-end
-
+# Wrapper class for primitive data-type Integer/Float.
 class DigitNode < PrimitiveNode
 end
 
+# Wrapper class for primitive data-type Bool.
 class BoolNode < PrimitiveNode
 end
 
+# Class for primitive data-type String.
+class StringNode < PrimitiveNode
+  attr_reader :value
+  def initialize(value)
+    @value = value.gsub(/^"|"$/, '')
+  end
+
+  def evaluate(scope)
+    return @value
+  end
+end

data/lib/pcpparse.rb

@@ -26,6 +26,7 @@ class Pycplus
       token(/&&/) {|m| m}
       token(/\|\|/) {|m| m}
       token(/\d+\.\d+/) {|m| m.to_f}
+      token(/"[^"]*"/) {|m| m}
       token(/\d+/) {|m| m.to_i}
       token(/\w+/) {|m| m}
       token(/./) {|m| m}
@@ -50,7 +51,6 @@ class Pycplus
       end
 
       rule :assignment do
-        # match(:identifier, :assignment_OP, :function_call) {|a, b, c| AssignmentNode.new(a,b,c)}
         match(:identifier, :assignment_OP, :logical_expr) {|a, b, c| AssignmentNode.new(a,b,c)}
         match(:identifier, :assignment_OP, :array) {|a, b, c| AssignmentNode.new(a,b,c)}
       end
@@ -107,7 +107,6 @@ class Pycplus
       rule :return_statement do
         match(:return, :logical_expr) {|_, a| ReturnNode.new(a)}
         match(:return, :array) {|_, a| ReturnNode.new(a)}
-        # match(:return, :function_call) {|_, a| ReturnNode.new(a)}
       end
 
       rule :while_statement do
@@ -192,6 +191,7 @@ class Pycplus
         match(:bool)
         match(:digit)
         match(:identifier)
+        match(:string)
         match('(', :logical_expr, ')') {|_, a, _| a}
       end
 
@@ -213,6 +213,7 @@ class Pycplus
       rule :atom do
         match(:bool)
         match(:digit)
+        match(:string)
         match(:identifier)
       end
 
@@ -226,8 +227,12 @@ class Pycplus
         match(Integer) {|a| DigitNode.new(a)}
       end
 
+      rule :string do
+        match(/".*?"/) {|a| StringNode.new(a)}
+      end
+
       rule :identifier do
-        match(/[_a-zA-Z]+\w*/) {|a| IdentifierNode.new(a.to_sym)}
+        match(/^(?!.*")[_a-zA-Z]+\w*(?<!")$/) {|a| IdentifierNode.new(a.to_sym)}
       end
     end
   end
@@ -235,7 +240,11 @@ class Pycplus
   def parse_file(filename)
     file = File.open(filename)
     file_data = file.read
-    result = @pycplus_parser.parse(file_data)
+    begin
+      result = @pycplus_parser.parse(file_data)
+    rescue StandardError => e
+      puts "Something went wrong! Error #{e.message}"
+    end
     return result.evaluate if result
   end
 
@@ -258,7 +267,4 @@ class Pycplus
       @pycplus_parser.logger.level = Logger::WARN
     end
   end
-end
-
-
-# _?[a-zA-Z*]\w*
+end

data/lib/rdparse.rb

@@ -19,21 +19,21 @@ class Rule
   #     match(:term, '/', :dice) {|a, _, b| a / b }
   #     match(:dice)
   #   end
-  
+
   Match = Struct.new :pattern, :block
-  
+
   def initialize(name, parser)
     @logger = parser.logger
     # The name of the expressions this rule matches
     @name = name
-    # We need the parser to recursively parse sub-expressions occurring 
+    # We need the parser to recursively parse sub-expressions occurring
     # within the pattern of the match objects associated with this rule
     @parser = parser
     @matches = []
     # Left-recursive matches
     @lrmatches = []
   end
-  
+
   # Add a matching expression to this rule, as in this example:
   #   match(:term, '*', :dice) {|a, _, b| a * b }
   # The arguments to 'match' describe the constituents of this expression.
@@ -47,7 +47,7 @@ class Rule
       @matches << match
     end
   end
-  
+
   def parse
     # Try non-left-recursive matches first, to avoid infinite recursion
     match_result = try_matches(@matches)
@@ -60,7 +60,7 @@ class Rule
   end
 
   private
-  
+
   # Try out all matching patterns of this rule
   def try_matches(matches, pre_result = nil)
     match_result = nil
@@ -73,7 +73,7 @@ class Rule
       # We iterate through the parts of the pattern, which may be e.g.
       #   [:expr,'*',:term]
       match.pattern.each_with_index do |token,index|
-        
+
         # If this "token" is a compound term, add the result of
         # parsing it to the "result" array
         if @parser.rules[token]
@@ -114,7 +114,7 @@ class Rule
         @parser.pos = start
       end
     end
-    
+
     return match_result
   end
 end
@@ -135,7 +135,7 @@ class Parser
     @language_name = language_name
     instance_eval(&block)
   end
-  
+
   # Tokenize the string into small pieces
   def tokenize(string)
     @tokens = []
@@ -161,10 +161,10 @@ class Parser
       end # raise
     end # until
   end
-  
+
   def parse(string)
     # First, split the string according to the "token" instructions given.
-    # Afterwards @tokens contains all tokens that are to be parsed. 
+    # Afterwards @tokens contains all tokens that are to be parsed.
     tokenize(string)
 
     # These variables are used to match if the total number of tokens
@@ -175,12 +175,13 @@ class Parser
     # Parse (and evaluate) the tokens received
     result = @start.parse
     # If there are unparsed extra tokens, signal error
+    #
     if @pos != @tokens.size
       raise ParseError, "Parse error. expected: '#{@expected.join(', ')}', found '#{@tokens[@max_pos]}'"
     end
     return result
   end
-  
+
   def next_token
     @pos += 1
     return @tokens[@pos - 1]
@@ -198,31 +199,31 @@ class Parser
     @expected << tok if @max_pos == @pos - 1 && !@expected.include?(tok)
     return nil
   end
-  
+
   def to_s
     "Parser for #{@language_name}"
   end
 
   private
-  
+
   LexToken = Struct.new(:pattern, :block)
-  
+
   def token(pattern, &block)
     @lex_tokens << LexToken.new(Regexp.new('\\A' + pattern.source), block)
   end
-  
+
   def start(name, &block)
     rule(name, &block)
     @start = @rules[name]
   end
-  
+
   def rule(name,&block)
     @current_rule = Rule.new(name, self)
     @rules[name] = @current_rule
     instance_eval(&block) # In practise, calls match 1..N times
     @current_rule = nil
   end
-  
+
   def match(*pattern, &block)
     # Basically calls memberfunction "match(*pattern, &block)
     @current_rule.send(:match, *pattern, &block)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pycplus
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Johannes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-05 00:00:00.000000000 Z
+date: 2024-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit