l43_rmap 0.1.0

data/lib/l43_rmap/parsing/rgx_parsers.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'rgx_parser'
+module L43Rmap
+  module Parsing
+    module RgxParsers
+      include Ast
+
+      BAREWORD   = /\A[^\s\)]+/
+      BarewordParser = RgxParser.new(BAREWORD) { Bareword.new(it) }
+
+      DQUOTE     = /\A"/
+      DquoteParser = RgxParser.new(DQUOTE)
+
+      ESC_DQUOTE = /\A"(")/
+      EscDquoteParser = RgxParser.new(ESC_DQUOTE)
+
+      ESC_SQUOTE = /\A'(')/
+      EscSquoteParser = RgxParser.new(ESC_SQUOTE)
+
+      ESCAPE     = /\A%([%(])/
+      EscapeParser = RgxParser.new(ESCAPE) { Verb.new(it) }
+
+      INDEXED_FIELD      = /\A%([-+]?\d+) ?/
+      IndexedFieldParser = RgxParser.new(INDEXED_FIELD) { IndexedField.new(it.to_i) }
+
+      NAMED_FIELD = /\A%([[:alpha:]][_[:alnum:]]*) ?/
+      NamedFieldParser = RgxParser.new(NAMED_FIELD) { NamedField.new(it) }
+
+      NAME       = /\A[[:alpha:]][_[:alnum:]]*[\!\?]?/
+      NameParser = RgxParser.new(NAME) { Name.new(it) }
+
+      INT        = /\A[-+]?\d+/
+      IntParser = RgxParser.new(INT) { Int.new(it.to_i) }
+
+      LPAR       = /\A\(/
+      LparParser = RgxParser.new(LPAR) { :ignore }
+
+      NO_DQUOTE  = /\A[^"]+/
+      NoDquoteParser = RgxParser.new(NO_DQUOTE)
+
+      NO_META    = /\A[^%(]+/
+      NoMetaParser = RgxParser.new(NO_META) { Verb.new(it) }
+
+      NO_SQUOTE  = /\A[^']+/
+      NoSquoteParser = RgxParser.new(NO_SQUOTE)
+
+      OP         = /\A([-+*\/%])\s*/
+      OpParser = RgxParser.new(OP) { Name.new(it) }
+
+      RPAR       = /\A\)/
+      RparParser = RgxParser.new(RPAR)
+
+      SQUOTE     = /\A'/
+      SquoteParser = RgxParser.new(SQUOTE)
+
+      SYMBOL     = /\A:([[:alpha:]][_[:alnum:]]*[\!\?]?)/
+      SymbolParser = RgxParser.new(SYMBOL) { Sym.new(it) }
+
+      WS         = /\A\s+/
+      WsParser = RgxParser.new(WS)
+
+      ZEROFIELD  = /\A%(?: |\z)/
+      ZerofieldParser = RgxParser.new(ZEROFIELD) { IndexedField.new(0) }
+
+      ZEROFIELD_INSIDE = /\A(%)(?: |\))/
+      ZerofieldInsideParser = RgxParser.new(ZEROFIELD_INSIDE, only_group: true) { IndexedField.new(0) }
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/predefined_patterns.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module L43Rmap
+  module PredefinedPatterns extend self
+    
+    Patterns = {
+      mv_to_ms: 'mv %  (lpad %n 0 4).(ext)',
+      mv_to_mse: 'mv (se) (lpad %n 0 4).(ext)',
+    }
+      
+    def get_pattern(key) = Patterns.fetch(key.to_sym)
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/runtime/line_time.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require_relative '../chunk'
+require_relative '../evaluator'
+require_relative '../function'
+require "securerandom"
+module L43Rmap
+  class Runtime
+    class LineTime
+      Ast = L43Rmap::Ast
+      Chunk = L43Rmap::Chunk
+      Function = L43Rmap::Function
+
+      attr_reader :line, :lnb, :rand, :runtime, :terminated, :time
+
+      def run
+        chunks = runtime.chunks
+        # p(chunks: chunks.map(&:show))
+        loop do
+          case chunks
+          in []
+            return outstack.compact
+          in [chunk, *chunks]
+            result = chunk.(self)
+            # p(result:)
+            case result
+            when Symbol
+              return result
+            else
+              outstack.push(result)
+            end
+          end
+        end
+      end
+
+      def fields =  @__fields__ ||= line.split
+
+      def outstack =  @__outstack__ ||= []
+
+      def terminate! = @terminated=true
+
+      private
+      def initialize(line:, lnb:, runtime:)
+        @chunks = runtime.chunks
+        @line = line
+        @lnb = lnb
+        @runtime = runtime
+        @time = Time.new
+      end
+
+      def terminate_runtime
+        runtime.terminate
+        return [:terminate]
+      end
+
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/runtime.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'runtime/line_time' 
+
+module L43Rmap
+  class Runtime
+    attr_reader :chunks, :current, :input_stream, :output_stream, :rand, :terminated, :time
+
+    DefaultDecRandomMax = 10_000
+
+    def run(input, output)
+      @output_stream = make_output_stream(output)
+      @input_stream = make_input_stream(input)
+      # @rand = SecureRandom.random_number
+      @time = Time.now
+      # p(time1: time.to_f)
+
+      execute!
+    rescue EOFError 
+    end
+
+    def random_hex =  @__randomhex__ ||= SecureRandom.hex
+
+    def random_rd =  @__randomrd__ ||= (format "%04d", SecureRandom.random_number(DefaultDecRandomMax))
+      
+    def image = chunks.map(&:image).join("\n")
+
+    def terminate! = @terminated = true
+
+    def timestamp(base, mult: 1_000, now: nil)
+      # p(time2: time.to_f)
+      now ||= time
+      (now.to_f * mult).to_i.to_s(base)
+    end
+
+
+    private
+    def execute!
+      lnb = 0
+      loop do
+        line = input_stream.readline chomp: true
+        lnb = lnb + 1
+        @current = LineTime.new(line:, lnb:, runtime: self)
+        result = current.run
+        # p(transformed: result)
+        case result
+        in []
+          next
+        in :ignore
+          next
+        in :terminate | :term
+          break
+        in Array
+          output_stream << result.join
+          output_stream << "\n" 
+        else
+          raise "BAD RETURN FROM LineTime: #{result.inspect}"
+        end
+      end
+    end
+
+    def initialize(chunks)
+      @chunks = chunks
+    end
+      
+    def make_input_stream(stream)
+      return stream unless String === stream
+      File.open(stream)
+    end
+      
+    def make_output_stream(stream)
+      return stream unless String === stream
+      File.open(stream, 'w')
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module L43Rmap
+  VERSION = '0.1.0'
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+##
+# Global Namespace for the Rmap language implementation
+require_relative 'l43_rmap/parsing/chunk_parser'
+require_relative 'l43_rmap/compiler'
+require_relative 'l43_rmap/runtime'
+
+module L43Rmap
+  PREDEFINED_FIELDS = [
+    "n",
+    "t",
+    "x"
+  ]
+
+  TAGS = [
+    :field,
+    :line,
+    :sexp,
+    :verb
+  ]
+
+  class << self
+    def compile(pattern)
+      ast = Parsing::ChunkParser.new.parse(pattern)
+      chunks = Compiler.new.compile(ast)
+      Runtime.new(chunks)
+    end
+  end
+end
+
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/all.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'combinators'
+require_relative 'parsers'
+require_relative 'parsers'
+module Peg
+  module All
+    include Combinators
+    include Parsers
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/combinators/implementation.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative '../../enumerable'
+module Peg
+  class InfiniteLoop < Exception; end
+
+  module Combinators
+    module Implementation
+
+      def _debug(parser, name: nil)
+        Parser.new(parser.name) do |input, _name|
+          puts "debugging #{name || parser.name}: #{input.inspect}"
+          result = Parser.parse(parser, input)
+          puts "debugging #{name || parser.name}: #{result}"
+          result
+        end
+      end
+
+      def _lookahead(parsers, name:)
+        parser = _select(parsers)
+        Parser.new(name || "lookahead(#{parser.name})") do |input, name|
+          case Parser.parse(parser, input)
+          in {ok: true}
+            {ok: true, ast: nil, input:}
+          in error
+            error
+          end
+        end
+      end
+
+      # def _map(parser, name, mapper)
+      #   name ||= "map(#{parser.name})"
+      #   Parser.new(name) do |input, _name|
+      #     case Parser.parse(parser, input)
+      #     in {ok: true, ast: ast, input: new_input}
+      #       {ok: true, ast: mapper.(ast), input: new_input}
+      #     in error
+      #       error
+      #     end
+      #   end
+      # end
+
+      def _map_result(parser, name, mapper)
+        Parser.new(name) do |input, name|
+          result = Parser.parse(parser, input)
+          # require "debug"; binding.break
+          mapper.(result)
+        end
+      end
+
+      def _many(parser, max:, min:, name:)
+        Parser.new(name) do |input, _name|
+          total_ast = []
+          original_input = input
+          current_input = input
+          match_count = 0
+          loop do
+            if current_input.empty?
+              break Result.ok(ast: total_ast, input:) if match_count >= min
+              break Result.nok(error: "many #{name} did not succeed the required #{min} times, but only #{match_count}", input: original_input, name:)
+            end
+
+            case Parser.parse(parser, current_input)
+            in {ok: true, ast:, input:}
+              raise InfiniteLoop, "must not parse zero width inside many in parser: #{parser.name}" if input.pos == current_input.pos
+              current_input = input
+              total_ast = [*total_ast, ast]
+              match_count += 1
+              break Result.ok(ast: total_ast, input:) if max && match_count >= max
+            else
+              break Result.ok(ast: total_ast, input:) if match_count >= min
+              break Result.nok(error: "many #{name} did not succeed the required #{min} times, but only #{match_count}", input: original_input, name:)
+            end
+          end
+        end
+      end
+
+      def _satisfy(parser, name:, &satisfier)
+        Parser.new(name || "satisfy(#{parser.name})") do |input, name|
+          original_input = input
+          case Parser.parse(parser, input)
+          in {ok: false} => error
+            error
+          in {ok: true, ast:, input:} => result
+            ok = satisfier.(ast)
+            if ok == true
+              result
+            elsif ok
+              {ok: true, ast: ok, input:}
+            else
+              {ok: false, input: original_input, error: "satisfier #{name} failed", name: name}
+            end
+          end
+        end
+      end
+
+      def _select(*parsers, name: nil)
+        parsers = parsers.flatten
+        raise ArgumentError, "all parsers must be instances of Parser" unless parsers.all? { Parser === it }
+        Parser.new(name || "select #{parsers.map(&:name).join(", ")}") do |input, name|
+          result = {ok: false, error: "No parser matched in select named #{name}", input:}
+          parsers.each do |parser|
+            # case p(Parser.parse(parser, input))
+            this_result = Parser.parse(parser, input)
+            # require "debug"; binding.break
+            case this_result
+            in {ok: true} => result
+              break result
+            in _
+              nil
+            end
+          end
+          result
+        end
+      end
+
+      def _sequence(parsers, name)
+        name ||= "seq(#{parsers.map(&:name).join(", ")})"
+        Parser.new(name) do |input, _name|
+          original_input = input
+          result = parsers.reduce_while [input, []] do |(input, ast), parser|
+            # require "debug"; binding.break
+            parsed = Parser.parse(parser, input)
+            # p parsed
+            case parsed
+            in {ok: true, ast: ast_node, input:}
+              cont_reduce([input, [*ast, ast_node]])
+            in {ok: false, error:}
+              halt_reduce(Result.nok(input: original_input, error:, name: name))
+            end
+          end
+
+          case result
+          in {ok: false} => error
+            error
+          in [input, ast]
+            Result.ok(ast:, input:)
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/combinators.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'parser'
+require_relative 'combinators/implementation'
+module Peg
+  module Combinators extend self
+    include Implementation
+
+    def lookahead(*parsers, name: nil)
+      parsers = make_parsers(*parsers)
+      _lookahead(parsers, name:)
+    end
+
+    def many(*parsers, max: nil, min: 0, name: nil)
+      name ||= "many(#{parsers.map(&:name).join(", ")})"
+      case parsers
+      in []
+        raise ArgumentError, "missing parser"
+      in [parser]
+        _many(parser, max:, min:, name:)
+      in _
+        many(select(*parsers), max:, min:, name:)
+      end
+    end
+
+    def map(parser, name: nil, &mapper)
+      raise ArgumentError, "missing mapper function" unless mapper
+      raise ArgumentError, "mapper function must have arity 1" unless mapper.arity == 1
+      name ||= "map(#{parser.name})"
+      Parser.new(name) do |input|
+        Parser.parse(parser, input).map(&mapper)
+      end
+    end
+    alias_method :_map, :map
+
+    def map_result(parser, name: nil, &mapper)
+      raise ArgumentError, "missing mapper function" unless mapper
+      raise ArgumentError, "mapper function must have arity 1" unless mapper.arity == 1
+      _map_result(parser, name || "map_result(#{parser.name})", mapper)
+    end
+
+    def maybe(parser, name: nil)
+      Parser.new(name || "maybe(#{parser.name})") do |input, name|
+        case Parser.parse(parser, input)
+        in {ok: false}
+          {ok: true, ast: nil, input:}
+        in success
+          success
+        end
+      end
+    end
+
+    def satisfy(parser, name: nil, &satisfier)
+      raise ArgumentError, "missing satisfier block" unless satisfier
+      parser = make_parser(parser)
+      _satisfy(parser, name, satisfier)
+    end
+
+    def select(*parsers, name: nil)
+      case parsers
+      in []
+        raise ArgumentError, "missing parser in select"
+      in [parser]
+        raise ArgumentError, "one parser in a selection is a NOP, remove the select call"
+      in _
+        _select(*make_parsers(parsers), name)
+      end
+    end
+
+    def sequence(*parsers, name: nil)
+      case parsers
+      in []
+        raise ArgumentError, "missing parser"
+      in [parser]
+        raise ArgumentError, "one parser in a sequence is a NOP, remove the sequence call"
+      in _
+        _sequence(make_parsers(parsers), name)
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/parser/input.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Peg
+  class Parser
+    class Input
+      attr_reader :content, :pos
+
+      def advance(by=1)
+        self.class.new(content.drop(by), pos+by)
+      end
+
+      def empty? = content.empty?
+
+      def show(count)
+        raise ArgumentError, "count must be an integer > 5" unless Integer === count && count > 5
+        return content.join("") if content.length < count
+
+        "#{content.take(count-3).join}..."
+      end
+
+      def ==(other)
+        self.class === other &&
+          other.content == content &&
+          other.pos == pos
+      end
+
+      private
+      def initialize(content, pos=1)
+        @content = content
+        @pos = pos
+      end
+      
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/parser.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'combinators/implementation'
+require_relative 'parser/input'
+require_relative 'parsers'
+require_relative 'result'
+
+module Peg
+  class Parser
+    include Peg::Combinators::Implementation
+
+    attr_reader :parse_fn, :name
+
+    def self.parse(parser, input)
+      raise ArgumentError, "parser must be an instance of #{self}" unless self === parser
+      case input
+      when String
+        parser.parse_fn.(Peg::Parser::Input.new(input.grapheme_clusters))
+      when Peg::Parser::Input
+        parser.parse_fn.(input)
+      else
+        raise ArgumentError, "input must be a string or instance of Input" unless self.class === parser
+      end
+    end
+
+    def and(*parsers, name:  nil) = _sequence([self, *parsers], name)
+
+    def debug(name: nil) = _debug(self, name:)
+
+    def many(name: nil, max: nil, min: 0) = _many(self, name:, max:, min:)
+    def map(name: nil, &blk) = Peg::Combinators.map(self, name:, &blk)
+
+    def or(*parsers, name: nil) = _select(self, *parsers, name:)
+
+    def satisfy(name: nil, &satisfier) = _satisfy(self, name:, &satisfier)
+
+    private
+    def initialize(name, &blk)
+      raise ArgumentError, "blk must be provided as a parse function" unless blk
+      @name = name
+      @parse_fn = blk
+    end
+    
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/peg.backup/parsers/advanced_parsers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../combinators'
+require_relative '../parsers'
+module Peg
+  module Parsers
+    module AdvancedParsers
+      include Peg::Combinators
+      include Peg::Parsers
+
+      def list_parser(element_parser:, seperator_parser:, name: "list parser")
+        sequence(
+          element_parser,
+          many(
+            sequence(
+              seperator_parser, element_parser
+            )
+              .map { it[1] }
+          )
+        )
+          .map { it.flatten.compact }
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later