grongigo 1.0.0

data/lib/grongigo/codegen.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+require_relative 'parser'
+
+module Grongigo
+  # C code generator
+  class CodeGenerator
+    def initialize
+      @indent_level = 0
+      @output = []
+    end
+
+    def generate(ast)
+      @output = []
+
+      # Standard headers
+      emit '#include <stdio.h>'
+      emit '#include <stdlib.h>'
+      emit '#include <string.h>'
+      emit ''
+
+      # Generate each declaration
+      ast.declarations.each do |decl|
+        generate_declaration(decl)
+        emit ''
+      end
+
+      @output.join("\n")
+    end
+
+    private
+
+    def emit(code)
+      @output << ('    ' * @indent_level + code)
+    end
+
+    def indent
+      @indent_level += 1
+    end
+
+    def dedent
+      @indent_level -= 1
+    end
+
+    def generate_declaration(node)
+      case node
+      when AST::FunctionDecl
+        generate_function(node)
+      when AST::VarDecl
+        generate_var_decl(node)
+      else
+        generate_statement(node)
+      end
+    end
+
+    def generate_function(node)
+      params = node.params.map { |p| "#{p.type} #{sanitize_name(p.name)}" }.join(', ')
+      params = 'void' if params.empty? && node.name == 'main'
+
+      emit "#{node.return_type} #{sanitize_name(node.name)}(#{params})"
+      generate_block(node.body)
+    end
+
+    def generate_block(node)
+      emit '{'
+      indent
+      node.statements.each { |stmt| generate_statement(stmt) }
+      dedent
+      emit '}'
+    end
+
+    def generate_statement(node)
+      case node
+      when AST::BlockStmt
+        generate_block(node)
+      when AST::VarDecl
+        generate_var_decl(node)
+      when AST::IfStmt
+        generate_if(node)
+      when AST::WhileStmt
+        generate_while(node)
+      when AST::ForStmt
+        generate_for(node)
+      when AST::SwitchStmt
+        generate_switch(node)
+      when AST::ReturnStmt
+        generate_return(node)
+      when AST::BreakStmt
+        emit 'break;'
+      when AST::ContinueStmt
+        emit 'continue;'
+      when AST::ExprStmt
+        emit "#{generate_expr(node.expression)};"
+      else
+        raise "Unknown statement type: #{node.class}"
+      end
+    end
+
+    def generate_var_decl(node)
+      name = sanitize_name(node.name)
+      type = node.type
+
+      # Handle array types
+      if type.end_with?('[]')
+        base_type = type[0..-3]
+        if node.initializer
+          emit "#{base_type} #{name}[] = #{generate_expr(node.initializer)};"
+        else
+          emit "#{base_type} #{name}[];"
+        end
+      elsif node.initializer
+        emit "#{type} #{name} = #{generate_expr(node.initializer)};"
+      else
+        emit "#{type} #{name};"
+      end
+    end
+
+    def generate_if(node)
+      emit "if (#{generate_expr(node.condition)})"
+      if node.then_branch.is_a?(AST::BlockStmt)
+        generate_block(node.then_branch)
+      else
+        indent
+        generate_statement(node.then_branch)
+        dedent
+      end
+
+      return unless node.else_branch
+
+      if node.else_branch.is_a?(AST::IfStmt)
+        @output[-1] = @output[-1] # Keep previous closing brace
+        # Put else if on same line
+        @output << ('    ' * @indent_level + 'else')
+        generate_if_as_else(node.else_branch)
+      elsif node.else_branch.is_a?(AST::BlockStmt)
+        emit 'else'
+        generate_block(node.else_branch)
+      else
+        emit 'else'
+        indent
+        generate_statement(node.else_branch)
+        dedent
+      end
+    end
+
+    def generate_if_as_else(node)
+      @output[-1] += " if (#{generate_expr(node.condition)})"
+      if node.then_branch.is_a?(AST::BlockStmt)
+        generate_block(node.then_branch)
+      else
+        indent
+        generate_statement(node.then_branch)
+        dedent
+      end
+
+      return unless node.else_branch
+
+      if node.else_branch.is_a?(AST::IfStmt)
+        @output << ('    ' * @indent_level + 'else')
+        generate_if_as_else(node.else_branch)
+      elsif node.else_branch.is_a?(AST::BlockStmt)
+        emit 'else'
+        generate_block(node.else_branch)
+      else
+        emit 'else'
+        indent
+        generate_statement(node.else_branch)
+        dedent
+      end
+    end
+
+    def generate_while(node)
+      emit "while (#{generate_expr(node.condition)})"
+      if node.body.is_a?(AST::BlockStmt)
+        generate_block(node.body)
+      else
+        indent
+        generate_statement(node.body)
+        dedent
+      end
+    end
+
+    def generate_for(node)
+      init = node.init ? generate_for_init(node.init) : ''
+      cond = node.condition ? generate_expr(node.condition) : ''
+      update = node.update ? generate_expr(node.update) : ''
+
+      emit "for (#{init}; #{cond}; #{update})"
+      if node.body.is_a?(AST::BlockStmt)
+        generate_block(node.body)
+      else
+        indent
+        generate_statement(node.body)
+        dedent
+      end
+    end
+
+    def generate_for_init(node)
+      case node
+      when AST::VarDecl
+        name = sanitize_name(node.name)
+        if node.initializer
+          "#{node.type} #{name} = #{generate_expr(node.initializer)}"
+        else
+          "#{node.type} #{name}"
+        end
+      else
+        generate_expr(node)
+      end
+    end
+
+    def generate_switch(node)
+      emit "switch (#{generate_expr(node.expression)})"
+      emit '{'
+      indent
+
+      node.cases.each do |c|
+        dedent
+        emit "case #{generate_expr(c.value)}:"
+        indent
+        c.statements.each { |stmt| generate_statement(stmt) }
+      end
+
+      if node.default_case
+        dedent
+        emit 'default:'
+        indent
+        node.default_case.each { |stmt| generate_statement(stmt) }
+      end
+
+      dedent
+      emit '}'
+    end
+
+    def generate_return(node)
+      if node.value
+        emit "return #{generate_expr(node.value)};"
+      else
+        emit 'return;'
+      end
+    end
+
+    def generate_expr(node)
+      case node
+      when AST::BinaryExpr
+        "(#{generate_expr(node.left)} #{node.operator} #{generate_expr(node.right)})"
+      when AST::UnaryExpr
+        if node.prefix
+          "#{node.operator}#{generate_expr(node.operand)}"
+        else
+          "#{generate_expr(node.operand)}#{node.operator}"
+        end
+      when AST::AssignExpr
+        "#{generate_expr(node.target)} = #{generate_expr(node.value)}"
+      when AST::CallExpr
+        args = node.arguments.map { |a| generate_expr(a) }.join(', ')
+        "#{generate_expr(node.callee)}(#{args})"
+      when AST::IndexExpr
+        "#{generate_expr(node.array)}[#{generate_expr(node.index)}]"
+      when AST::Identifier
+        sanitize_name(node.name)
+      when AST::NumberLiteral
+        node.value.to_s
+      when AST::StringLiteral
+        "\"#{escape_string(node.value)}\""
+      when AST::CharLiteral
+        "'#{escape_char(node.value)}'"
+      else
+        raise "Unknown expression type: #{node.class}"
+      end
+    end
+
+    def sanitize_name(name)
+      # Convert Grongigo variable names to valid C names
+      return name if name =~ /^[a-zA-Z_][a-zA-Z0-9_]*$/
+
+      # Special keywords
+      return name if %w[main printf scanf NULL].include?(name)
+
+      # Convert katakana to roman alphabets
+      katakana2roman(name)
+    end
+
+    def katakana2roman(text)
+      # Simple katakana to roman alphabet mapping
+      map = {
+        'ア' => 'a', 'イ' => 'i', 'ウ' => 'u', 'エ' => 'e', 'オ' => 'o',
+        'カ' => 'ka', 'キ' => 'ki', 'ク' => 'ku', 'ケ' => 'ke', 'コ' => 'ko',
+        'サ' => 'sa', 'シ' => 'si', 'ス' => 'su', 'セ' => 'se', 'ソ' => 'so',
+        'タ' => 'ta', 'チ' => 'ti', 'ツ' => 'tu', 'テ' => 'te', 'ト' => 'to',
+        'ナ' => 'na', 'ニ' => 'ni', 'ヌ' => 'nu', 'ネ' => 'ne', 'ノ' => 'no',
+        'ハ' => 'ha', 'ヒ' => 'hi', 'フ' => 'hu', 'ヘ' => 'he', 'ホ' => 'ho',
+        'マ' => 'ma', 'ミ' => 'mi', 'ム' => 'mu', 'メ' => 'me', 'モ' => 'mo',
+        'ヤ' => 'ya', 'ユ' => 'yu', 'ヨ' => 'yo',
+        'ラ' => 'ra', 'リ' => 'ri', 'ル' => 'ru', 'レ' => 're', 'ロ' => 'ro',
+        'ワ' => 'wa', 'ヲ' => 'wo', 'ン' => 'n',
+        'ガ' => 'ga', 'ギ' => 'gi', 'グ' => 'gu', 'ゲ' => 'ge', 'ゴ' => 'go',
+        'ザ' => 'za', 'ジ' => 'zi', 'ズ' => 'zu', 'ゼ' => 'ze', 'ゾ' => 'zo',
+        'ダ' => 'da', 'ヂ' => 'di', 'ヅ' => 'du', 'デ' => 'de', 'ド' => 'do',
+        'バ' => 'ba', 'ビ' => 'bi', 'ブ' => 'bu', 'ベ' => 'be', 'ボ' => 'bo',
+        'パ' => 'pa', 'ピ' => 'pi', 'プ' => 'pu', 'ペ' => 'pe', 'ポ' => 'po',
+        'ジャ' => 'ja', 'ジュ' => 'ju', 'ジョ' => 'jo',
+        'ー' => '_'
+      }
+
+      result = ''
+      i = 0
+      while i < text.length
+        # Check for 2-character combinations
+        if i + 1 < text.length && map.key?(text[i, 2])
+          result += map[text[i, 2]]
+          i += 2
+        elsif map.key?(text[i])
+          result += map[text[i]]
+          i += 1
+        else
+          # Convert unmappable characters to underscore
+          result += '_'
+          i += 1
+        end
+      end
+
+      # Ensure result doesn't start with a digit
+      result = "_#{result}" if result =~ /^[0-9]/
+      result = 'var' if result.empty?
+      result
+    end
+
+    def escape_string(str)
+      str.gsub('\\', '\\\\')
+         .gsub('"', '\\"')
+         .gsub("\n", '\\n')
+         .gsub("\t", '\\t')
+         .gsub("\r", '\\r')
+    end
+
+    def escape_char(str)
+      return '\\0' if str.empty?
+
+      char = str[0]
+      case char
+      when '\\'
+        '\\\\'
+      when "'"
+        "\\'"
+      when "\n"
+        '\\n'
+      when "\t"
+        '\\t'
+      when "\r"
+        '\\r'
+      else
+        char
+      end
+    end
+  end
+end

data/lib/grongigo/compiler.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative 'lexer'
+require_relative 'parser'
+require_relative 'codegen'
+
+module Grongigo
+  # Main compiler class
+  class Compiler
+    attr_reader :errors
+
+    def initialize(options = {})
+      @options = {
+        verbose: false,
+        output_tokens: false,
+        output_ast: false
+      }.merge(options)
+      @errors = []
+    end
+
+    def compile(source)
+      @errors = []
+
+      # Lexical analysis
+      log 'Starting lexical analysis...'
+      lexer = Lexer.new(source)
+      tokens = lexer.tokenize
+
+      if @options[:output_tokens]
+        puts '=== Tokens ==='
+        tokens.each { |t| puts t }
+        puts ''
+      end
+
+      # Parsing
+      log 'Starting parsing...'
+      parser = Parser.new(tokens)
+      ast = parser.parse
+
+      if @options[:output_ast]
+        puts '=== AST ==='
+        print_ast(ast)
+        puts ''
+      end
+
+      # Code generation
+      log 'Generating C code...'
+      generator = CodeGenerator.new
+      c_code = generator.generate(ast)
+
+      log 'Compilation successful!'
+      c_code
+    rescue ParseError => e
+      @errors << "Parse error: #{e.message}"
+      nil
+    rescue StandardError => e
+      @errors << "Error: #{e.message}"
+      @errors << e.backtrace.first(5).join("\n") if @options[:verbose]
+      nil
+    end
+
+    def compile_file(input_path, output_path = nil)
+      output_path ||= input_path.sub(/\.[^.]+$/, '.c')
+
+      source = File.read(input_path, encoding: 'UTF-8')
+      c_code = compile(source)
+
+      return false unless c_code
+
+      File.write(output_path, c_code, encoding: 'UTF-8')
+      log "Output written to: #{output_path}"
+      true
+    end
+
+    private
+
+    def log(message)
+      puts "[Grongigo] #{message}" if @options[:verbose]
+    end
+
+    def print_ast(node, indent = 0)
+      prefix = '  ' * indent
+      case node
+      when AST::Program
+        puts "#{prefix}Program"
+        node.declarations.each { |d| print_ast(d, indent + 1) }
+      when AST::FunctionDecl
+        puts "#{prefix}FunctionDecl: #{node.return_type} #{node.name}"
+        node.params.each { |p| print_ast(p, indent + 1) }
+        print_ast(node.body, indent + 1)
+      when AST::Parameter
+        puts "#{prefix}Parameter: #{node.type} #{node.name}"
+      when AST::VarDecl
+        puts "#{prefix}VarDecl: #{node.type} #{node.name}"
+        print_ast(node.initializer, indent + 1) if node.initializer
+      when AST::BlockStmt
+        puts "#{prefix}BlockStmt"
+        node.statements.each { |s| print_ast(s, indent + 1) }
+      when AST::IfStmt
+        puts "#{prefix}IfStmt"
+        print_ast(node.condition, indent + 1)
+        print_ast(node.then_branch, indent + 1)
+        print_ast(node.else_branch, indent + 1) if node.else_branch
+      when AST::WhileStmt
+        puts "#{prefix}WhileStmt"
+        print_ast(node.condition, indent + 1)
+        print_ast(node.body, indent + 1)
+      when AST::ForStmt
+        puts "#{prefix}ForStmt"
+        print_ast(node.init, indent + 1) if node.init
+        print_ast(node.condition, indent + 1) if node.condition
+        print_ast(node.update, indent + 1) if node.update
+        print_ast(node.body, indent + 1)
+      when AST::ReturnStmt
+        puts "#{prefix}ReturnStmt"
+        print_ast(node.value, indent + 1) if node.value
+      when AST::BreakStmt
+        puts "#{prefix}BreakStmt"
+      when AST::ContinueStmt
+        puts "#{prefix}ContinueStmt"
+      when AST::ExprStmt
+        puts "#{prefix}ExprStmt"
+        print_ast(node.expression, indent + 1)
+      when AST::BinaryExpr
+        puts "#{prefix}BinaryExpr: #{node.operator}"
+        print_ast(node.left, indent + 1)
+        print_ast(node.right, indent + 1)
+      when AST::UnaryExpr
+        puts "#{prefix}UnaryExpr: #{node.operator} (prefix=#{node.prefix})"
+        print_ast(node.operand, indent + 1)
+      when AST::AssignExpr
+        puts "#{prefix}AssignExpr"
+        print_ast(node.target, indent + 1)
+        print_ast(node.value, indent + 1)
+      when AST::CallExpr
+        puts "#{prefix}CallExpr"
+        print_ast(node.callee, indent + 1)
+        node.arguments.each { |a| print_ast(a, indent + 1) }
+      when AST::IndexExpr
+        puts "#{prefix}IndexExpr"
+        print_ast(node.array, indent + 1)
+        print_ast(node.index, indent + 1)
+      when AST::Identifier
+        puts "#{prefix}Identifier: #{node.name}"
+      when AST::NumberLiteral
+        puts "#{prefix}NumberLiteral: #{node.value}"
+      when AST::StringLiteral
+        puts "#{prefix}StringLiteral: #{node.value.inspect}"
+      when AST::CharLiteral
+        puts "#{prefix}CharLiteral: #{node.value.inspect}"
+      else
+        puts "#{prefix}Unknown: #{node.class}"
+      end
+    end
+  end
+end

data/lib/grongigo/constants.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Grongigo
+  # Grongigo numerals (base-9, English-based)
+  DIGITS = {
+    'ゼゼソ' => 0,  # zero
+    'パパン' => 1,  # one (wan)
+    'ドググ' => 2,  # two
+    'グシギ' => 3,  # three
+    'ズゴゴ' => 4,  # four
+    'ズガギ' => 5,  # five
+    'ギブグ' => 6,  # six
+    'ゲズン' => 7,  # seven
+    'ゲギド' => 8,  # eight
+    'バギン' => 9   # nine (10 in base-9)
+  }.freeze
+
+  # Numeric operators
+  NUMBER_OPS = {
+    'ド' => :add,      # addition
+    'グ' => :multiply  # multiplication
+  }.freeze
+
+  # Keywords (types)
+  TYPE_KEYWORDS = {
+    'ゲギグウ' => 'int',    # integer (seisuu)
+    'ロジ' => 'char',       # character (moji)
+    'ズゾウ' => 'float',    # floating point (fudou)
+    'ザダダス' => 'double', # double (fukufudou -> zadadas)
+    'バサ' => 'void',       # void (kara)
+    'バゴ' => 'long',       # long (naga)
+    'ジジバギ' => 'short',  # short (mijikai)
+    'ブゾウ' => 'unsigned'  # unsigned (mufugou)
+  }.freeze
+
+  # Keywords (control structures)
+  CONTROL_KEYWORDS = {
+    'ジョウベン' => 'if',       # if (jouken)
+    'ゾバ' => 'else',           # else (hoka)
+    'ガギザ' => 'while',        # while (aida)
+    'ブシバゲギ' => 'for',      # for (kurikaeshi)
+    'ロゾス' => 'return',       # return (modosu)
+    'ブゲス' => 'break',        # break (nukeru)
+    'ヅヅゲス' => 'continue',   # continue (tsuzukeru)
+    'ゲンダブ' => 'switch',     # switch (sentaku)
+    'ダガギ' => 'case',         # case (baai)
+    'ビデギ' => 'default',      # default (kitei)
+    'ジョウジ' => 'printf',     # printf (hyouji)
+    'ジュウソブ' => 'scanf'     # scanf (juuryoku -> juusobu)
+  }.freeze
+
+  # Keywords (other)
+  OTHER_KEYWORDS = {
+    'ボウゾウ' => 'struct',     # struct (kouzou)
+    'バダデギギ' => 'typedef',  # typedef (katatеigi)
+    'ゴゴビガ' => 'sizeof',     # sizeof (ookisa)
+    'ル' => 'NULL',             # NULL (mu)
+    'ギン' => '1',              # true (shin)
+    'ギ' => '0',                # false (gi) - need to distinguish from variable names
+    'ゴロ' => 'main',           # main (omo)
+    'パザ' => '',               # function definition marker (waza)
+    'ザジレ' => '{',            # block start (hajime)
+    'ゴパシ' => '}'             # block end (owari)
+  }.freeze
+
+  # Operators
+  OPERATORS = {
+    'ダグ' => '+',              # add (tasu)
+    'ジブ' => '-',              # subtract (hiku)
+    'バゲス' => '*',            # multiply (kakeru)
+    'パス' => '/',              # divide (waru)
+    'ガラシ' => '%',            # modulo (amari)
+    'ギセス' => '=',            # assign (ireru)
+    'ジドギギ' => '==',         # equal (hitoshii)
+    'ジドギグバギ' => '!=',     # not equal
+    'ギョウバシ' => '<',        # less than (shounari)
+    'ザギバシ' => '>',          # greater than (dainari)
+    'ギバ' => '<=',             # less or equal (ika)
+    'ギジョウ' => '>=',         # greater or equal (ijou)
+    'バヅ' => '&&',             # and (katsu)
+    'ラダパ' => '||',           # or (mataha)
+    'ジデギ' => '!',            # not (hitei)
+    'ガンド' => '&',            # bitwise and (ando)
+    'ゴゴ' => '|',              # bitwise or (oa -> goga)
+    'ダグダグ' => '++',         # increment (tasu tasu)
+    'ジブジブ' => '--'          # decrement (hiku hiku)
+  }.freeze
+
+  # Merge all keywords
+  ALL_KEYWORDS = TYPE_KEYWORDS
+                 .merge(CONTROL_KEYWORDS)
+                 .merge(OTHER_KEYWORDS)
+                 .freeze
+
+  # Proper nouns not converted in Grongigo
+  PROPER_NOUNS = %w[
+    クウガ
+    リント
+    ゲゲル
+    グロンギ
+    グセパ
+    バグンダダ
+    ゲリザギバスゲゲル
+    ザギバスゲゲル
+  ].freeze
+
+  # Japanese to Grongigo conversion table (for reference)
+  JAPANESE_TO_GRONGIGO = {
+    # Basic rows
+    'あ' => 'ガ', 'い' => 'ギ', 'う' => 'グ', 'え' => 'ゲ', 'お' => 'ゴ',
+    'か' => 'バ', 'き' => 'ビ', 'く' => 'ブ', 'け' => 'ベ', 'こ' => 'ボ',
+    'さ' => 'ガ', 'し' => 'ギ', 'す' => 'グ', 'せ' => 'ゲ', 'そ' => 'ゴ',
+    'た' => 'ダ', 'ち' => 'ヂ', 'つ' => 'ヅ', 'て' => 'デ', 'と' => 'ド',
+    'な' => 'バ', 'に' => 'ビ', 'ぬ' => 'ブ', 'ね' => 'ベ', 'の' => 'ボ',
+    'は' => 'ザ', 'ひ' => 'ジ', 'ふ' => 'ズ', 'へ' => 'ゼ', 'ほ' => 'ゾ',
+    'ま' => 'ラ', 'み' => 'リ', 'む' => 'ル', 'め' => 'レ', 'も' => 'ロ',
+    'や' => 'ジャ', 'ゆ' => 'ジュ', 'よ' => 'ジョ',
+    'ら' => 'サ', 'り' => 'シ', 'る' => 'ス', 'れ' => 'セ', 'ろ' => 'ソ',
+    'わ' => 'パ',
+    # Dakuon (voiced)
+    'が' => 'ガ', 'ぎ' => 'ギ', 'ぐ' => 'グ', 'げ' => 'ゲ', 'ご' => 'ゴ',
+    'ざ' => 'ザ', 'じ' => 'ジ', 'ず' => 'ズ', 'ぜ' => 'ゼ', 'ぞ' => 'ゾ',
+    'だ' => 'ザ', 'ぢ' => 'ジ', 'づ' => 'ズ', 'で' => 'ゼ', 'ど' => 'ゾ',
+    'ば' => 'ダ', 'び' => 'ヂ', 'ぶ' => 'ヅ', 'べ' => 'デ', 'ぼ' => 'ド',
+    'ぱ' => 'マ', 'ぴ' => 'ミ', 'ぷ' => 'ム', 'ぺ' => 'メ', 'ぽ' => 'モ'
+    # Special particles (but not supported)
+    # 'が' => 'グ', 'の' => 'ン', 'は' => 'パ', 'を' => 'ゾ' (when used as particles)
+  }.freeze
+end