pycplus 0.4.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f3bc5bfe8923bf561c4a2b3167a862151f1487d62b84bb1587f9f07b0433c63
-  data.tar.gz: 4872ec376c3501b869ed773b0a535b894abe35d9af05af81784cf081a34696dc
+  metadata.gz: b5ad55e5bb630968fc874f2b4864d1157f613387a386963d80ae70a059f7fe82
+  data.tar.gz: 3f9cd2e36bb0307ad340f1e0279904761d0bf0b6d1f8f14a61cb86230aacc0b6
 SHA512:
-  metadata.gz: 84dd3244332bfe07a86e8448276f0bdb7ebd5318696ba882ab707fbb8e82aaeba63e40c6cc531a166012461df549a47bede2e9a07bab81cf58255f1d6faeb784
-  data.tar.gz: 3002a3bc7ce8f595fd1f84371796cd4ad0ce9de8ad4f0d08c5dbe7278685c9278f8be3fbc7f7d8618b923ef03af483c0e0f4d65cda9b934918f3bc3ff0c918b6
+  metadata.gz: fd8d3e774ffa9e0008799e40a612a4f0855736f4ffb7a80c7bd47b0215586e054b8843f3eb9c01b212bd11b651a593510531ad439a0a8ec5a5b3abd8d16c6587
+  data.tar.gz: a425b2c00467899bedaa54b2ba471b731f10f3013daf726295b0105e5258ac8253e6e33dc16a551d0cd52a2f5a35048bb7c5578b7b9c36664534cc019c901988

data/README.md

@@ -1,3 +1,48 @@
-# 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
+```
+
+## Flags
+
+Several flags can be used with the gem.
+
+Type the following command to see the available flags:
+
+```bash
+pycplus -h
+```
+
+## Usage
+
+The programming language is to be used with files of type .pcp.
+
+To run a file, navigate to the directory where the file is located and type the following command:
+
+```bash
+pycplus filename.pcp
+```
+
+## Unit testing
+
+Unit tests can be ran from the projects test directory.
+
+Navigate to the projectfolder and type the following command:
+
+```bash
+rake
+```
+
+## Additional documentation
+
+Additional documentation about the language and system can be found in the 'doc' directory. This documentation is in Swedish.

data/bin/pycplus

@@ -12,7 +12,8 @@ def print_version
         puts "#{spec.name} version #{spec.version}"
     rescue
         begin
-            spec = Gem::Specification.load('../pycplus.gemspec')
+            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"
@@ -27,6 +28,11 @@ OptionParser.new do |opts|
 
     opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} [options] filename"
 
+    opts.on("-h", "--help", "Display this help message") do
+        puts opts
+        exit
+    end
+
     # 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
@@ -35,7 +41,6 @@ OptionParser.new do |opts|
 
     opts.on("-d", "--debug", "Enable debug mode") do
         options[:debug] = true
-        print("dhsdhshdshds")
     end
 end.parse!
 

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,17 +227,26 @@ 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
 
   def parse_file(filename)
-    file = File.open(filename)
-    file_data = file.read
-    result = @pycplus_parser.parse(file_data)
-    return result.evaluate if result
+    file_data = File.read(filename)
+    result = nil
+    begin
+      ast = @pycplus_parser.parse(file_data)
+      result = ast.evaluate if ast
+    rescue StandardError => e
+      puts "Something went wrong! #{e.class}: #{e.message}"
+    end
+    return result
   end
 
   def parse_string(str, return_tree = false, display_output = false)
@@ -258,7 +268,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.1
+  version: 1.1.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-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -31,8 +31,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.6.0
-description: This Ruby Gem provides a framework for creating and utilizing a programming
-  language developed as part of a school project at LiU (Linköping University).
+description: This Ruby Gem provides the tools to parse, interpret, and execute programs
+  written in a custom programming language, developed as part of a school project
+  at LiU (Linköping University).
 email: test@test.com
 executables:
 - pycplus
@@ -66,5 +67,5 @@ requirements: []
 rubygems_version: 3.3.5
 signing_key: 
 specification_version: 4
-summary: A Ruby Gem for creating and using a programming language.
+summary: A Ruby Gem for creating and running programs in a custom language.
 test_files: []