mvsk 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d25c6ee53316bfdf1a6b23855d7df851b1db4ab27dc8d08b3564bc03e05dabf
-  data.tar.gz: 2e892657a1b4c1cbb43f5843b380af172d0e9c2a9b50ef656a0f4743ca47660b
+  metadata.gz: f04de2ea639c5201033077c0853085693663dcb0c8ffe2bcc4dde87ae0824fc2
+  data.tar.gz: 609ab7ff6ef10298d6d263a77b6594f4575e16c967116ace4bc2d4c328ab5fb5
 SHA512:
-  metadata.gz: ddf0fa19233e74a7165e37cc867bf2829971f18ebd353e253cf4338ea790387fb0722b080740fb9d309b99aa561f65dbd2e6eaa83035da7ee11a83e2cd4006ee
-  data.tar.gz: e9e5e64332ab975c498782d94bd84efb4a0265d3cfa20a7087c6b3a4b7fba5547466d46da08615ca524a80f5cc2cc9bf2311957be836d903951c01fede0a7ecf
+  metadata.gz: 25dd4c8a0a1a9891f287ec03bfe849556994e5c6ba34e374cf2abd01d2e38f949d8fd766b7f190735bb132b15d4c79ff0b9755f9b4d997db35bd2ead960a9535
+  data.tar.gz: 8691243c770fb63eb12eb502a9dbd09b7448d6d7808b0ca5680efa7868f639916b358533fa89a5b1f102faac7c1cc591908ab38eb2565443219326c5cf2f7015

data/bin/mvsk

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+require 'musk'
+
+args = ARGV.reject { |s| s.start_with?('-') }
+opts = ARGV - args
+
+if args.length == 1 and opts.empty?
+  Musk.run_file(args.first)
+elsif ARGV.length.zero?
+  Musk.run_prompt
+else
+  require 'pastel'
+  require 'optparse'
+
+  OptionParser.new do |op|
+    op.version = Musk::VERSION
+    op.banner = <<~USAGE
+      #{0}
+
+      Usage:
+
+        mvsk <file> [options]
+
+      Options:
+    USAGE
+
+    op.on '--tokens', 'print tokens' do
+      puts 'tokens'
+    end
+
+    op.on '--nodes', 'print nodes' do
+      puts 'nodes'
+    end
+
+    op.summary_width = 22
+
+    if args.length > 1
+      puts op
+      exit
+    end
+  end.parse!
+end

data/lib/musk/lexer/helper.rb

@@ -0,0 +1,27 @@
+module Musk
+  class Lexer
+    module Helper
+      def is_alpha_numeric(char)
+        is_alpha(char) || is_digit(char)
+      end
+
+      def is_alpha(char)
+        ('A' <= char && char <= 'Z') ||
+        ('a' <= char && char <= 'z') ||
+        ('_' == char)
+      end
+
+      def is_digit(char)
+        '0' <= char && char <= '9'
+      end
+
+      def is_bool(str)
+        str == 'true' || str == 'false'
+      end
+
+      def is_nil(str)
+        str == 'nil'
+      end
+    end
+  end
+end

data/lib/musk/lexer/keywords.rb

@@ -0,0 +1,51 @@
+module Musk
+  class Lexer
+    module Keywords
+      RESERVED_WORDS = {
+        :if => Token::If,
+        :else => Token::Else,
+        :switch => Token::Switch,
+        :case => Token::Case,
+        :default => Token::Default,
+        :for => Token::For,
+        :in => Token::In,
+        :loop => Token::Loop,
+        :break => Token::Break,
+        :continue => Token::Continue,
+        :class => Token::Class,
+        :extends => Token::Extends,
+        :super => Token::Super,
+        :self => Token::Self,
+        :get => Token::Get,
+        :set => Token::Set,
+        :fun => Token::Fun,
+        :return => Token::Return,
+        :let => Token::Let,
+        :mut => Token::Mut,
+        :and => Token::And,
+        :or => Token::Or,
+        :is => Token::Is,
+        :not => Token::Not,
+        :import => Token::Import,
+        :as => Token::As,
+        :throw => Token::Throw,
+        :try => Token::Try
+      }
+    end
+  end
+end
+
+# var tokens = [...]string{
+#   Int:         "<int>",
+#   Float:       "<float>",
+#   Identifier:  "Identifier",
+#   String:      "<string>",
+#   Rune:        "<rune>",
+#   Bool:        "<bool>",
+#   Nil:         "nil",
+#   HashBang:    "#!",
+#   Pipeline:    "|>",
+#   Tilde:       "~",
+#   Println:     "println",
+#   Illegal:     "Illegal",
+#   EOF:         "EOF",

data/lib/musk/lexer.rb

@@ -0,0 +1,309 @@
+require 'musk/lexer/keywords'
+require 'musk/lexer/helper'
+
+module Musk
+  class Lexer
+    include Helper
+    include Keywords
+
+    attr_reader :tokens
+
+    def initialize(code)
+      @tokens = []
+      @input = code
+      @line = 1
+      @start = 0
+      @current = 0
+    end
+
+    def scan_tokens
+      until at_end?
+        @start = @current
+        scan_token
+      end
+
+      add_token(Token::EOF, '')
+      @tokens
+    end
+
+    def next_token
+      until at_end?
+        @start = @current
+        break if scan_token
+      end
+
+      @token_i = 0 if @token_i.nil?
+      @token_i += 1
+
+      if @token_i <= @tokens.size
+        @tokens.last
+      else
+        nil
+      end
+    end
+
+    private
+
+    def scan_token
+      char = advance
+
+      return false if skip_whitespace(char)
+      return false if skip_comment(char)
+
+      single_token(char) ||
+      double_token(char) ||
+      triple_token(char) ||
+      string_token(char) ||
+      number_token(char) ||
+      identifier_token(char)
+    end
+
+    def skip_whitespace(char)
+      if char == "\n"
+        @line += 1
+        return true
+      end
+
+      char == "\r" ||
+      char == "\t" ||
+      char == ' '
+    end
+
+    def skip_comment(char)
+      if char == '/' && match?('/')
+        until peek == "\n" || at_end?
+          advance
+        end
+
+        true
+      else
+        false
+      end
+    end
+
+    def identifier_token(char)
+      if is_alpha(char)
+        while is_alpha_numeric(peek)
+          advance
+        end
+
+        lexeme = @input[@start...@current]
+
+        if is_bool(lexeme)
+          add_token_bool(lexeme)
+        elsif is_nil(lexeme)
+          add_token(Token::Nil, 'nil')
+        else
+          if type = RESERVED_WORDS[lexeme.to_sym]
+            add_token(type, lexeme)
+          else
+            add_token(Token::Identifier, lexeme)
+          end
+        end
+
+        true
+      else
+        add_token(Token::Illegal, nil, "unexpected '#{char}'")
+        false
+      end
+    end
+
+    def string_token(char)
+      if char == '"'
+        until peek == '"' || at_end?
+          if peek == "\n"
+            @line += 1
+          end
+
+          advance
+        end
+
+        if at_end?
+          add_token(Token::Illegal, nil, 'unterminated string')
+          return false
+        end
+
+        advance
+        add_token_string(@input[@start...@current])
+
+        true
+      else
+        false
+      end
+    end
+
+    def number_token(char)
+      if is_digit(char)
+        while is_digit(peek)
+          advance
+        end
+
+        if peek == '.' && is_digit(peek_next)
+          advance
+
+          while is_digit(peek)
+            advance
+          end
+
+          add_token_float(@input[@start...@current])
+        else
+          add_token_int(@input[@start...@current])
+        end
+
+        true
+      else
+        false
+      end
+    end
+
+    def single_token(char)
+      case char
+      when '+' then add_token(Token::Plus)
+      when '-' then add_token(Token::Minus)
+      when '*' then add_token(Token::Star)
+      when '/' then add_token(Token::Slash)
+      when '%' then add_token(Token::Modulo)
+      when ',' then add_token(Token::Comma)
+      when ':' then add_token(Token::Colon)
+      when ';' then add_token(Token::Semi)
+      when '.' then add_token(Token::Dot)
+      when '{' then add_token(Token::LeftBrace)
+      when '}' then add_token(Token::RightBrace)
+      when '[' then add_token(Token::LeftSquare)
+      when ']' then add_token(Token::RightSquare)
+      when '(' then add_token(Token::LeftParen)
+      when ')' then add_token(Token::RightParen)
+      else
+        return false
+      end
+
+      true
+    end
+
+    def double_token(char)
+      case char
+      when '!'
+        if match?('=')
+          add_token(Token::BangEq)
+        else
+          add_token(Token::Bang)
+        end
+      when '='
+        if match?('=')
+          add_token(Token::EqualEq)
+        else
+          add_token(Token::Equal)
+        end
+      when '>'
+        if match?('=')
+          add_token(Token::GreaterEq)
+        else
+          add_token(Token::Greater)
+        end
+      when '<'
+        if match?('=')
+          add_token(Token::LessEq)
+        else
+          add_token(Token::Less)
+        end
+      when '?'
+        if match?('.')
+          add_token(Token::QuestionDot)
+        else
+          add_token(Token::Question)
+        end
+      else
+        return false
+      end
+
+      true
+    end
+
+    def triple_token(char)
+      case char
+      when '&'
+        if match?('&')
+          if match?('=')
+            add_token(Token::Illegal)
+          else
+            add_token(Token::And)
+          end
+        else
+          add_token(Token::BitwiseAnd)
+        end
+      when '|'
+        if match?('|')
+          if match?('=')
+            add_token(Token::Illegal)
+          else
+            add_token(Token::Or)
+          end
+        else
+          if match?('>')
+            add_token(Token::Pipeline)
+          else
+            add_token(Token::BitwiseOr)
+          end
+        end
+      else
+        return false
+      end
+
+      true
+    end
+
+    def add_token_bool(lexeme)
+      value = lexeme.eql?('true')
+      add_token(Token::Bool, lexeme, value)
+    end
+
+    def add_token_string(lexeme)
+      value = lexeme[1, lexeme.length - 2]
+      add_token(Token::String, lexeme, value)
+    end
+
+    def add_token_float(lexeme)
+      add_token(Token::Float, lexeme, lexeme.to_f)
+    end
+
+    def add_token_int(lexeme)
+      add_token(Token::Int, lexeme, lexeme.to_i)
+    end
+
+    def add_token(type, lexeme = nil, literal = nil)
+      lexeme = @input[@start...@current] if lexeme.nil?
+      @tokens.push(Token.new(type, lexeme, literal, @line))
+    end
+
+    def match?(char)
+      return false if at_end?
+      return false if @input[@current] != char
+
+      @current += 1
+      true
+    end
+
+    def peek
+      return "\0" if at_end?
+      @input[@current]
+    end
+
+    def peek_next
+      if @current + 1 < @input.length
+        @input[@current + 1]
+      else
+        "\0"
+      end
+    end
+
+    def advance
+      char = @input[@current]
+      @current += 1
+      char
+    end
+
+    def at_end?
+      @current >= @input.length
+    end
+  end
+end

data/lib/musk/nodes.rb

@@ -0,0 +1,214 @@
+module Musk
+  module Nodes
+    class Node
+      def accept(visitor)
+        raise NotImplementedError
+      end
+    end
+
+    class Program < Node; end
+    class Expression < Node; end
+    class Statement < Node; end
+    class Declaration < Statement; end
+
+    class BlockStatement < Statement
+      attr_reader :statements
+
+      def initialize(statements:)
+        @statements = statements
+      end
+
+      def accept(visitor)
+        visitor.visit_block_stmt(self)
+      end
+    end
+
+    class IfStatement < Statement
+      #   //   Condition Expression
+      #   //   Then Statement
+      #   //   Else Statement
+    end
+
+    class ForStatement < Statement
+    end
+
+    class LoopStatement < Statement
+      #   //   Condition Expression
+      #   //   Body Statement
+    end
+
+    class ContinueStatement < Statement
+      # Label Expression
+    end
+
+    class BreakStatement < Statement
+      # Label Expression
+    end
+
+    class ReturnStatement < Statement
+      attr_reader :keyword, :value
+
+      def initialize(keyword:, value:)
+        @keyword = keyword
+        @value = value
+        # Argument Expression
+      end
+
+      def accept(visitor)
+        visitor.visit_return_stmt(self)
+      end
+    end
+
+    class ExpressionStatement < Statement
+      attr_reader :expression
+
+      def initialize(expression:)
+        @expression = expression
+      end
+
+      def accept(visitor)
+        visitor.visit_expression_stmt(self)
+      end
+    end
+
+    class ClassDeclaration < Declaration
+      # //   Name        token.Token
+      # //   Methods     []ClassMethod
+      # //   SuperClass  *VariableExpression
+    end
+
+    class VariableDeclaration < Declaration
+      # //   Name        token.Token
+      # //   Initializer Expression
+    end
+
+    class FunctionDeclaration < Declaration
+      attr_reader :name, :params, :body
+
+      def initialize(name:, params:, body:)
+        @name = name
+        @params = params
+        @body = body
+      end
+
+      def accept(visitor)
+        visitor.visit_function_stmt(self)
+      end
+    end
+
+    class Function < Expression
+      attr_reader :params, :body
+
+      def initialize(params:, body:)
+        @params = params
+        @body = body
+      end
+    end
+
+    class Assignment < Expression
+      #   Operator token.Token
+      #   Right    Expression
+      #   Left     Expression
+      #   //> expr-assign
+      #   static class Assign extends Expr {
+      #     Assign(Token name, Expr value) {
+      #       this.name = name;
+      #       this.value = value;
+      #     <R> R accept(Visitor<R> visitor) {
+      #       return visitor.visitAssignExpr(this);
+      #     final Token name;
+      #     final Expr value;
+    end
+
+    # type Variable struct {
+    #   Name string
+    #   Expression
+    # }
+
+    # type Identifier struct {
+    #   Name string
+    #   Expression
+    # }
+
+    class Call < Expression
+      attr_reader :callee, :args
+
+      def initialize(callee:, args:)
+        @callee = callee
+        @args = args
+        # final Token paren;
+        # this.paren = paren;
+      end
+
+      def accept(visitor)
+        visitor.visit_call_expr(self)
+      end
+    end
+
+    class Logical < Expression
+      attr_reader :left, :operator, :right
+
+      def initialize(left:, operator:, right:)
+        @left = left
+        @operator = operator
+        @right = right
+      end
+
+      def accept(visitor)
+        visitor.visit_logical_expr(self)
+      end
+    end
+
+    class Grouping < Expression
+      attr_reader :expr
+
+      def initialize(expr:)
+        @expr = expr
+      end
+
+      def accept(visitor)
+        visitor.visit_grouping_expr(self)
+      end
+    end
+
+    class Binary < Expression
+      attr_reader :left, :operator, :right
+
+      def initialize(left:, operator:, right:)
+        @left = left
+        @operator = operator
+        @right = right
+      end
+
+      def accept(visitor)
+        visitor.visit_binary_expr(self)
+      end
+    end
+
+    class Unary < Expression
+      attr_reader :operator, :right
+
+      def initialize(operator:, right:)
+        @operator = operator
+        @right = right
+      end
+
+      def accept(visitor)
+        visitor.visit_unary_expr(self)
+      end
+    end
+
+    class Literal < Expression
+      attr_reader :type, :value
+
+      def initialize(type:, value:)
+        @type = type
+        @value = value
+      end
+
+      def accept(visitor)
+        visitor.visit_literal_expr(self)
+      end
+    end
+  end
+end

data/lib/musk/parser.rb

@@ -0,0 +1,170 @@
+module Musk
+  class Parser
+    def initialize(tokens)
+      @tokens = tokens
+      @current = 0
+    end
+
+    def parse
+      statements = []
+      statements.push(declaration) until at_end?
+      # statements.add(statement());
+      statements
+    end
+
+    private
+
+    def declaration
+      begin
+        #       if (match(CLASS)) return classDeclaration();
+        #       if (match(FUN)) return function("function");
+        #       if (match(VAR)) return varDeclaration();
+        statement
+      rescue ParseError
+        synchronize
+        nil
+      end
+    end
+
+    def statement
+      return if_statement if match?(Token::If)
+      return for_statement if match?(Token::For)
+      return loop_statement if match?(Token::Loop)
+      return return_statement if match?(Token::Return)
+
+#     if (match(LEFT_BRACE)) return new Stmt.Block(block());
+#     return expressionStatement();
+    end
+
+    #   private Stmt expressionStatement() {
+#     Expr expr = expression();
+#     consume(SEMICOLON, "Expect ';' after expression.");
+#     return new Stmt.Expression(expr);
+#   }
+
+
+    def synchronize
+      advance
+
+      until at_end?
+        return if previous.type == Token::Semi
+        return if peek.type == Token::Class
+        return if peek.type == Token::Fun
+        return if peek.type == Token::Return
+        return if peek.type == Token::Let
+        return if peek.type == Token::If
+        return if peek.type == Token::Switch
+        return if peek.type == Token::For
+        return if peek.type == Token::Loop
+
+        advance
+      end
+    end
+
+
+    def expression
+      assignment
+    end
+
+    def assignment
+
+    end
+
+#   private Expr unary() {
+#     if (match(BANG, MINUS)) {
+#       Token operator = previous();
+#       Expr right = unary();
+#       return new Expr.Unary(operator, right);
+#     }
+#     return call();
+#   }
+
+    def primary
+      return literal(previous) if match?(Token::Nil, Token::Bool)
+      return literal(previous) if match?(Token::Int, Token::Float)
+      return literal(previous) if match?(Token::String)
+
+      if match?(Token::Super)
+        # Token keyword = previous();
+        consume(Token::Dot, "expect '.' after 'super'")
+        method = consume(Token::Identifier, 'expect superclass method name')
+        return Nodes::Super.new()
+        # .(keyword, method);
+        # .{Method: tok.Value}
+      end
+
+      if match?(Token::Self)
+        return Nodes::Self.new(previous)
+      end
+
+      if match?(Token::Identifier)
+        #     tok := p.previous()
+        #     return ast.Variable{Name: tok.Value}
+        #       return new Expr.Variable(previous());
+      end
+
+      if match?(Token::LeftParen)
+        exp = primary
+        # expr = expression();
+        consume(Token::RightParen, "expect ')' after expression")
+        return Nodes::Grouping.new(expr: exp)
+      end
+
+      #   //   panic(ParseError{token: p.peek(), message: "Expect expression"})
+      #   panic("error")
+      # }
+      #     throw error(peek(), "Expect expression.");
+    end
+
+    def literal(token)
+      Nodes::Literal.new(type: token.type, value: token.literal)
+    end
+
+    def consume(type, message)
+      return advance if check?(type)
+      error peek, message
+      raise ParseError
+    end
+
+    def error(tok, message)
+      if tok.type == Token::EOF
+#       report(token.line, " at end", message);
+      else
+#       report(token.line, " at '" + token.lexeme + "'", message);
+      end
+    end
+
+    def match?(*types)
+      types.each do |type|
+        if check?(type)
+          advance
+          return true
+        end
+      end
+
+      false
+    end
+
+    def check?(type)
+      return false if at_end?
+      peek.type == type
+    end
+
+    def advance
+      @current += 1 unless at_end?
+      previous
+    end
+
+    def previous
+      @tokens[@current - 1]
+    end
+
+    def peek
+      @tokens[@current]
+    end
+
+    def at_end?
+      peek.type == Token::EOF
+    end
+  end
+end

data/lib/musk/token.rb

@@ -0,0 +1,48 @@
+module Musk
+  class Token
+    class << self
+      def token_type(*types)
+        types.each do |type|
+          const_set type, type.to_s
+        end
+      end
+    end
+
+    attr_reader :type, :lexeme, :literal, :line
+
+    token_type :Plus, :Minus, :Star, :Slash, :Modulo,
+               :Comma, :Colon, :Semi, :Dot,
+               :LeftBrace, :RightBrace,
+               :LeftSquare, :RightSquare,
+               :LeftParen, :RightParen
+
+    token_type :Bang, :BangEq, :Equal, :EqualEq,
+               :Greater, :GreaterEq, :Less, :LessEq,
+               :BitwiseAnd, :BitwiseOr, :And, :Or,
+               :Question, :QuestionDot,
+               :Pipeline
+
+    token_type :Int, :Float, :String, :Char, :Bool, :Nil,
+               :Identifier, :Illegal, :EOF
+
+    token_type :If, :Else, :Switch, :Case, :Default,
+               :For, :In, :Loop, :Break, :Continue,
+               :Class, :Extends, :Super, :Self,
+               :Get, :Set, :Fun, :Return,
+               :Let, :Mut, :Is, :Not,
+               :Import, :As,
+               :Throw, :Try
+
+    def initialize(type, lexeme, literal = nil, line)
+      @type = type
+      @lexeme = lexeme
+      @literal = literal
+      @line = line
+    end
+
+    def to_s
+      return @type if @literal.nil?
+      "#{@type} #{@lexeme} #{@literal}"
+    end
+  end
+end

data/lib/musk/types.rb

@@ -0,0 +1,24 @@
+module Musk
+  module Types
+    class List
+    end
+
+    class Int
+    end
+
+    class Float
+    end
+
+    class String
+    end
+
+    class Char
+    end
+
+    class Bool
+    end
+
+    class Nil
+    end
+  end
+end

data/lib/musk/version.rb

@@ -0,0 +1,3 @@
+module Musk
+  VERSION = '1.0.2'
+end

data/lib/musk.rb

@@ -0,0 +1,79 @@
+require 'musk/version'
+require 'musk/token'
+require 'musk/lexer'
+require 'musk/nodes'
+require 'musk/parser'
+
+module Musk
+  class ParseError < RuntimeError; end
+
+  module_function
+
+  def run_prompt
+    require 'pastel'
+    require 'readline'
+
+    stty_save = `stty -g`.chomp
+
+    begin
+      while buf = Readline.readline('> ', true)
+        break if buf.nil?
+        break if buf.strip == 'exit'
+
+        print run(buf), "\n"
+        # run(line); //> reset-had-error
+        # hadError = false;
+      end
+    rescue Interrupt
+      system 'stty', stty_save
+    ensure
+      puts
+      exit
+    end
+  end
+
+  def run_file(path)
+    if File.exist?(path) && File.file?(path)
+      puts 'fiasd'
+    else
+      warn "No such file #{path}"
+    end
+
+    # run(File.read(path))
+    # # if (hadError) System.exit(65);
+    # # if (hadRuntimeError) System.exit(70);
+  end
+
+  def run(code)
+    lexer = Lexer.new(code)
+    tokens = lexer.scan_tokens
+    tokens.each { |token| puts token }
+  end
+end
+
+# ["And",
+#  "Class",
+#  "Else",
+#  "False",
+#  "Fun",
+#  "For",
+#  "If",
+#  "Nil",
+#  "Or",
+#  "Print",
+#  "Return",
+#  "Super",
+#  "This",
+#  "True",
+#  "Var",
+#  "While"]
+# Int
+# Float
+# Bool
+# String
+# Char
+# Unit
+# Tuple
+# List
+# Array
+# Function

data/lib/mvsk.rb

@@ -1,2 +1 @@
-module Musk
-end
+# https://elm-lang.org/docs/syntax

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mvsk
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - razeos at tossdev
@@ -9,13 +9,38 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2023-07-18 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
 description: 
 email: 
-executables: []
+executables:
+- mvsk
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/mvsk
+- lib/musk.rb
+- lib/musk/lexer.rb
+- lib/musk/lexer/helper.rb
+- lib/musk/lexer/keywords.rb
+- lib/musk/nodes.rb
+- lib/musk/parser.rb
+- lib/musk/token.rb
+- lib/musk/types.rb
+- lib/musk/version.rb
 - lib/mvsk.rb
 homepage: 
 licenses:
@@ -39,5 +64,5 @@ requirements: []
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: mvsk at tossdev
+summary: A simple programming language
 test_files: []