rouge 3.17.0

data/lib/rouge/lexers/lua.rb

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Lua < RegexLexer
+      title "Lua"
+      desc "Lua (http://www.lua.org)"
+      tag 'lua'
+      filenames '*.lua', '*.wlua'
+
+      mimetypes 'text/x-lua', 'application/x-lua'
+
+      option :function_highlighting, 'Whether to highlight builtin functions (default: true)'
+      option :disabled_modules, 'builtin modules to disable'
+
+      def initialize(opts={})
+        @function_highlighting = opts.delete(:function_highlighting) { true }
+        @disabled_modules = opts.delete(:disabled_modules) { [] }
+        super(opts)
+      end
+
+      def self.detect?(text)
+        return true if text.shebang? 'lua'
+      end
+
+      def self.builtins
+        load File.join(__dir__, 'lua/builtins.rb')
+        self.builtins
+      end
+
+      def builtins
+        return [] unless @function_highlighting
+
+        @builtins ||= Set.new.tap do |builtins|
+          self.class.builtins.each do |mod, fns|
+            next if @disabled_modules.include? mod
+            builtins.merge(fns)
+          end
+        end
+      end
+
+      state :root do
+        # lua allows a file to start with a shebang
+        rule %r(#!(.*?)$), Comment::Preproc
+        rule %r//, Text, :base
+      end
+
+      state :base do
+        rule %r(--\[(=*)\[.*?\]\1\])m, Comment::Multiline
+        rule %r(--.*$), Comment::Single
+
+        rule %r((?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?'), Num::Float
+        rule %r((?i)\d+e[+-]?\d+), Num::Float
+        rule %r((?i)0x[0-9a-f]*), Num::Hex
+        rule %r(\d+), Num::Integer
+
+        rule %r(\n), Text
+        rule %r([^\S\n]), Text
+        # multiline strings
+        rule %r(\[(=*)\[.*?\]\1\])m, Str
+
+        rule %r((==|~=|<=|>=|\.\.\.|\.\.|[=+\-*/%^<>#])), Operator
+        rule %r([\[\]\{\}\(\)\.,:;]), Punctuation
+        rule %r((and|or|not)\b), Operator::Word
+
+        rule %r((break|do|else|elseif|end|for|if|in|repeat|return|then|until|while)\b), Keyword
+        rule %r((local)\b), Keyword::Declaration
+        rule %r((true|false|nil)\b), Keyword::Constant
+
+        rule %r((function)\b), Keyword, :function_name
+
+        rule %r([A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?) do |m|
+          name = m[0]
+          if name == "gsub"
+            token Name::Builtin
+            push :gsub
+          elsif self.builtins.include?(name)
+            token Name::Builtin
+          elsif name =~ /\./
+            a, b = name.split('.', 2)
+            token Name, a
+            token Punctuation, '.'
+            token Name, b
+          else
+            token Name
+          end
+        end
+
+        rule %r('), Str::Single, :escape_sqs
+        rule %r("), Str::Double, :escape_dqs
+      end
+
+      state :function_name do
+        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!
+        end
+        # inline function
+        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
+      end
+
+      state :escape_dqs do
+        mixin :string_escape
+        mixin :dqs
+      end
+
+      state :string_escape do
+        rule %r(\\([abfnrtv\\"']|\d{1,3})), Str::Escape
+      end
+
+      state :sqs do
+        rule %r('), Str::Single, :pop!
+        rule %r([^']+), Str::Single
+      end
+
+      state :dqs do
+        rule %r("), Str::Double, :pop!
+        rule %r([^"]+), Str::Double
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# automatically generated by `rake builtins:lua`
+module Rouge
+  module Lexers
+    class Lua
+      def self.builtins
+        @builtins ||= {}.tap do |b|
+          b["basic"] = Set.new %w(_G _VERSION assert collectgarbage dofile error getmetatable ipairs load loadfile next pairs pcall print rawequal rawget rawlen rawset select setmetatable tonumber tostring type xpcall file:close file:flush file:lines file:read file:seek file:setvbuf file:write LUA_CPATH LUA_CPATH_5_2 LUA_INIT LUA_INIT_5_2 LUA_PATH LUA_PATH_5_2 luaopen_base luaopen_bit32 luaopen_coroutine luaopen_debug luaopen_io luaopen_math luaopen_os luaopen_package luaopen_string luaopen_table LUA_ERRERR LUA_ERRFILE LUA_ERRGCMM LUA_ERRMEM LUA_ERRRUN LUA_ERRSYNTAX LUA_HOOKCALL LUA_HOOKCOUNT LUA_HOOKLINE LUA_HOOKRET LUA_HOOKTAILCALL LUA_MASKCALL LUA_MASKCOUNT LUA_MASKLINE LUA_MASKRET LUA_MINSTACK LUA_MULTRET LUA_NOREF LUA_OK LUA_OPADD LUA_OPDIV LUA_OPEQ LUA_OPLE LUA_OPLT LUA_OPMOD LUA_OPMUL LUA_OPPOW LUA_OPSUB LUA_OPUNM LUA_REFNIL LUA_REGISTRYINDEX LUA_RIDX_GLOBALS LUA_RIDX_MAINTHREAD LUA_TBOOLEAN LUA_TFUNCTION LUA_TLIGHTUSERDATA LUA_TNIL LUA_TNONE LUA_TNUMBER LUA_TSTRING LUA_TTABLE LUA_TTHREAD LUA_TUSERDATA LUA_USE_APICHECK LUA_YIELD LUAL_BUFFERSIZE)
+          b["modules"] = Set.new %w(require package.config package.cpath package.loaded package.loadlib package.path package.preload package.searchers package.searchpath)
+          b["bit32"] = Set.new %w(bit32.arshift bit32.band bit32.bnot bit32.bor bit32.btest bit32.bxor bit32.extract bit32.lrotate bit32.lshift bit32.replace bit32.rrotate bit32.rshift)
+          b["coroutine"] = Set.new %w(coroutine.create coroutine.resume coroutine.running coroutine.status coroutine.wrap coroutine.yield)
+          b["debug"] = Set.new %w(debug.debug debug.getuservalue debug.gethook debug.getinfo debug.getlocal debug.getmetatable debug.getregistry debug.getupvalue debug.setuservalue debug.sethook debug.setlocal debug.setmetatable debug.setupvalue debug.traceback debug.upvalueid debug.upvaluejoin)
+          b["io"] = Set.new %w(io.close io.flush io.input io.lines io.open io.output io.popen io.read io.stderr io.stdin io.stdout io.tmpfile io.type io.write)
+          b["math"] = Set.new %w(math.abs math.acos math.asin math.atan math.atan2 math.ceil math.cos math.cosh math.deg math.exp math.floor math.fmod math.frexp math.huge math.ldexp math.log math.max math.min math.modf math.pi math.pow math.rad math.random math.randomseed math.sin math.sinh math.sqrt math.tan math.tanh)
+          b["os"] = Set.new %w(os.clock os.date os.difftime os.execute os.exit os.getenv os.remove os.rename os.setlocale os.time os.tmpname)
+          b["string"] = Set.new %w(string.byte string.char string.dump string.find string.format string.gmatch string.gsub string.len string.lower string.match string.rep string.reverse string.sub string.upper)
+          b["table"] = Set.new %w(table.concat table.insert table.pack table.remove table.sort table.unpack)
+        end
+      end
+    end
+  end
+end

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

data/lib/rouge/lexers/magik.rb

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Magik < RegexLexer
+      title "Magik"
+      desc "Smallworld Magik"
+      tag 'magik'
+      filenames '*.magik'
+      mimetypes 'text/x-magik', 'application/x-magik'
+
+      def self.keywords
+        @keywords ||= %w(
+           _package
+           _pragma
+           _block _endblock
+           _handling _default
+           _protect _protection _endprotect
+           _try _with _when _endtry
+           _catch _endcatch
+           _throw
+           _lock _endlock
+           _if _then _elif _else _endif
+           _for _over _while _loop _finally _endloop _loopbody _continue _leave
+           _return
+           _class
+           _local _constant _recursive _global _dynamic _import
+           _private _iter _abstract _method _endmethod
+           _proc _endproc
+           _gather _scatter _allresults _optional
+           _thisthread _self _clone _super
+           _primitive
+           _unset _true _false _maybe
+           _is _isnt _not _and _or _xor _cf _andif _orif
+           _div _mod
+        )
+      end
+
+      def self.string_double
+        @string_double ||= /"[^"\n]*?"/
+      end
+      def self.string_single
+        @string_single ||= /'[^'\n]*?'/
+      end
+
+      def self.digits
+        @digits ||= /[0-9]+/
+      end
+      def self.radix
+        @radix ||= /r[0-9a-z]/i
+      end
+      def self.exponent
+        @exponent ||= /(e|&)[+-]?#{Magik.digits}/i
+      end
+      def self.decimal
+        @decimal ||= /\.#{Magik.digits}/
+      end
+      def self.number
+        @number = /#{Magik.digits}(#{Magik.radix}|#{Magik.exponent}|#{Magik.decimal})*/
+      end
+
+      def self.character
+        @character ||= /%u[0-9a-z]{4}|%[^\s]+/i
+      end
+
+      def self.simple_identifier
+        @simple_identifier ||= /(?>(?:[a-z0-9_!?]|\\.)+)/i
+      end
+      def self.piped_identifier
+        @piped_identifier ||= /\|[^\|\n]*\|/
+      end
+      def self.identifier
+        @identifier ||= /(?:#{Magik.simple_identifier}|#{Magik.piped_identifier})+/i
+      end
+      def self.package_identifier
+        @package_identifier ||= /#{Magik.identifier}:#{Magik.identifier}/
+      end
+      def self.symbol
+        @symbol ||= /:#{Magik.identifier}/i
+      end
+      def self.global_ref
+        @global_ref ||= /@[\s]*#{Magik.identifier}:#{Magik.identifier}/
+      end
+      def self.label
+        @label = /@[\s]*#{Magik.identifier}/
+      end
+
+      state :root do
+        rule %r/##(.*)?/, Comment::Doc
+        rule %r/#(.*)?/, Comment::Single
+
+        rule %r/(_method)(\s+)/ do
+          groups Keyword, Text::Whitespace
+          push :method_name
+        end
+
+        rule %r/(?:#{Magik.keywords.join('|')})\b/, Keyword
+
+        rule Magik.string_double, Literal::String
+        rule Magik.string_single, Literal::String
+        rule Magik.symbol, Str::Symbol
+        rule Magik.global_ref, Name::Label
+        rule Magik.label, Name::Label
+        rule Magik.character, Literal::String::Char
+        rule Magik.number, Literal::Number
+        rule Magik.package_identifier, Name
+        rule Magik.identifier, Name
+
+        rule %r/[\[\]{}()\.,;]/, Punctuation
+        rule %r/\$/, Punctuation
+        rule %r/(<<|^<<)/, Operator
+        rule %r/(>>)/, Operator
+        rule %r/[-~+\/*%=&^<>]|!=/, Operator
+
+        rule %r/[\s]+/, Text::Whitespace
+      end
+
+      state :method_name do
+        rule %r/(#{Magik.identifier})(\.)(#{Magik.identifier})/ do
+          groups Name::Class, Punctuation, Name::Function
+          pop!
+        end
+      end
+    end
+  end
+end