rouge 3.1.0 → 3.18.0

data/lib/rouge/lexers/literate_coffeescript.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -20,11 +21,11 @@ module Rouge
       start { markdown.reset!; coffee.reset! }
 
       state :root do
-        rule /^(    .*?\n)+/m do
+        rule %r/^(    .*?\n)+/m do
           delegate coffee
         end
 
-        rule /^([ ]{0,3}(\S.*?|)\n)*/m do
+        rule %r/^([ ]{0,3}(\S.*?|)\n)*/m do
           delegate markdown
         end
       end

data/lib/rouge/lexers/literate_haskell.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -18,18 +19,18 @@ module Rouge
 
       # TODO: support TeX versions as well.
       state :root do
-        rule /\s*?\n(?=>)/, Text, :code
-        rule /.*?\n/, Text
-        rule /.+\z/, Text
+        rule %r/\s*?\n(?=>)/, Text, :code
+        rule %r/.*?\n/, Text
+        rule %r/.+\z/, Text
       end
 
       state :code do
-        rule /(>)( .*?(\n|\z))/ do |m|
+        rule %r/(>)( .*?(\n|\z))/ do |m|
           token Name::Label, m[1]
           delegate haskell, m[2]
         end
 
-        rule /\s*\n(?=\s*[^>])/, Text, :pop!
+        rule %r/\s*\n(?=\s*[^>])/, Text, :pop!
       end
     end
   end

data/lib/rouge/lexers/llvm.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -13,67 +14,83 @@ module Rouge
       string = /"[^"]*?"/
       identifier = /([-a-zA-Z$._][-a-zA-Z$._0-9]*|#{string})/
 
-      state :basic do
-        rule /;.*?$/, Comment::Single
-        rule /\s+/, Text
-
-        rule /#{identifier}\s*:/, Name::Label
-
-        rule /@(#{identifier}|\d+)/, Name::Variable::Global
-        rule /(%|!)#{identifier}/, Name::Variable
-        rule /(%|!)\d+/, Name::Variable
-
-        rule /c?#{string}/, Str
+      def self.keywords
+        @keywords ||= Set.new %w(
+          addrspace addrspacecast alias align alignstack allocsize alwaysinline
+          appending arcp argmemonly arm_aapcs_vfpcc arm_aapcscc arm_apcscc asm
+          attributes available_externally begin builtin byval c cc ccc cold
+          coldcc common constant convergent datalayout dbg declare default
+          define dllexport dllimport end eq exact extern_weak external false
+          fast fastcc gc global hidden inaccessiblemem_or_argmemonly
+          inaccessiblememonly inbounds inlinehint inreg internal jumptable
+          landingpad linker_private linkonce linkonce_odr minsize module naked
+          ne nest ninf nnan no-jump-tables noalias nobuiltin nocapture
+          nocf_check noduplicate noimplicitfloat noinline nonlazybind norecurse
+          noredzone noredzone noreturn nounwind nsw nsz null nuw oeq oge ogt
+          ole olt one opaque optforfuzzing optnone optsize ord personality
+          private protected ptx_device ptx_kernel readnone readonly
+          returns_twice safestack sanitize_address sanitize_hwaddress
+          sanitize_memory sanitize_thread section sge sgt shadowcallstack
+          sideeffect signext sle slt speculatable speculative_load_hardening
+          sret ssp sspreq sspstrong strictfp tail target thread_local to triple
+          true type ueq uge ugt ule ult undef une unnamed_addr uno uwtable
+          volatile weak weak_odr writeonly x x86_fastcallcc x86_stdcallcc
+          zeroext zeroinitializer
+        )
+      end
 
-        rule /0[xX][a-fA-F0-9]+/, Num
-        rule /-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?/, Num
+      def self.instructions
+        @instructions ||= Set.new %w(
+          add alloca and ashr bitcast br call catch cleanup extractelement
+          extractvalue fadd fcmp fdiv fmul fpext fptosi fptoui fptrunc free
+          frem fsub getelementptr getresult icmp insertelement insertvalue
+          inttoptr invoke load lshr malloc mul or phi ptrtoint resume ret sdiv
+          select sext shl shufflevector sitofp srem store sub switch trunc udiv
+          uitofp unreachable unwind urem va_arg xor zext
+        )
+      end
 
-        rule /[=<>{}\[\]()*.,!]|x/, Punctuation
+      def self.types
+        @types ||= Set.new %w(
+          double float fp128 half label metadata ppc_fp128 void x86_fp80 x86mmx
+        )
       end
 
-      builtin_types = %w(
-        void float double half x86_fp80 x86mmx fp128 ppc_fp128 label metadata
-      )
+      state :basic do
+        rule %r/;.*?$/, Comment::Single
+        rule %r/\s+/, Text
 
-      state :types do
-        rule /i[1-9]\d*/, Keyword::Type
-        rule /#{builtin_types.join('|')}/, Keyword::Type
-      end
+        rule %r/#{identifier}\s*:/, Name::Label
+
+        rule %r/@(#{identifier}|\d+)/, Name::Variable::Global
+        rule %r/#\d+/, Name::Variable::Global
+        rule %r/(%|!)#{identifier}/, Name::Variable
+        rule %r/(%|!)\d+/, Name::Variable
 
-      builtin_keywords = %w(
-        begin end true false declare define global constant personality private
-        landingpad linker_private internal available_externally linkonce_odr
-        linkonce weak weak_odr appending dllimport dllexport common default
-        hidden protected extern_weak external thread_local zeroinitializer
-        undef null to tail target triple datalayout volatile nuw nsw nnan ninf
-        nsz arcp fast exact inbounds align addrspace section alias module asm
-        sideeffect gc dbg ccc fastcc coldcc x86_stdcallcc x86_fastcallcc
-        arm_apcscc arm_aapcscc arm_aapcs_vfpcc ptx_device ptx_kernel cc
-        c signext zeroext inreg sret nounwind noreturn noalias nocapture byval
-        nest readnone readonly inlinehint noinline alwaysinline optsize ssp
-        sspreq noredzone noimplicitfloat naked type opaque eq ne slt sgt sle
-        sge ult ugt ule uge oeq one olt ogt ole oge ord uno unnamed_addr ueq
-        une uwtable x
-      )
+        rule %r/c?#{string}/, Str
 
-      builtin_instructions = %w(
-        add fadd sub fsub mul fmul udiv sdiv fdiv urem srem frem shl lshr ashr
-        and or xor icmp fcmp phi call catch trunc zext sext fptrunc fpext
-        uitofp sitofp fptoui fptosi inttoptr ptrtoint bitcast select va_arg ret
-        br switch invoke unwind unreachable malloc alloca free load store
-        getelementptr extractelement insertelement shufflevector getresult
-        extractvalue insertvalue cleanup resume
-      )
+        rule %r/0[xX][a-fA-F0-9]+/, Num
+        rule %r/-?\d+(?:[.]\d+)?(?:[eE][-+]?\d+(?:[.]\d+)?)?/, Num
 
-      state :keywords do
-        rule /#{builtin_instructions.join('|')}/, Keyword
-        rule /#{builtin_keywords.join('|')}/, Keyword
+        rule %r/[=<>{}\[\]()*.,!]|x/, Punctuation
       end
 
       state :root do
         mixin :basic
-        mixin :keywords
-        mixin :types
+
+        rule %r/i[1-9]\d*/, Keyword::Type
+
+        rule %r/\w+/ do |m|
+          if self.class.types.include? m[0]
+            token Keyword::Type
+          elsif self.class.instructions.include? m[0]
+            token Keyword
+          elsif self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Error
+          end
+        end
       end
     end
   end

data/lib/rouge/lexers/lua.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -24,7 +25,7 @@ module Rouge
       end
 
       def self.builtins
-        load Pathname.new(__FILE__).dirname.join('lua/builtins.rb')
+        load File.join(Lexers::BASE_DIR, 'lua/builtins.rb')
         self.builtins
       end
 
@@ -42,7 +43,7 @@ module Rouge
       state :root do
         # lua allows a file to start with a shebang
         rule %r(#!(.*?)$), Comment::Preproc
-        rule //, Text, :base
+        rule %r//, Text, :base
       end
 
       state :base do
@@ -71,7 +72,10 @@ module Rouge
 
         rule %r([A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?) do |m|
           name = m[0]
-          if self.builtins.include?(name)
+          if name == "gsub"
+            token Name::Builtin
+            push :gsub
+          elsif self.builtins.include?(name)
             token Name::Builtin
           elsif name =~ /\./
             a, b = name.split('.', 2)
@@ -88,7 +92,7 @@ module Rouge
       end
 
       state :function_name do
-        rule /\s+/, Text
+        rule %r/\s+/, Text
         rule %r((?:([A-Za-z_][A-Za-z0-9_]*)(\.))?([A-Za-z_][A-Za-z0-9_]*)) do
           groups Name::Class, Punctuation, Name::Function
           pop!
@@ -97,6 +101,41 @@ module Rouge
         rule %r(\(), Punctuation, :pop!
       end
 
+      state :gsub do
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/[(,]/, Punctuation
+        rule %r/\s+/, Text
+        rule %r/"/, Str::Regex, :regex
+      end
+
+      state :regex do
+        rule %r(") do
+          token Str::Regex
+          goto :regex_end
+        end
+
+        rule %r/\[\^?/, Str::Escape, :regex_group
+        rule %r/\\./, Str::Escape
+        rule %r{[(][?][:=<!]}, Str::Escape
+        rule %r/[{][\d,]+[}]/, Str::Escape
+        rule %r/[()?]/, Str::Escape
+        rule %r/./, Str::Regex
+      end
+
+      state :regex_end do
+        rule %r/[$]+/, Str::Regex, :pop!
+        rule(//) { pop! }
+      end
+
+      state :regex_group do
+        rule %r(/), Str::Escape
+        rule %r/\]/, Str::Escape, :pop!
+        rule %r/(\\)(.)/ do |m|
+          groups Str::Escape, Str::Regex
+        end
+        rule %r/./, Str::Regex
+      end
+
       state :escape_sqs do
         mixin :string_escape
         mixin :sqs

data/lib/rouge/lexers/lua/builtins.rb

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
 # automatically generated by `rake builtins:lua`
 module Rouge
   module Lexers

data/lib/rouge/lexers/lustre.rb

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Lustre < RegexLexer
+      title "Lustre"
+      desc 'The Lustre programming language (Verimag)'
+      tag 'lustre'
+      filenames '*.lus'
+      mimetypes 'text/x-lustre'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          extern unsafe assert const current enum function let node operator
+          returns step struct tel type var model package needs provides uses is
+          body end include merge
+        )
+      end
+
+      def self.word_operators
+        @word_operators ||= Set.new %w(
+          div and xor mod or not nor if then else fby pre when with
+        )
+      end
+
+      def self.primitives
+        @primitives ||= Set.new %w(int real bool)
+      end
+
+      operator = %r([,!$%&*+./:<=>?@^|~#-]+)
+      id = /[a-z_][\w']*/i
+
+      state :root do
+        rule %r/\s+/m, Text
+        rule %r/false|true/, Keyword::Constant
+        rule %r(\-\-.*), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule %r(\(\*.*?\*\))m, Comment::Multiline
+        rule id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.word_operators.include? match
+            token Operator::Word
+          elsif self.class.primitives.include? match
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        rule %r/[(){}\[\];]+/, Punctuation
+        rule operator, Operator
+
+        rule %r/-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
+        rule %r/\d[\d_]*/, Num::Integer
+
+        rule %r/'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
+        rule %r/'[.]'/, Str::Char
+        rule %r/"/, Str::Double, :string
+        rule %r/[~?]#{id}/, Name::Variable
+      end
+
+      state :string do
+        rule %r/[^\\"]+/, Str::Double
+        mixin :escape_sequence
+        rule %r/\\\n/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      state :escape_sequence do
+        rule %r/\\[\\"'ntbr]/, Str::Escape
+        rule %r/\\\d{3}/, Str::Escape
+        rule %r/\\x\h{2}/, Str::Escape
+      end
+    end
+  end
+end

data/lib/rouge/lexers/lutin.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+#
+# adapted from lustre.rf (adapted from ocaml.rb), hence some ocaml-ism migth remains
+module Rouge
+  module Lexers
+    load_lexer 'lustre.rb'
+
+    class Lutin < Lustre
+      title "Lutin"
+      desc 'The Lutin programming language (Verimag)'
+      tag 'lutin'
+      filenames '*.lut'
+      mimetypes 'text/x-lutin'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          let in node extern system returns weak strong assert raise try catch
+          trap do exist erun run type ref exception include false true 
+        )
+      end
+
+      def self.word_operators
+        @word_operators ||= Set.new %w(
+           div and xor mod or not nor if then else pre) 
+      end
+
+      def self.primitives
+        @primitives ||= Set.new %w(int real bool trace loop fby)
+      end
+    end
+  end
+end

data/lib/rouge/lexers/m68k.rb

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class M68k < RegexLexer
+      tag 'm68k'
+
+      title "M68k"
+      desc "Motorola 68k Assembler"
+
+      id = /[a-zA-Z_][a-zA-Z0-9_]*/
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          abcd add adda addi addq addx and andi asl asr
+
+          bcc bcs beq bge bgt bhi ble bls blt bmi bne bpl bvc bvs bhs blo
+          bchg bclr bfchg bfclr bfests bfextu bfffo bfins bfset bftst bkpt bra bse bsr btst
+
+          callm cas cas2 chk chk2 clr cmp cmpa cmpi cmpm cmp2
+
+          dbcc dbcs dbeq dbge dbgt dbhi dble dbls dblt dbmi dbne dbpl dbvc dbvs dbhs dblo
+          dbra dbf dbt divs divsl divu divul
+
+          eor eori exg ext extb
+
+          illegal jmp jsr lea link lsl lsr
+
+          move movea move16 movem movep moveq muls mulu
+
+          nbcd neg negx nop not or ori
+
+          pack pea rol ror roxl roxr rtd rtm rtr rts
+
+          sbcd
+
+          seq sne spl smi svc svs st sf sge sgt sle slt scc shi sls scs shs slo
+          sub suba subi subq subx swap
+
+          tas trap trapcc TODO trapv tst
+
+          unlk unpk eori
+        )
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+          dc ds dcb
+        )
+      end
+
+      def self.reserved
+        @reserved ||= Set.new %w(
+          include incdir incbin end endf endfunc endmain endproc fpu func machine main mmu opword proc set opt section
+          rept endr
+          ifeq ifne ifgt ifge iflt ifle iif ifd ifnd ifc ifnc elseif else endc
+          even cnop fail machine
+          output radix __G2 __LK
+          list nolist plen llen ttl subttl spc page listchar format
+          equ equenv equr set reg
+          rsreset rsset offset
+          cargs
+          fequ.s fequ.d fequ.x fequ.p fequ.w fequ.l fopt
+          macro endm mexit narg
+        )
+      end
+
+      def self.builtins
+        @builtins ||=Set.new %w(
+          d0 d1 d2 d3 d4 d5 d6 d7
+          a0 a1 a2 a3 a4 a5 a6 a7 a7'
+          pc usp ssp ccr
+        )
+      end
+
+      start { push :expr_bol }
+
+      state :expr_bol do
+        mixin :inline_whitespace
+        rule(//) { pop! }
+      end
+
+      state :inline_whitespace do
+        rule %r/\s+/, Text
+      end
+
+      state :whitespace do
+        rule %r/\n+/m, Text, :expr_bol
+        rule %r(^\*(\\.|.)*?$), Comment::Single, :expr_bol
+        rule %r(;(\\.|.)*?$), Comment::Single, :expr_bol
+        mixin :inline_whitespace
+      end
+
+      state :root do
+        rule(//) { push :statements }
+      end
+
+      state :statements do
+        mixin :whitespace
+        rule %r/"/, Str, :string
+        rule %r/#/, Name::Decorator
+        rule %r/^\.?[a-zA-Z0-9_]+:?/, Name::Label
+        rule %r/\.[bswl]\s/i, Name::Decorator
+        rule %r('(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, Str::Char
+        rule %r/\$[0-9a-f]+/i, Num::Hex
+        rule %r/@[0-8]+/i, Num::Oct
+        rule %r/%[01]+/i, Num::Bin
+        rule %r/\d+/i, Num::Integer
+        rule %r([*~&+=\|?:<>/-]), Operator
+        rule %r/\\./, Comment::Preproc
+        rule %r/[(),.]/, Punctuation
+        rule %r/\[[a-zA-Z0-9]*\]/, Punctuation
+
+        rule id do |m|
+          name = m[0]
+
+          if self.class.keywords.include? name.downcase
+            token Keyword
+          elsif self.class.keywords_type.include? name.downcase
+            token Keyword::Type
+          elsif self.class.reserved.include? name.downcase
+            token Keyword::Reserved
+          elsif self.class.builtins.include? name.downcase
+            token Name::Builtin
+          elsif name =~ /[a-zA-Z0-9]+/
+            token Name::Variable
+          else
+            token Name
+          end
+        end
+      end
+
+      state :string do
+        rule %r/"/, Str, :pop!
+        rule %r/\\([\\abfnrtv"']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})/, Str::Escape
+        rule %r/[^\\"\n]+/, Str
+        rule %r/\\\n/, Str
+        rule %r/\\/, Str # stray backslash
+      end
+    end
+  end
+end