grongigo 1.0.0

data/lib/grongigo/jp2grg.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Grongigo
+  # Utility: Convert Japanese to Grongigo
+  class Jp2Grg
+    CONVERSION_TABLE = {
+      # Seion (unvoiced)
+      'あ' => 'ガ', 'い' => 'ギ', 'う' => 'グ', 'え' => 'ゲ', 'お' => 'ゴ',
+      'か' => 'バ', 'き' => 'ビ', 'く' => 'ブ', 'け' => 'ベ', 'こ' => 'ボ',
+      'さ' => 'ガ', 'し' => 'ギ', 'す' => 'グ', 'せ' => 'ゲ', 'そ' => 'ゴ',
+      'た' => 'ダ', 'ち' => 'ヂ', 'つ' => 'ヅ', 'て' => 'デ', 'と' => 'ド',
+      'な' => 'バ', 'に' => 'ビ', 'ぬ' => 'ブ', 'ね' => 'ベ', 'の' => 'ボ',
+      'は' => 'ザ', 'ひ' => 'ジ', 'ふ' => 'ズ', 'へ' => 'ゼ', 'ほ' => 'ゾ',
+      'ま' => 'ラ', 'み' => 'リ', 'む' => 'ル', 'め' => 'レ', 'も' => 'ロ',
+      'や' => 'ジャ', 'ゆ' => 'ジュ', 'よ' => 'ジョ',
+      'ら' => 'サ', 'り' => 'シ', 'る' => 'ス', 'れ' => 'セ', 'ろ' => 'ソ',
+      'わ' => 'パ', 'を' => 'ゾ', 'ん' => 'ン',
+      # Dakuon (voiced)
+      'が' => 'ガ', 'ぎ' => 'ギ', 'ぐ' => 'グ', 'げ' => 'ゲ', 'ご' => 'ゴ',
+      'ざ' => 'ザ', 'じ' => 'ジ', 'ず' => 'ズ', 'ぜ' => 'ゼ', 'ぞ' => 'ゾ',
+      'だ' => 'ザ', 'ぢ' => 'ジ', 'づ' => 'ズ', 'で' => 'ゼ', 'ど' => 'ゾ',
+      'ば' => 'ダ', 'び' => 'ヂ', 'ぶ' => 'ヅ', 'べ' => 'デ', 'ぼ' => 'ド',
+      'ぱ' => 'マ', 'ぴ' => 'ミ', 'ぷ' => 'ム', 'ぺ' => 'メ', 'ぽ' => 'モ',
+      # Small letters
+      'ぁ' => 'ァ', 'ぃ' => 'ィ', 'ぅ' => 'ゥ', 'ぇ' => 'ェ', 'ぉ' => 'ォ',
+      'ゃ' => 'ャ', 'ゅ' => 'ュ', 'ょ' => 'ョ',
+      'っ' => 'ッ',
+      # Katakana (direct conversion)
+      'ア' => 'ガ', 'イ' => 'ギ', 'ウ' => 'グ', 'エ' => 'ゲ', 'オ' => 'ゴ',
+      'カ' => 'バ', 'キ' => 'ビ', 'ク' => 'ブ', 'ケ' => 'ベ', 'コ' => 'ボ',
+      'サ' => 'ガ', 'シ' => 'ギ', 'ス' => 'グ', 'セ' => 'ゲ', 'ソ' => 'ゴ',
+      'タ' => 'ダ', 'チ' => 'ヂ', 'ツ' => 'ヅ', 'テ' => 'デ', 'ト' => 'ド',
+      'ナ' => 'バ', 'ニ' => 'ビ', 'ヌ' => 'ブ', 'ネ' => 'ベ', 'ノ' => 'ボ',
+      'ハ' => 'ザ', 'ヒ' => 'ジ', 'フ' => 'ズ', 'ヘ' => 'ゼ', 'ホ' => 'ゾ',
+      'マ' => 'ラ', 'ミ' => 'リ', 'ム' => 'ル', 'メ' => 'レ', 'モ' => 'ロ',
+      'ヤ' => 'ジャ', 'ユ' => 'ジュ', 'ヨ' => 'ジョ',
+      'ラ' => 'サ', 'リ' => 'シ', 'ル' => 'ス', 'レ' => 'セ', 'ロ' => 'ソ',
+      'ワ' => 'パ', 'ヲ' => 'ゾ', 'ン' => 'ン',
+      'ガ' => 'ガ', 'ギ' => 'ギ', 'グ' => 'グ', 'ゲ' => 'ゲ', 'ゴ' => 'ゴ',
+      'ザ' => 'ザ', 'ジ' => 'ジ', 'ズ' => 'ズ', 'ゼ' => 'ゼ', 'ゾ' => 'ゾ',
+      'ダ' => 'ザ', 'ヂ' => 'ジ', 'ヅ' => 'ズ', 'デ' => 'ゼ', 'ド' => 'ゾ',
+      'バ' => 'ダ', 'ビ' => 'ヂ', 'ブ' => 'ヅ', 'ベ' => 'デ', 'ボ' => 'ド',
+      'パ' => 'マ', 'ピ' => 'ミ', 'プ' => 'ム', 'ペ' => 'メ', 'ポ' => 'モ'
+    }.freeze
+
+    def self.convert(text)
+      result = ''
+      chars = text.chars
+      i = 0
+
+      while i < chars.length
+        # Check if current position starts with a proper noun
+        matched_noun = nil
+        PROPER_NOUNS.each do |noun|
+          if text[i, noun.length] == noun
+            matched_noun = noun
+            break
+          end
+        end
+
+        if matched_noun
+          # Skip proper nouns (don't convert)
+          result += matched_noun
+          i += matched_noun.length
+        else
+          char = chars[i]
+          result += if CONVERSION_TABLE.key?(char)
+                      CONVERSION_TABLE[char]
+                    else
+                      char
+                    end
+          i += 1
+        end
+      end
+
+      result
+    end
+
+    # Convert decimal to base-9 Grongigo number
+    def self.num2grg(num)
+      return 'ゼゼソ' if num == 0
+
+      digits = %w[ゼゼソ パパン ドググ グシギ ズゴゴ ズガギ ギブグ ゲズン ゲギド]
+
+      # Convert to base-9
+      base9_digits = []
+      n = num
+      while n > 0
+        base9_digits.unshift(n % 9)
+        n /= 9
+      end
+
+      # Convert to Grongigo representation
+      return digits[base9_digits[0]] if base9_digits.length == 1
+
+      # Multiple digits case
+      result_parts = []
+      base9_digits.reverse.each_with_index do |digit, power|
+        next if digit == 0
+
+        if power == 0
+          result_parts.unshift(digits[digit])
+        else
+          # バギン (9) to the power × digit
+          multiplier = 'バギン' + ('グバギン' * (power - 1))
+          if digit == 1
+            result_parts.unshift(multiplier)
+          else
+            result_parts.unshift("#{multiplier}グ#{digits[digit]}")
+          end
+        end
+      end
+
+      result_parts.join('ド')
+    end
+  end
+end

data/lib/grongigo/lexer.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+require_relative 'token'
+
+module Grongigo
+  # Lexical analyzer
+  class Lexer
+    # Token types
+    TOKEN_TYPES = %i[
+      type_keyword
+      control_keyword
+      other_keyword
+      operator
+      number
+      identifier
+      string_literal
+      char_literal
+      open_brace
+      close_brace
+      open_paren
+      close_paren
+      open_bracket
+      close_bracket
+      comma
+      semicolon
+      colon
+      newline
+      eof
+    ].freeze
+
+    def initialize(source)
+      @source = source
+      @pos = 0
+      @line = 1
+      @column = 1
+      @tokens = []
+    end
+
+    def tokenize
+      @tokens = []
+
+      until eof?
+        skip_whitespace_and_comments
+        break if eof?
+
+        token = next_token
+        @tokens << token if token
+      end
+
+      @tokens << Token.new(:eof, nil, @line, @column)
+      @tokens
+    end
+
+    private
+
+    def eof?
+      @pos >= @source.length
+    end
+
+    def current_char
+      @source[@pos]
+    end
+
+    def peek(n = 1)
+      @source[@pos, n]
+    end
+
+    def advance(n = 1)
+      n.times do
+        if current_char == "\n"
+          @line += 1
+          @column = 1
+        else
+          @column += 1
+        end
+        @pos += 1
+      end
+    end
+
+    def skip_whitespace_and_comments
+      loop do
+        # Skip whitespace (except newlines)
+        advance while !eof? && current_char =~ /[ \t\r]/
+
+        # Newline
+        if !eof? && current_char == "\n"
+          advance
+          next
+        end
+
+        # Comment: ゴレン to end of line (custom definition for comments)
+        # Simple line comment starting with "ゴゴ" (equivalent to //)
+        if peek(2) == 'ゴゴ'
+          advance(2)
+          advance until eof? || current_char == "\n"
+          next
+        end
+
+        # Block comment (equivalent to /* */): "ゴビ" to "ビゴ"
+        if peek(2) == 'ゴビ'
+          advance(2)
+          until eof?
+            if peek(2) == 'ビゴ'
+              advance(2)
+              break
+            end
+            advance
+          end
+          next
+        end
+
+        break
+      end
+    end
+
+    def next_token
+      start_line = @line
+      start_column = @column
+
+      # String literal 「」
+      return scan_string_literal(start_line, start_column) if current_char == '「'
+
+      # Character literal 『』
+      return scan_char_literal(start_line, start_column) if current_char == '『'
+
+      # Brackets and delimiters
+      case current_char
+      when '（', '('
+        advance
+        return Token.new(:open_paren, '(', start_line, start_column)
+      when '）', ')'
+        advance
+        return Token.new(:close_paren, ')', start_line, start_column)
+      when '［', '['
+        advance
+        return Token.new(:open_bracket, '[', start_line, start_column)
+      when '］', ']'
+        advance
+        return Token.new(:close_bracket, ']', start_line, start_column)
+      when '、', ','
+        advance
+        return Token.new(:comma, ',', start_line, start_column)
+      when '。'
+        advance
+        return Token.new(:semicolon, ';', start_line, start_column)
+      when '：', ':'
+        advance
+        return Token.new(:colon, ':', start_line, start_column)
+      end
+
+      # Katakana-based identifier/keyword/number
+      return scan_katakana_word(start_line, start_column) if current_char =~ /\p{Katakana}/
+
+      # ASCII characters (allowed as variable names)
+      return scan_ascii_identifier(start_line, start_column) if current_char =~ /[a-zA-Z_]/
+
+      # Digits (decimal literals allowed, converted to base-9 later)
+      return scan_decimal_number(start_line, start_column) if current_char =~ /[0-9]/
+
+      # Unknown character
+      char = current_char
+      advance
+      Token.new(:unknown, char, start_line, start_column)
+    end
+
+    def scan_string_literal(start_line, start_column)
+      advance # Skip opening 「
+      value = ''
+      until eof? || current_char == '」'
+        value += current_char
+        advance
+      end
+      advance if current_char == '」' # Skip closing 」
+      Token.new(:string_literal, value, start_line, start_column)
+    end
+
+    def scan_char_literal(start_line, start_column)
+      advance # Skip opening 『
+      value = ''
+      until eof? || current_char == '』'
+        value += current_char
+        advance
+      end
+      advance if current_char == '』' # Skip closing 』
+      Token.new(:char_literal, value, start_line, start_column)
+    end
+
+    def scan_katakana_word(start_line, start_column)
+      word = ''
+      while !eof? && current_char =~ /[\p{Katakana}ー]/
+        word += current_char
+        advance
+      end
+
+      # Classify as keyword, operator, or number
+      token_type, token_value = classify_katakana_word(word)
+      Token.new(token_type, token_value, start_line, start_column)
+    end
+
+    def classify_katakana_word(word)
+      # Block delimiters
+      return [:open_brace, '{'] if word == 'ザジレ'
+      return [:close_brace, '}'] if word == 'ゴパシ'
+
+      # Type keywords
+      return [:type_keyword, TYPE_KEYWORDS[word]] if TYPE_KEYWORDS.key?(word)
+
+      # Control keywords
+      return [:control_keyword, CONTROL_KEYWORDS[word]] if CONTROL_KEYWORDS.key?(word)
+
+      # Other keywords
+      if OTHER_KEYWORDS.key?(word)
+        value = OTHER_KEYWORDS[word]
+        return [:other_keyword, value.empty? ? word : value]
+      end
+
+      # Operators
+      return [:operator, OPERATORS[word]] if OPERATORS.key?(word)
+
+      # Try to parse as number
+      number = try_parse_number(word)
+      return [:number, number] if number
+
+      # Identifier (variable name, etc.)
+      [:identifier, word]
+    end
+
+    def try_parse_number(word)
+      # Single digit
+      return DIGITS[word] if DIGITS.key?(word)
+
+      # Parse compound number (e.g., バギンドパパン = 9 + 1 = 10)
+      parse_compound_number(word)
+    end
+
+    def parse_compound_number(word)
+      return nil if word.empty?
+
+      # Tokenize the expression
+      tokens = tokenize_number_expression(word)
+      return nil if tokens.empty?
+
+      # Evaluate the expression
+      evaluate_number_expression(tokens)
+    rescue StandardError
+      nil
+    end
+
+    def tokenize_number_expression(word)
+      tokens = []
+      remaining = word
+
+      until remaining.empty?
+        matched = false
+
+        # Check digits (longest first)
+        DIGITS.keys.sort_by { |k| -k.length }.each do |digit_word|
+          next unless remaining.start_with?(digit_word)
+
+          tokens << [:digit, DIGITS[digit_word]]
+          remaining = remaining[digit_word.length..]
+          matched = true
+          break
+        end
+        next if matched
+
+        # Check operators
+        if remaining.start_with?('ド')
+          tokens << [:add, nil]
+          remaining = remaining[1..]
+          matched = true
+        elsif remaining.start_with?('グ')
+          tokens << [:multiply, nil]
+          remaining = remaining[1..]
+          matched = true
+        end
+
+        break unless matched
+      end
+
+      return [] unless remaining.empty?
+
+      tokens
+    end
+
+    def evaluate_number_expression(tokens)
+      return nil if tokens.empty?
+
+      # Process multiplication first by grouping
+      # Example: バギングバギンドパパン = (9*9) + 1 = 82
+
+      result = 0
+      current_product = nil
+
+      i = 0
+      while i < tokens.length
+        token = tokens[i]
+
+        case token[0]
+        when :digit
+          # Error if digit appears without preceding operator
+          return nil unless current_product.nil?
+
+          current_product = token[1]
+        when :multiply
+          # Multiply with next digit
+          i += 1
+          return nil if i >= tokens.length || tokens[i][0] != :digit
+
+          current_product = (current_product || 1) * tokens[i][1]
+        when :add
+          # Add current product to result and reset
+          result += current_product if current_product
+          current_product = nil
+        end
+
+        i += 1
+      end
+
+      result += current_product if current_product
+      result
+    end
+
+    def scan_ascii_identifier(start_line, start_column)
+      word = ''
+      while !eof? && current_char =~ /[a-zA-Z0-9_]/
+        word += current_char
+        advance
+      end
+      Token.new(:identifier, word, start_line, start_column)
+    end
+
+    def scan_decimal_number(start_line, start_column)
+      word = ''
+      while !eof? && current_char =~ /[0-9.]/
+        word += current_char
+        advance
+      end
+
+      # Determine if integer or floating point
+      if word.include?('.')
+        Token.new(:number, word.to_f, start_line, start_column)
+      else
+        Token.new(:number, word.to_i, start_line, start_column)
+      end
+    end
+  end
+end

data/lib/grongigo/parse_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Grongigo
+  # Parse error
+  class ParseError < StandardError
+    attr_reader :token
+
+    def initialize(message, token = nil)
+      super(message)
+      @token = token
+    end
+  end
+end