rougegal 2.1.2

data/lib/rouge/lexers/vb.rb

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class VisualBasic < RegexLexer
+      title "Visual Basic"
+      desc "Visual Basic"
+      tag 'vb'
+      aliases 'visualbasic'
+      filenames '*.vbs', '*.vb'
+      mimetypes 'text/x-visualbasic', 'application/x-visualbasic'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          AddHandler Alias ByRef ByVal CBool CByte CChar CDate CDbl CDec
+          CInt CLng CObj CSByte CShort CSng CStr CType CUInt CULng CUShort
+          Call Case Catch Class Const Continue Declare Default Delegate
+          Dim DirectCast Do Each Else ElseIf End EndIf Enum Erase Error
+          Event Exit False Finally For Friend Function Get Global GoSub
+          GoTo Handles If Implements Imports Inherits Interface Let
+          Lib Loop Me Module MustInherit MustOverride MyBase MyClass
+          Namespace Narrowing New Next Not NotInheritable NotOverridable
+          Nothing Of On Operator Option Optional Overloads Overridable
+          Overrides ParamArray Partial Private Property Protected Public
+          RaiseEvent ReDim ReadOnly RemoveHandler Resume Return Select Set
+          Shadows Shared Single Static Step Stop Structure Sub SyncLock
+          Then Throw To True Try TryCast Using Wend When While Widening
+          With WithEvents WriteOnly
+        )
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+          Boolean Byte Char Date Decimal Double Integer Long Object
+          SByte Short Single String Variant UInteger ULong UShort
+        )
+      end
+
+      def self.operator_words
+        @operator_words ||= Set.new %w(
+          AddressOf And AndAlso As GetType In Is IsNot Like Mod Or OrElse
+          TypeOf Xor
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          Console ConsoleColor
+        )
+      end
+
+      id = /[a-z_]\w*/i
+      upper_id = /[A-Z]\w*/
+
+      state :whitespace do
+        rule /\s+/, Text
+        rule /\n/, Text, :bol
+        rule /rem\b.*?$/i, Comment::Single
+        rule %r(%\{.*?%\})m, Comment::Multiline
+        rule /'.*$/, Comment::Single
+      end
+
+      state :bol do
+        rule /\s+/, Text
+        rule /<.*?>/, Name::Attribute
+        rule(//) { :pop! }
+      end
+
+      state :root do
+        mixin :whitespace
+        rule %r(
+            [#]If\b .*? \bThen
+          | [#]ElseIf\b .*? \bThen
+          | [#]End \s+ If
+          | [#]Const
+          | [#]ExternalSource .*? \n
+          | [#]End \s+ ExternalSource
+          | [#]Region .*? \n
+          | [#]End \s+ Region
+          | [#]ExternalChecksum
+        )x, Comment::Preproc
+        rule /[.]/, Punctuation, :dotted
+        rule /[(){}!#,:]/, Punctuation
+        rule /Option\s+(Strict|Explicit|Compare)\s+(On|Off|Binary|Text)/,
+          Keyword::Declaration
+        rule /End\b/, Keyword, :end
+        rule /(Dim|Const)\b/, Keyword, :dim
+        rule /(Function|Sub|Property)\b/, Keyword, :funcname
+        rule /(Class|Structure|Enum)\b/, Keyword, :classname
+        rule /(Module|Namespace|Imports)\b/, Keyword, :namespace
+
+        rule upper_id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.keywords_type.include? match
+            token Keyword::Type
+          elsif self.class.operator_words.include? match
+            token Operator::Word
+          elsif self.class.builtins.include? match
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+
+        rule(
+          %r(&=|[*]=|/=|\\=|\^=|\+=|-=|<<=|>>=|<<|>>|:=|<=|>=|<>|[-&*/\\^+=<>.]),
+          Operator
+        )
+
+        rule /"/, Str, :string
+        rule /#{id}[%&@!#\$]?/, Name
+        rule /#.*?#/, Literal::Date
+
+        rule /(\d+\.\d*|\d*\.\d+)(f[+-]?\d+)?/i, Num::Float
+        rule /\d+([SILDFR]|US|UI|UL)?/, Num::Integer
+        rule /&H[0-9a-f]+([SILDFR]|US|UI|UL)?/, Num::Integer
+        rule /&O[0-7]+([SILDFR]|US|UI|UL)?/, Num::Integer
+
+        rule /_\n/, Keyword
+      end
+
+      state :dotted do
+        mixin :whitespace
+        rule id, Name, :pop!
+      end
+
+      state :string do
+        rule /""/, Str::Escape
+        rule /"C?/, Str, :pop!
+        rule /[^"]+/, Str
+      end
+
+      state :dim do
+        mixin :whitespace
+        rule id, Name::Variable, :pop!
+        rule(//) { pop! }
+      end
+
+      state :funcname do
+        mixin :whitespace
+        rule id, Name::Function, :pop!
+      end
+
+      state :classname do
+        mixin :whitespace
+        rule id, Name::Class, :pop!
+      end
+
+      state :namespace do
+        mixin :whitespace
+        rule /#{id}([.]#{id})*/, Name::Namespace, :pop!
+      end
+
+      state :end do
+        mixin :whitespace
+        rule /(Function|Sub|Property|Class|Structure|Enum|Module|Namespace)\b/,
+          Keyword, :pop!
+        rule(//) { pop! }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/verilog.rb

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Verilog < RegexLexer
+      title "Verilog and System Verilog"
+      desc "The System Verilog hardware description language"
+      tag 'verilog'
+      filenames '*.v', '*.sv', '*.svh'
+      mimetypes 'text/x-verilog', 'text/x-systemverilog'
+
+      # optional comment or whitespace
+      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
+      id = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          alias always always_comb always_ff always_latch assert assert_strobe
+          assign assume automatic attribute before begin bind bins binsof break
+          case casex casez clocking config constraint context continue cover
+          covergroup coverpoint cross deassign defparam default design dist do
+          else end endattribute endcase endclass endclocking endconfig
+          endfunction endgenerate endgroup endinterface endmodule endpackage
+          endprimitive endprogram endproperty endspecify endsequence endtable
+          endtask expect export extends extern final first_match for force
+          foreach fork forkjoin forever function generate genvar if iff ifnone
+          ignore_bins illegal_bins import incdir include initial inside instance
+          interface intersect join join_any join_none liblist library local
+          localparam  matches module modport new noshowcancelled null package
+          parameter primitive priority program property protected
+          pulsestyle_onevent  pulsestyle_ondetect pure rand randc randcase
+          randsequence release return sequence showcancelled solve specify super
+          table task this throughout timeprecision timeunit type typedef unique
+          use wait wait_order while wildcard with within
+        )
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+          and bit buf bufif0 bufif1 byte cell chandle class cmos const disable
+          edge enum event highz0 highz1 initial inout input int integer join
+          logic longint macromodule medium nand negedge nmos nor not
+          notif0 notif1 or output packed parameter pmos posedge pull0 pull1
+          pulldown pullup rcmos real realtime ref reg repeat rnmos rpmos rtran
+          rtranif0 rtranif1 scalared shortint shortreal signed  specparam
+          static string strength strong0 strong1 struct supply0 supply1 tagged
+          time tran tranif0 tranif1 tri tri0 tri1 triand trior trireg union
+          unsigned uwire var vectored virtual void wait wand weak[01] wire wor
+          xnor xor
+        )
+      end
+
+      def self.keywords_system_task
+        @keyword_system_task ||= Set.new %w(
+          acos acosh asin asinh assertfailoff assertfailon  assertkill
+          assertnonvacuouson assertoff asserton assertpassoff assertpasson
+          assertvacuousoff atan atan2 atanh bits bitstoreal  bitstoshortreal
+          cast ceil changed changed_gclk changing_gclk clog2 cos cosh countones
+          coverage_control coverage_get coverage_get_max coverage_merge
+          coverage_save dimensions display displayb displayh displayo
+          dist_chi_square dist_erlang dist_exponential dist_normal dist_poisson
+          dist_t dist_uniform dumpall dumpfile dumpflush dumplimit dumpoff
+          dumpon dumpports dumpportsall dumpportsflush dumpportslimit
+          dumpportsoff dumpportson dumpvars error exit exp falling_gclk fclose
+          fdisplay fdisplayb fdisplayh fdisplayo fell fell_gclk feof ferror
+          fflush fgetc fgets finish floor fmonitor fmonitorb fmonitorh fmonitoro
+          fopen fread fscanf fseek fstrobe fstrobeb fstrobeh fstrobeo ftell
+          future_gclk fwrite fwriteb fwriteh fwriteo get_coverage high hypot
+          increment info isunbounded isunknown itor left ln load_coverage_db
+          log10 low monitor monitorb monitorh monitoro monitoroff monitoron
+          onehot onehot0 past past_gclk pow printtimescale q_add q_exam q_full
+          q_initialize q_remove random readmemb readmemh realtime realtobits
+          rewind right rising_gclk rose rose_gclk rtoi sampled
+          set_coverage_db_name sformat sformatf shortrealtobits signed sin sinh
+          size sqrt sscanf stable stable_gclk steady_gclk stime stop strobe
+          strobeb strobeh strobeo swrite swriteb swriteh swriteo system tan tanh
+          time timeformat typename ungetc unpacked_dimensions unsigned warning
+          write writeb writeh writememb writememh writeo
+        )
+      end
+
+      state :expr_bol do
+        mixin :inline_whitespace
+        rule /`define/, Comment::Preproc, :macro
+
+        rule(//) { pop! }
+      end
+
+      # :expr_bol is the same as :bol but without labels, since
+      # labels can only appear at the beginning of a statement.
+      state :bol do
+        rule /#{id}:(?!:)/, Name::Label
+        mixin :expr_bol
+      end
+
+      state :inline_whitespace do
+        rule /[ \t\r]+/, Text
+        rule /\\\n/, Text # line continuation
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+      end
+
+      state :whitespace do
+        rule /\n+/m, Text, :bol
+        rule %r(//(\\.|.)*?\n), Comment::Single, :bol
+        mixin :inline_whitespace
+      end
+
+      state :expr_whitespace do
+        rule /\n+/m, Text, :expr_bol
+        mixin :whitespace
+      end
+
+      state :string do
+        rule /"/, Str, :pop!
+        rule /\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
+        rule /[^\\"\n]+/, Str
+        rule /\\\n/, Str
+        rule /\\/, Str # stray backslash
+      end
+
+      state :statement do
+        mixin :whitespace
+        rule /L?"/, Str, :string
+        rule /([0-9_]+\.[0-9_]*|[0-9_]*\.[0-9_]+)(e[+-]?[0-9_]+)?/i, Num::Float
+        rule /[0-9_]+e[+-]?[0-9_]+/i, Num::Float
+        rule /[0-9]*'h[0-9a-fA-F_?]+/, Num::Hex
+        rule /[0-9]*'b?[01xz_?]+/, Num::Bin
+        rule /[0-9]*'d[0-9_?]+/, Num::Integer
+        rule /[0-9_]+[lu]*/i, Num::Integer
+        rule %r([~!%^&*+-=\|?:<>/@{}]), Operator
+        rule /[()\[\],.$\#]/, Punctuation
+        rule /`(\w+)/, Comment::Preproc
+
+        rule id do |m|
+          name = m[0]
+
+          if self.class.keywords.include? name
+            token Keyword
+          elsif self.class.keywords_type.include? name
+            token Keyword::Type
+          elsif self.class.keywords_system_task.include? name
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+      end
+
+      state :root do
+        mixin :expr_whitespace
+        rule(//) { push :statement }
+      end
+
+      state :macro do
+        rule /\n/, Comment::Preproc, :pop!
+        mixin :inline_whitespace
+        rule /;/, Punctuation
+        rule /\=/, Operator
+        rule /(\w+)/, Text
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/vhdl.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class VHDL < RegexLexer
+      title "VHDL 2008"
+      desc "Very High Speed Integrated Circuit Hardware Description Language"
+      tag 'vhdl'
+
+      filenames '*.vhd', '*.vhdl', '*.vho'
+
+      mimetypes 'text/x-vhdl'
+      def self.keywords
+        @keywords ||= Set.new %w(
+        access after alias all architecture array assert assume assume_guarantee attribute
+        begin block body buffer bus case component configuration constant context cover
+        default disconnect downto else elsif end entity exit fairness file for force function
+        generate generic group guarded if impure in inertial inout is label library linkage
+        literal loop map new next null of on open others out package parameter port postponed
+        procedure process property protected pure range record register reject release report
+        return select sequence severity shared signal strong subtype then to transport type
+        unaffected units until use variable vmode vprop vunit wait when while with
+        )
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+        bit bit_vector boolean boolean_vector character integer integer_vector natural positive
+        real real_vector severity_level signed std_logic std_logic_vector std_ulogic
+        std_ulogic_vector string unsigned time time__vector
+        )
+      end
+
+      def self.operator_words
+        @operator_words ||= Set.new %w(
+        abs and mod nand nor not or rem rol ror sla sll sra srl xnor xor
+        )
+      end
+
+      id = /[a-zA-Z][a-zA-Z0-9_]*/
+
+      state :whitespace do
+        rule /\s+/, Text
+        rule /\n/, Text
+        # Find Comments (VHDL doesn't support multiline comments)
+        rule /--.*$/, Comment::Single
+      end
+
+      state :statements do
+
+        # Find Numbers
+        rule /-?\d+/i, Num::Integer
+        rule /-?\d+[.]\d+/i, Num::Float
+
+        # Find Strings
+        rule /[box]?"[^"]*"/i, Str::Single
+        rule /'[^']?'/i, Str::Char
+
+        # Find Attributes
+        rule /'#{id}/i, Name::Attribute
+        
+        # Punctuations
+        rule /[(),:;]/, Punctuation
+
+        # Boolean and NULL
+        rule /(?:true|false|null)\b/i, Name::Builtin
+
+        rule id do |m|
+          match = m[0].downcase   #convert to lower case
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.keywords_type.include? match
+            token Keyword::Type
+          elsif self.class.operator_words.include? match
+            token Operator::Word
+          else
+            token Name
+          end
+        end
+
+        rule(
+        %r(=>|[*][*]|:=|\/=|>=|<=|<>|\?\?|\?=|\?\/=|\?>|\?<|\?>=|\?<=|<<|>>|[#&'*+-.\/:<=>\?@^]),
+        Operator
+        )
+
+      end
+
+      state :root do
+
+        mixin :whitespace
+        mixin :statements
+
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/viml.rb

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class VimL < RegexLexer
+      title "VimL"
+      desc "VimL, the scripting language for the Vim editor (vim.org)"
+      tag 'viml'
+      aliases 'vim', 'vimscript', 'ex'
+      filenames '*.vim', '*.vba', '.vimrc', '.exrc', '.gvimrc',
+                '_vimrc', '_exrc', '_gvimrc' # _ names for windows
+
+      mimetypes 'text/x-vim'
+
+      def self.keywords
+        load Pathname.new(__FILE__).dirname.join('viml/keywords.rb')
+        self.keywords
+      end
+
+      state :root do
+        rule /^(\s*)(".*?)$/ do
+          groups Text, Comment
+        end
+
+        rule /^\s*\\/, Str::Escape
+
+        rule /[ \t]+/, Text
+
+        # TODO: regexes can have other delimiters
+        rule %r(/(\\\\|\\/|[^\n/])*/), Str::Regex
+        rule %r("(\\\\|\\"|[^\n"])*"), Str::Double
+        rule %r('(\\\\|\\'|[^\n'])*'), Str::Single
+
+        # if it's not a string, it's a comment.
+        rule /(?<=\s)"[^-:.%#=*].*?$/, Comment
+
+        rule /-?\d+/, Num
+        rule /#[0-9a-f]{6}/i, Num::Hex
+        rule /^:/, Punctuation
+        rule /[():<>+=!\[\]{}\|,~.-]/, Punctuation
+        rule /\b(let|if|else|endif|elseif|fun|function|endfunction)\b/,
+          Keyword
+
+        rule /\b(NONE|bold|italic|underline|dark|light)\b/, Name::Builtin
+
+        rule /[absg]:\w+\b/, Name::Variable
+        rule /\b\w+\b/ do |m|
+          name = m[0]
+          keywords = self.class.keywords
+
+          if mapping_contains?(keywords[:command], name)
+            token Keyword
+          elsif mapping_contains?(keywords[:option], name)
+            token Name::Builtin
+          elsif mapping_contains?(keywords[:auto], name)
+            token Name::Builtin
+          else
+            token Text
+          end
+        end
+
+        # no errors in VimL!
+        rule /./m, Text
+      end
+
+      def mapping_contains?(mapping, word)
+        shortest, longest = find_likely_mapping(mapping, word)
+
+        shortest and word.start_with?(shortest) and
+        longest and longest.start_with?(word)
+      end
+
+      # binary search through the mappings to find the one that's likely
+      # to actually work.
+      def find_likely_mapping(mapping, word)
+        min = 0
+        max = mapping.size
+
+        until max == min
+          mid = (max + min) / 2
+
+          cmp, _ = mapping[mid]
+
+          case word <=> cmp
+          when 1
+            # too low
+            min = mid + 1
+          when -1
+            # too high
+            max = mid
+          when 0
+            # just right, abort!
+            return mapping[mid]
+          end
+        end
+
+        mapping[max - 1]
+      end
+    end
+  end
+end