img_to_script 1.0.0

data/lib/img_to_script/languages/mk90_basic/formatters/minificator.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Languages
+    module MK90Basic
+      module Formatters
+        #
+        # The aim of the minificator is to make the output as compact as
+        # possible, and so to save space at the MPO-10 cart.
+        #
+        # The minificator:
+        #   1. doesn't put spaces (as MK90's BASIC lexer ignores them);
+        #   2. adds as many characters to a line as possible.
+        #      This minimizes the number of CR+LF sequences.
+        #
+        class Minificator < Formatter
+          SEP_BETWEEN_STATEMENTS = ":"
+
+          private
+
+          #
+          # Append a token to the BASIC script.
+          #
+          def _append_token(token)
+            @token = token
+            @placeholders_idx = _get_placeholders_idx
+
+            _format_token_arguments
+
+            if @token.sliceable
+              _process_sliceable_token
+            else
+              _process_non_sliceable_token
+            end
+          end
+
+          #
+          # Process a token with a statement that can be splitted and
+          # continued on a next line.
+          #
+          def _process_sliceable_token
+            @current_arg_idx = 0
+
+            _append_arg until @current_arg_idx == @args.length
+          end
+
+          #
+          # Append an argument of the sliceable statement.
+          #
+          def _append_arg
+            @current_arg = @args[@current_arg_idx].to_s
+
+            if @current_arg_idx.zero?
+              # The first argument should be handled differently (since a
+              # keyword should be prepended first).
+              _append_arg_with_keyword
+            else
+              # The rest arguments are processed in a batch.
+              _append_rest_sliceable_args
+            end
+
+            @current_arg_idx += 1
+          end
+
+          #
+          # Append the keyword of a sliceable statement, when attach an
+          # argument to it.
+          #
+          # There are two situations when this happens:
+          # 1. the argument is the first in the arguments array;
+          # 2. the statement was splitted and should be continued on a new line.
+          #
+          def _append_arg_with_keyword
+            statement = "#{@token.keyword}#{@current_arg}"
+
+            if @token.require_nl
+              # Statement explicitly demands to be on a new line
+              _append_to_new_line(statement)
+              return
+            end
+
+            if _calc_sliceable_statement_keyword_length <= @max_chars_per_line
+              # There is enough space in the current BASIC line to add a new keyword + the next arg. pair.
+              _append_to_current_line(statement)
+            else
+              # There is not enough space in the current BASIC line, create a new one.
+              _append_to_new_line(statement)
+            end
+          end
+
+          def _append_rest_sliceable_args
+            if _calc_current_line_plus_argument_length <= @max_chars_per_line
+              # There is enough space in the current BASIC line to add another argument.
+              _append_new_argument_to_current_line
+            else
+              # There is not enough space in the current BASIC line, create a new one.
+              _append_arg_with_keyword
+            end
+          end
+
+          #
+          # Append current argument of the sliceable statement to a current line.
+          #
+          def _append_new_argument_to_current_line
+            @script[-1] += @token.separator + @current_arg.to_s
+          end
+
+          #
+          # Length of a current line with a current argument of the sliceable
+          # statement.
+          #
+          # @return [Integer]
+          #
+          def _calc_current_line_plus_argument_length
+            _get_current_line_content.length +
+              @current_arg.length +
+              @token.separator.length
+          end
+
+          #
+          # Process a token with a statement that cannot be splitted, i.e. it
+          # should be lined up within a single BASIC line.
+          #
+          def _process_non_sliceable_token
+            _evaluate_placeholders
+
+            if @token.require_nl
+              # Statement explicitly demands to be on a new line.
+              _append_to_new_line(_non_sliceable_statement)
+            else
+              # Statement potentially can be added to a current line.
+              _try_to_append_non_sliceble_to_current_line
+            end
+          end
+
+          #
+          # Try to append a non-sliceable statement to a current line.
+          #
+          # There are situations when it can't be done:
+          # 1. current line is empty (that means it is not numbered yet).
+          # 2. there's no enough space in the current line to append the
+          # statement.
+          #
+          def _try_to_append_non_sliceble_to_current_line
+            if _get_current_line_content.empty?
+              _append_to_new_line(_non_sliceable_statement)
+              return
+            end
+
+            if _calc_non_sliceable_statement_length <= @max_chars_per_line
+              _append_to_current_line(_non_sliceable_statement)
+            else
+              _append_to_new_line(_non_sliceable_statement)
+            end
+          end
+
+          #
+          # Return current BASIC line, i.e. the last element of the @script
+          # array.
+          #
+          # @return [String]
+          #
+          def _get_current_line_content
+            @script[-1] || ""
+          end
+
+          #
+          # Return a formatted non-sliceable statement.
+          #
+          # @return [String]
+          #
+          def _non_sliceable_statement
+            @token.keyword + @args.join(@token.separator)
+          end
+
+          def _update_line_num
+            @n_line += @line_step
+
+            # Since line number has been changed, it is required to
+            # re-evaluate placeholders with the updated value.
+            _evaluate_placeholders
+          end
+
+          #
+          # Append statement to the current BASIC line.
+          #
+          # @param [String] statement
+          #   Statement to append in a String formatted form, e.g.: "ABS(X+L)"
+          #
+          def _append_to_current_line(statement)
+            @script[-1] += "#{SEP_BETWEEN_STATEMENTS}#{statement}"
+          end
+
+          #
+          # Append statement to a new BASIC line.
+          #
+          # @param [String] statement
+          #   Statement to append in a String formatted form, e.g.: "ABS(X+L)"
+          #
+          def _append_to_new_line(statement)
+            # Since a new line is about to be created, the line number should
+            # be updated first.
+            _update_line_num
+
+            new_line = "#{_select_line_label}#{statement}"
+            @script << new_line
+          end
+
+          #
+          # @return [String]
+          #
+          def _select_line_label
+            @number_lines ? @n_line.to_s : ""
+          end
+
+          #
+          # Full length of a non-sliceable statement.
+          #
+          # @return [Integer]
+          #
+          def _calc_non_sliceable_statement_length
+            _get_current_line_content.length +
+              _non_sliceable_statement.length +
+              SEP_BETWEEN_STATEMENTS.length
+          end
+
+          #
+          # Keyword + first argument length.
+          #
+          # @return [Integer]
+          #
+          def _calc_sliceable_statement_keyword_length
+            _get_current_line_content.length +
+              @token.keyword.length +
+              @current_arg.length +
+              SEP_BETWEEN_STATEMENTS.length
+          end
+
+          #
+          # Evaluate current line number placeholders in the token's arguments.
+          #
+          def _evaluate_placeholders
+            @placeholders_idx.each do |i|
+              e = @token.args[i]
+              @args[i] = @n_line + e.shift * @line_step
+            end
+          end
+
+          #
+          # For an argument what is a token (i.e. a nested token): pass the
+          # argument to a new instance of the minificator, and append the
+          # argument in a formatted form (a String).
+          #
+          # For the arguments of other types: append as is.
+          #
+          def _format_token_arguments
+            @args = []
+            @token.args.each do |arg|
+              if arg.is_a?(MK90Basic::MK90BasicToken)
+                @args.append(_format_nested_token(arg))
+              else
+                @args.append(arg)
+              end
+            end
+          end
+
+          #
+          # Format a nested token.
+          #
+          # @return [String]
+          #
+          def _format_nested_token(token)
+            arr = _minificator.format(
+              Array(token)
+            )
+
+            case arr.length
+            when 0
+              # @todo: warn: minificator returned an empty arr!
+              ""
+            when 1
+              # ok!
+              arr.first
+            else
+              # @todo: warn: statement doesn't fit to a single line!
+              arr.first
+            end
+          end
+
+          #
+          # Return a minificator instance to format a nested token.
+          #
+          # @return [Minificator]
+          #   A new Minificator instance.
+          #
+          def _minificator
+            Minificator.new.configure do |config|
+              config.number_lines = false
+            end
+          end
+
+          #
+          # Return array of indexes of the placeholders.
+          #
+          # @return [Array<Integer>]
+          #
+          def _get_placeholders_idx
+            @token.args.each_index.select do |i|
+              @token.args[i].is_a?(CurrentLinePlaceholder)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/languages/mk90_basic/formatters/sliceable_tokens_mixin.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Languages
+    module MK90Basic
+      module Formatters
+        #
+        # Methods related to the sliceable statements.
+        #
+        module SliceableTokensMixin
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/languages/mk90_basic/formatters.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Languages
+    module MK90Basic
+      #
+      # Namespace for the MK90 BASIC formatters.
+      #
+      module Formatters
+      end
+    end
+  end
+end

data/lib/img_to_script/languages/mk90_basic/mk90_basic_token.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Languages
+    module MK90Basic
+      #
+      # Designed to be used with the MK90 BASIC translator & formatter.
+      #
+      class MK90BasicToken < LanguageToken
+        attr_accessor :keyword, :args, :separator, :require_nl, :sliceable
+
+        #
+        # Initialize a new BASIC token.
+        #
+        # @param [String] keyword
+        #   Statement keyword (e.g.: "PRINT", "FOR", "CLS").
+        #
+        # @param [Array<Numeric, String>] args
+        #   Statement arguments (e.g.: %i[10 20 30 40]).
+        #
+        # @param [String] separator
+        #   Separator between arguments. Commonly a comma or
+        #   an 'empty' string (no separation between arguments).
+        #
+        # @param [Boolean] require_nl
+        #   Defines if the statement should be placed on a new line.
+        #
+        # @param [Boolean] sliceable
+        #   Defines if the statement allows to 'slice' its arguments,
+        #   to move some of them on a new line if the expression doesn't
+        #   fit into a current line. Examples:
+        #
+        #  sliceable = true:
+        #                              | <- max. characters per line limit
+        #   10 DATA 1, [omitted...], 8, 9, 10, 11
+        #      =>                      |
+        #   10 DATA 1, [omitted...], 8
+        #   20 DATA 9, 10, 11          |
+        #
+        #  sliceable = false:
+        #                              |
+        #   10 [omitted...]:PRINT"HELLO, WORLD!"
+        #      =>                      |
+        #   10 [omitted...]            |
+        #   20 PRINT"HELLO, WORLD!"    |
+        #
+        def initialize(keyword:, args:, separator:, require_nl:, sliceable:)
+          @keyword = keyword
+          @args = args
+          @separator = separator
+          @require_nl = require_nl
+          @sliceable = sliceable
+
+          super()
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/languages/mk90_basic/translators/mixin.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Languages
+    module MK90Basic
+      module Translators
+        # rubocop:disable Metrics/ModuleLength
+
+        #
+        # Shared by both MK90 BAIC v.1.0 & v.2.0.
+        #
+        module Mixin
+          def _abs_func(token)
+            _function(token, "ABS")
+          end
+
+          def _clear_screen(token)
+            _single_keyword(token, "CLS")
+          end
+
+          def _program_end(token)
+            _single_keyword(token, "END")
+          end
+
+          def _data_store(token)
+            MK90BasicToken.new(
+              keyword: "DATA",
+              args: token.data,
+              separator: ",",
+              require_nl: token.require_nl,
+              sliceable: true
+            )
+          end
+
+          def _data_read(token)
+            MK90BasicToken.new(
+              keyword: "READ",
+              args: _translate_arguments(token.var_list),
+              separator: ",",
+              require_nl: token.require_nl,
+              sliceable: false
+            )
+          end
+
+          def _draw_line_by_abs_coords(token)
+            MK90BasicToken.new(
+              keyword: "DRAWD",
+              args: _translate_arguments([
+                                           token.x0,
+                                           token.y0,
+                                           token.x1,
+                                           token.y1
+                                         ]),
+              separator: ",",
+              require_nl: token.require_nl,
+              sliceable: false
+            )
+          end
+
+          def _draw_pixel_by_abs_coords(token)
+            MK90BasicToken.new(
+              keyword: "DRAWH",
+              args: _translate_arguments([
+                                           token.x,
+                                           token.y
+                                         ]),
+              separator: ",",
+              require_nl: token.require_nl,
+              sliceable: false
+            )
+          end
+
+          def _draw_chunk_by_hex_value(token)
+            MK90BasicToken.new(
+              keyword: "DRAWM",
+              args: token.hex_values,
+              separator: "",
+              require_nl: token.require_nl,
+              sliceable: true
+            )
+          end
+
+          def _math_add(token)
+            _math_operation(token, "+")
+          end
+
+          def _math_greater_than(token)
+            _math_operation(token, ">")
+          end
+
+          def _math_sub(token)
+            _math_operation(token, "-")
+          end
+
+          def _math_mult(token)
+            _math_operation(token, "*")
+          end
+
+          def _move_point_to_abs_coords(token)
+            MK90BasicToken.new(
+              keyword: "DRAWO",
+              args: _translate_arguments([
+                                           token.x,
+                                           token.y
+                                         ]),
+              separator: ",",
+              require_nl: token.require_nl,
+              sliceable: false
+            )
+          end
+
+          def _go_to(token)
+            MK90BasicToken.new(
+              keyword: "GOTO",
+              args: _translate_arguments([
+                                           token.line
+                                         ]),
+              separator: "",
+              require_nl: token.require_nl,
+              sliceable: false
+            )
+          end
+
+          def _loop_begin(token)
+            MK90BasicToken.new(
+              keyword: "FOR",
+              args: _translate_arguments([
+                                           token.var_name,
+                                           "=",
+                                           token.start_value,
+                                           "TO",
+                                           token.end_value
+                                         ]),
+              separator: "",
+              require_nl: token.require_nl,
+              sliceable: false
+            )
+          end
+
+          def _sign_func(token)
+            _function(token, "SGN")
+          end
+
+          def _parentheses(token)
+            _function(token, "")
+          end
+
+          def _loop_end(token)
+            MK90BasicToken.new(
+              keyword: "NEXT",
+              args: _translate_arguments(
+                [
+                  token.var_name
+                ]
+              ),
+              separator: "",
+              require_nl: token.require_nl,
+              sliceable: false
+            )
+          end
+
+          def _if_condition(token)
+            MK90BasicToken.new(
+              keyword: "IF",
+              args: _translate_arguments([
+                                           token.expression,
+                                           "THEN",
+                                           token.consequent
+                                         ]),
+              separator: "",
+              require_nl: token.require_nl,
+              sliceable: false
+            )
+          end
+
+          def _wait(token)
+            MK90BasicToken.new(
+              keyword: "WAIT",
+              args: _translate_arguments([
+                                           token.time
+                                         ]),
+              separator: "",
+              require_nl: token.require_nl,
+              sliceable: false
+            )
+          end
+
+          def _remark(token)
+            MK90BasicToken.new(
+              keyword: "REM",
+              args: [
+                token.text
+              ],
+              separator: "",
+              require_nl: token.require_nl,
+              sliceable: false
+            )
+          end
+        end
+
+        # rubocop:enable Metrics/ModuleLength
+      end
+    end
+  end
+end

data/lib/img_to_script/languages/mk90_basic/translators/mk90_basic_10.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Languages
+    module MK90Basic
+      module Translators
+        #
+        # Translates abstract tokens to the MK90 BASIC v.1.0 statements.
+        #
+        class MK90Basic10 < Translator
+          private
+
+          # MK90 BASIC v1.0 - requires the "LET" keyword
+          def _assign_value(token)
+            MK90BasicToken.new(
+              keyword: "LET",
+              args: _translate_arguments([token.left, "=", token.right]),
+              separator: "",
+              require_nl: token.require_nl,
+              sliceable: false
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/languages/mk90_basic/translators/mk90_basic_20.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Languages
+    module MK90Basic
+      module Translators
+        #
+        # Translates abstract tokens to the MK90 BASIC v.2.0 statements.
+        #
+        class MK90Basic20 < Translator
+          private
+
+          # MK90 BASIC v2.0 - doesn't require the "LET" keyword
+          def _assign_value(token)
+            MK90BasicToken.new(
+              keyword: "",
+              args: _translate_arguments([token.left, "=", token.right]),
+              separator: "",
+              require_nl: token.require_nl,
+              sliceable: false
+            )
+          end
+        end
+      end
+    end
+  end
+end