langscan 1.2

data/lib/langscan/_common.rb

@@ -0,0 +1,50 @@
+#
+# _common.rb - a part of LangScan
+#
+# Copyright (C) 2004-2005 Akira Tanaka <akr@m17n.org> 
+# Copyright (C) 2004-2005 Satoru Takabayashi <satoru@namazu.org> 
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+require 'langscan/_type'
+
+module LangScan
+  class ScanFailed < StandardError; end
+
+  Fragment = Struct.new(
+    :type, :text,
+    :beg_lineno, :beg_byteno)
+
+  # LangScan::Fragment has following variables.
+  # * _type_ is symbol that denotes Type of the fragment(e.g. :string, :comment,...).
+  # * _text_ is string that contains text of the fragment.
+  # * _lineno_ is number of lines where the fragment appears.
+  # * _byteno_ is number of bytes where the fragment appears.
+  class Fragment
+    alias_method :lineno, :beg_lineno
+    alias_method :byteno, :beg_byteno
+    
+    def inspect
+      "\#<#{self.class} #{type} #{text.inspect} #{beg_lineno} (#{beg_byteno})>"
+    end
+
+    def pretty_print(q)
+      q.text inspect
+    end
+
+    def end_byteno
+      self.beg_byteno + self.text.length
+    end
+  end
+
+  unless respond_to?(:register)
+    # stub
+    def register(mod)
+    end
+    module_function :register
+  end
+end

data/lib/langscan/_easyscanner.rb

@@ -0,0 +1,78 @@
+#
+# _easyscanner.rb - simple scanner for LangScan
+#
+# Copyright (C) 2005 Keisuke Nishida <knishida@open-cobol.org>
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+require 'langscan/_common'
+
+module LangScan
+  class EasyScanner
+    def initialize(pattern, types, keywords)
+      @pattern = pattern
+
+      # build regexp
+      regexp = "(\n)|" + @pattern.map {|v| "(" + v[1] + ")"}.join("|")
+      @regexp = Regexp.new(regexp)
+
+      # build type hash
+      @type = {}
+      types.each {|k| @type[k] = true }
+
+      # build keyword hash
+      @keyword = {}
+      keywords.each {|k| @keyword[k] = true }
+    end
+
+    def scan(input, &block)
+      lineno = 0
+      offset = 0
+      while match = @regexp.match(input[offset..-1])
+        if match[1]
+          # newline
+          lineno += 1
+          offset += match.end(0)
+        else
+          for i in 2..match.size-1
+            if match[i]
+              type = @pattern[i-2][0]
+              byteno = offset + match.begin(0)
+              if @pattern[i-2][2]
+                # pattern with terminator
+                start = offset + match.end(0)
+                end_match = input[start..-1].match(@pattern[i-2][2])
+                if end_match
+                  offset = start + end_match.end(0)
+                else
+                  # not terminated! what should we do?
+                  offset = start
+                end
+              else
+                # simple pattern
+                offset += match.end(0)
+              end
+              text = input[byteno..offset-1]
+              if type == :ident
+                case true
+                when @type[text]
+                  type = :type
+                when @keyword[text]
+                  type = :keyword
+                end
+              end
+              yield(Fragment.new(type, text, lineno, byteno))
+              lineno += text.count("\n")
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/langscan/_pairmatcher.rb

@@ -0,0 +1,46 @@
+#
+# pairmatcher.rb - a pair matching parser
+#
+# Copyright (C) 2005 Akira Tanaka <akr@m17n.org> 
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+require 'langscan/_common'
+require 'langscan/pairmatcher/pairmatcher'
+
+class Struct::LangScanPair
+  def outmost
+    ret = self
+    while o = ret.outer
+      ret = o
+    end
+    ret
+  end
+
+end
+
+module LangScan
+  def PairMatcher.fragmentsorter(block)
+    buf = []
+    pos = 0
+    lambda {|f|
+      if pos == f.beg_byteno
+        pos += f.text.length
+        block.call(f)
+        buf.sort! {|f1, f2| f1.beg_byteno <=> f2.beg_byteno }
+        while !buf.empty? && buf.first.beg_byteno == pos
+          f = buf.first
+          pos += f.text.length
+          block.call(f)
+          buf.shift
+        end
+      else
+        buf << f
+      end
+    }
+  end
+end

data/lib/langscan/_type.rb

@@ -0,0 +1,125 @@
+#
+# _type.rb - a part of LangScan
+#
+# Copyright (C) 2004-2005 Satoru Takabayashi <satoru@namazu.org> 
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+module LangScan
+  module Type
+    def self.N_ (dummy); dummy; end
+
+    class TypeGroup
+      def initialize(name)
+        @name = name
+        @members = []
+        @by_type = {}
+      end
+      attr_reader :name
+
+      def << (info)
+        @members.push(info)
+        @by_type[info.type] = info
+      end
+
+      def has_type?(type)
+        @by_type.include?(type)
+      end
+
+      def each
+        @members.each {|info| yield(info) }
+      end
+
+      def [] (i)
+        if i.is_a?(Integer)
+          @members[i]
+        else
+          @by_type[i]
+        end
+      end
+    end
+
+    TypeRegistry = {}
+
+    class TypeInfo
+      def initialize(type, name)
+        @type = type
+        @name = name
+        TypeRegistry[@type] = true
+      end
+      attr_reader :type
+      attr_reader :name
+    end
+
+    FunctionGroup = TypeGroup.new(N_("Function"))
+    FunctionGroup << TypeInfo.new(:fundef,  N_("Function Definition"))
+    FunctionGroup << TypeInfo.new(:funcall, N_("Function Call"))
+    FunctionGroup << TypeInfo.new(:fundecl, N_("Function Declaration"))
+
+    ObjectGroup = TypeGroup.new(N_("Object"))
+    ObjectGroup << TypeInfo.new(:classdef,  N_("Class Definition"))
+    ObjectGroup << TypeInfo.new(:classref,  N_("Class Reference"))
+    ObjectGroup << TypeInfo.new(:moduledef, N_("Module Definition"))
+
+    LiteralGroup = TypeGroup.new(N_("Literal"))
+    LiteralGroup << TypeInfo.new(:const,     N_("Constant"))
+    LiteralGroup << TypeInfo.new(:word,      N_("Word"))
+    LiteralGroup << TypeInfo.new(:ident,     N_("Identifier"))
+    LiteralGroup << TypeInfo.new(:integer,   N_("Integer"))
+    LiteralGroup << TypeInfo.new(:floating,  N_("Floating"))
+    LiteralGroup << TypeInfo.new(:imaginary, N_("Imaginary"))
+    LiteralGroup << TypeInfo.new(:string,    N_("String"))
+    LiteralGroup << TypeInfo.new(:symbol,    N_("Symbol"))
+    LiteralGroup << TypeInfo.new(:character, N_("Character"))
+    LiteralGroup << TypeInfo.new(:comment,   N_("Comment"))
+
+    KeywordGroup = TypeGroup.new(N_("Keyword"))
+    KeywordGroup << TypeInfo.new(:keyword, N_("Keyword"))
+    KeywordGroup << TypeInfo.new(:type,    N_("Primitive Type"))
+
+    TextGroup = TypeGroup.new(N_("Text"))
+    TextGroup << TypeInfo.new(:text, N_("Text"))
+
+    AllGroups = [
+      FunctionGroup, ObjectGroup, LiteralGroup, 
+      KeywordGroup, TextGroup
+    ]
+
+    module_function
+    def function?(type)
+      FunctionGroup.has_type?(type)
+    end
+
+    def include?(type)
+      TypeRegistry.include?(type)
+    end
+
+    SplittableTypes = {}
+    [:string, :comment, :text].each {|type| SplittableTypes[type] = true }
+    def splittable?(type)
+      SplittableTypes.include?(type)
+    end
+
+    def highlightable?(type)
+      ! splittable?(type)
+    end
+
+    def each_group
+      AllGroups.each {|group|
+        yield(group)
+      }
+    end
+
+    def each
+      each_group {|group|
+        group.each {|info|
+          yield(info)
+        }
+      }
+    end
+  end
+end

data/lib/langscan/autoconf.rb

@@ -0,0 +1,51 @@
+#
+# autoconf.rb - Autoconf module of LangScan
+#
+# Copyright (C) 2005 Keisuke Nishida <knishida@open-cobol.org>
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+require 'langscan/_easyscanner'
+
+module LangScan
+  module Autoconf
+    module_function
+    def name
+      "Autoconf"
+    end
+
+    def abbrev
+      "autoconf"
+    end
+
+    def extnames
+      [".ac"]
+    end
+
+    Pattern = [[:comment, "#.*"],
+               [:string, "\"", "\""],
+               [:string, "'", "'"],
+               [:integer, "\\d+"],
+               [:ident, "\\w+"],
+               [:keyword, "AC_\\w+"]]
+
+    Types = []
+
+    Keywords = %w(
+      if then else elif fi continue for in do done case esac exit
+    )
+
+    # LangScan::Autoconf.scan iterates over autoconf file.
+    # It yields for each Fragment.
+    def scan(input, &block)
+      scanner = EasyScanner.new(Pattern, Types, Keywords)
+      scanner.scan(input, &block)
+    end
+
+    LangScan.register(self)
+  end
+end

data/lib/langscan/automake.rb

@@ -0,0 +1,51 @@
+#
+# automake.rb - Automake module of LangScan
+#
+# Copyright (C) 2005 Keisuke Nishida <knishida@open-cobol.org>
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+require 'langscan/_easyscanner'
+
+module LangScan
+  module Automake
+    module_function
+    def name
+      "Automake"
+    end
+
+    def abbrev
+      "automake"
+    end
+
+    def extnames
+      [".am"]
+    end
+
+    Pattern = [[:comment, "#.*"],
+               [:string, "\"", "\""],
+               [:string, "'", "'"],
+               [:integer, "\\d+"],
+               [:ident, "\\w+"],
+               [:keyword, "[-\\.\\w]+:"]]
+
+    Types = []
+
+    Keywords = %w(
+      if then else elif fi continue for in do done case esac exit
+    )
+
+    # LangScan::Automake.scan iterates over automake file.
+    # It yields for each Fragment.
+    def scan(input, &block)
+      scanner = EasyScanner.new(Pattern, Types, Keywords)
+      scanner.scan(input, &block)
+    end
+
+    LangScan.register(self)
+  end
+end

data/lib/langscan/brainfuck.rb

@@ -0,0 +1,48 @@
+#
+# brainfuck.rb - a Brainfuck module of LangScan
+#
+# Copyright (C) 2005 MATSUNO Tokuhiro <tokuhirom at yahoo.co.jp>
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+require 'langscan/_easyscanner'
+
+module LangScan
+  module Brainfuck
+    module_function
+    def name
+      "BrainFuck"
+    end
+
+    def abbrev
+      "bf"
+    end
+
+    def extnames
+      [".bf"]
+    end
+
+    Pattern = [
+	  [:ident, '[<>+\\-.,\[\]]'],
+	  [:comment, '[^<>+\\-.,\[\]]+'],
+    ]
+
+    Types = []
+
+    Keywords = []
+
+    # LangScan::Brainfuck.scan iterates over Brainfuck program.
+    # It yields for each Fragment.
+    def scan(input, &block)
+      EasyScanner.new(Pattern, Types, Keywords).scan(input) {|t|
+		yield t
+      }
+    end
+
+    LangScan.register(self)
+  end
+end