postsvg 0.2.2 → 0.3.0

data/lib/postsvg/model/operators/arithmetic.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Arithmetic
+        BINARY_DEFAULT = { consumes: 2, produces: 1 }.freeze
+        UNARY_DEFAULT = { consumes: 1, produces: 1 }.freeze
+
+        class Add < Operator
+          register_as "add", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Sub < Operator
+          register_as "sub", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Mul < Operator
+          register_as "mul", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Div < Operator
+          register_as "div", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Idiv < Operator
+          register_as "idiv", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number.to_i
+            a = stack.pop_number.to_i
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Mod < Operator
+          register_as "mod", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number.to_i
+            a = stack.pop_number.to_i
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Neg < Operator
+          register_as "neg", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Abs < Operator
+          register_as "abs", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Ceiling < Operator
+          register_as "ceiling", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Floor < Operator
+          register_as "floor", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Round < Operator
+          register_as "round", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Truncate < Operator
+          register_as "truncate", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Sqrt < Operator
+          register_as "sqrt", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Atan < Operator
+          register_as "atan", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Cos < Operator
+          register_as "cos", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Sin < Operator
+          register_as "sin", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Ln < Operator
+          register_as "ln", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Log < Operator
+          register_as "log", **UNARY_DEFAULT
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop_number)
+          end
+        end
+
+        class Exp < Operator
+          register_as "exp", **BINARY_DEFAULT
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/operators/boolean.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Boolean
+        # PS boolean literals. They look like operator tokens but
+        # push constant Boolean values. Modeled as zero-arity
+        # operators so the parser/registry handle them naturally.
+        class True < Operator
+          register_as "true", consumes: 0, produces: 1
+        end
+
+        class False < Operator
+          register_as "false", consumes: 0, produces: 1
+        end
+
+        class Eq < Operator
+          register_as "eq"
+          def self.from_operands(stack)
+            b = stack.pop
+            a = stack.pop
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Ne < Operator
+          register_as "ne"
+          def self.from_operands(stack)
+            b = stack.pop
+            a = stack.pop
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Gt < Operator
+          register_as "gt"
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Ge < Operator
+          register_as "ge"
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Lt < Operator
+          register_as "lt"
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Le < Operator
+          register_as "le"
+          def self.from_operands(stack)
+            b = stack.pop_number
+            a = stack.pop_number
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class And < Operator
+          register_as "and"
+          def self.from_operands(stack)
+            b = stack.pop
+            a = stack.pop
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Or < Operator
+          register_as "or"
+          def self.from_operands(stack)
+            b = stack.pop
+            a = stack.pop
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Xor < Operator
+          register_as "xor"
+          def self.from_operands(stack)
+            b = stack.pop
+            a = stack.pop
+            new(operand_a: a, operand_b: b)
+          end
+          attr_reader :operand_a, :operand_b
+          def initialize(operand_a:, operand_b:)
+            @operand_a = operand_a
+            @operand_b = operand_b
+            freeze
+          end
+        end
+
+        class Not < Operator
+          register_as "not"
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop)
+          end
+        end
+
+        class Bitshift < Operator
+          register_as "bitshift"
+          def self.from_operands(stack)
+            shift = stack.pop_number.to_i
+            value = stack.pop_number.to_i
+            new(operand: value, shift: shift)
+          end
+          attr_reader :operand, :shift
+          def initialize(operand:, shift:)
+            @operand = operand
+            @shift = shift
+            freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/operators/color.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Color
+        class Setgray < Operator
+          register_as "setgray"
+          attr_reader :gray
+          def initialize(gray:)
+            @gray = gray
+            freeze
+          end
+          def self.from_operands(stack)
+            new(gray: stack.pop_number)
+          end
+        end
+
+        class Setrgbcolor < Operator
+          register_as "setrgbcolor"
+          attr_reader :red, :green, :blue
+          def initialize(red:, green:, blue:)
+            @red = red
+            @green = green
+            @blue = blue
+            freeze
+          end
+          def self.from_operands(stack)
+            blue = stack.pop_number
+            green = stack.pop_number
+            red = stack.pop_number
+            new(red: red, green: green, blue: blue)
+          end
+        end
+
+        class Setcmykcolor < Operator
+          register_as "setcmykcolor"
+          attr_reader :cyan, :magenta, :yellow, :key
+          def initialize(cyan:, magenta:, yellow:, key:)
+            @cyan = cyan
+            @magenta = magenta
+            @yellow = yellow
+            @key = key
+            freeze
+          end
+          def self.from_operands(stack)
+            key = stack.pop_number
+            yellow = stack.pop_number
+            magenta = stack.pop_number
+            cyan = stack.pop_number
+            new(cyan: cyan, magenta: magenta, yellow: yellow, key: key)
+          end
+        end
+
+        class Sethsbcolor < Operator
+          register_as "sethsbcolor"
+          attr_reader :hue, :saturation, :brightness
+          def initialize(hue:, saturation:, brightness:)
+            @hue = hue
+            @saturation = saturation
+            @brightness = brightness
+            freeze
+          end
+          def self.from_operands(stack)
+            brightness = stack.pop_number
+            saturation = stack.pop_number
+            hue = stack.pop_number
+            new(hue: hue, saturation: saturation, brightness: brightness)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/postsvg/model/operators/container.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Postsvg
+  module Model
+    module Operators
+      module Container
+        class Length < Operator
+          register_as "length", consumes: 1, produces: 1
+          attr_reader :operand
+          def initialize(operand:)
+            @operand = operand
+            freeze
+          end
+          def self.from_operands(stack)
+            new(operand: stack.pop)
+          end
+        end
+
+        class Get < Operator
+          register_as "get", consumes: 2, produces: 1
+          attr_reader :operand, :key
+          def initialize(operand:, key:)
+            @operand = operand
+            @key = key
+            freeze
+          end
+          def self.from_operands(stack)
+            key = stack.pop
+            coll = stack.pop
+            new(operand: coll, key: key)
+          end
+        end
+
+        class Put < Operator
+          register_as "put", consumes: 3, produces: 0
+          attr_reader :operand, :key, :value
+          def initialize(operand:, key:, value:)
+            @operand = operand
+            @key = key
+            @value = value
+            freeze
+          end
+          def self.from_operands(stack)
+            value = stack.pop
+            key = stack.pop
+            coll = stack.pop
+            new(operand: coll, key: key, value: value)
+          end
+        end
+
+        class Getinterval < Operator
+          register_as "getinterval", consumes: 3, produces: 1
+          attr_reader :operand, :start, :count
+          def initialize(operand:, start:, count:)
+            @operand = operand
+            @start = start
+            @count = count
+            freeze
+          end
+          def self.from_operands(stack)
+            count = stack.pop_number.to_i
+            start = stack.pop_number.to_i
+            coll = stack.pop
+            new(operand: coll, start: start, count: count)
+          end
+        end
+
+        class Putinterval < Operator
+          register_as "putinterval", consumes: 3, produces: 0
+          attr_reader :operand, :start, :source
+          def initialize(operand:, start:, source:)
+            @operand = operand
+            @start = start
+            @source = source
+            freeze
+          end
+          def self.from_operands(stack)
+            source = stack.pop
+            start = stack.pop_number.to_i
+            coll = stack.pop
+            new(operand: coll, start: start, source: source)
+          end
+        end
+
+        class Forall < Operator
+          register_as "forall", consumes: 2, produces: 0
+          attr_reader :collection, :body
+          def initialize(collection:, body:)
+            @collection = collection
+            @body = body
+            freeze
+          end
+          def self.from_operands(stack)
+            body = stack.pop
+            coll = stack.pop
+            new(collection: coll, body: body)
+          end
+        end
+
+        class Astore < Operator
+          register_as "astore", consumes: 1, produces: 1
+          attr_reader :array, :length
+          def initialize(array:, length:)
+            @array = array
+            @length = length
+            freeze
+          end
+          def self.from_operands(stack)
+            arr = stack.pop
+            length = stack.pop_number.to_i
+            new(array: arr, length: length)
+          end
+        end
+
+        class Search < Operator
+          register_as "search", consumes: 2, produces: 1
+          attr_reader :target, :pattern
+          def initialize(target:, pattern:)
+            @target = target
+            @pattern = pattern
+            freeze
+          end
+          def self.from_operands(stack)
+            pattern = stack.pop
+            target = stack.pop
+            new(target: target, pattern: pattern)
+          end
+        end
+
+        class Anchorsearch < Operator
+          register_as "anchorsearch", consumes: 2, produces: 1
+          attr_reader :target, :pattern
+          def initialize(target:, pattern:)
+            @target = target
+            @pattern = pattern
+            freeze
+          end
+          def self.from_operands(stack)
+            pattern = stack.pop
+            target = stack.pop
+            new(target: target, pattern: pattern)
+          end
+        end
+
+        class Token < Operator
+          register_as "token", consumes: 1, produces: 1
+          attr_reader :target
+          def initialize(target:)
+            @target = target
+            freeze
+          end
+          def self.from_operands(stack)
+            new(target: stack.pop)
+          end
+        end
+
+        class String < Operator
+          register_as "string", consumes: 1, produces: 1
+          attr_reader :count
+          def initialize(count:)
+            @count = count
+            freeze
+          end
+          def self.from_operands(stack)
+            new(count: stack.pop_number.to_i)
+          end
+        end
+
+        class Cvs < Operator
+          register_as "cvs", consumes: 2, produces: 1
+          attr_reader :value, :target
+          def initialize(value:, target:)
+            @value = value
+            @target = target
+            freeze
+          end
+          def self.from_operands(stack)
+            target = stack.pop
+            value = stack.pop
+            new(value: value, target: target)
+          end
+        end
+      end
+    end
+  end
+end