rouge_ecl 0.0.1

data/lib/rouge/lexers/diff.rb

@@ -0,0 +1,31 @@
+module Rouge
+  module Lexers
+    class Diff < RegexLexer
+      title 'diff'
+      desc 'Lexes unified diffs or patches'
+
+      tag 'diff'
+      aliases 'patch', 'udiff'
+      filenames '*.diff', '*.patch'
+      mimetypes 'text/x-diff', 'text/x-patch'
+
+      def self.detect?(text)
+        return true if text.start_with?('Index: ')
+        return true if text =~ %r(\Adiff[^\n]*?\ba/[^\n]*\bb/)
+        return true if text =~ /(---|[+][+][+]).*?\n(---|[+][+][+])/
+      end
+
+      state :root do
+        rule(/^ .*$\n?/, Text)
+        rule(/^---$\n?/, Text)
+        rule(/^\+.*$\n?/, Generic::Inserted)
+        rule(/^-+.*$\n?/, Generic::Deleted)
+        rule(/^!.*$\n?/, Generic::Strong)
+        rule(/^@.*$\n?/, Generic::Subheading)
+        rule(/^([Ii]ndex|diff).*$\n?/, Generic::Heading)
+        rule(/^=.*$\n?/, Generic::Heading)
+        rule(/.*$\n?/, Text)
+      end
+    end
+  end
+end

data/lib/rouge/lexers/digdag.rb

@@ -0,0 +1,68 @@
+require 'set'
+module Rouge
+  module Lexers
+    load_lexer 'yaml.rb'
+
+    class Digdag < YAML
+      title 'digdag'
+      desc 'A simple, open source, multi-cloud workflow engine (https://www.digdag.io/)'
+      tag 'digdag'
+      filenames '*.dig'
+
+      mimetypes 'application/x-digdag'
+
+      # http://docs.digdag.io/operators.html
+      # as of digdag v0.9.10
+      KEYWORD_PATTERN = Regexp.union(%w(
+        call
+        require
+        loop
+        for_each
+        if
+        fail
+        echo
+
+        td
+        td_run
+        td_ddl
+        td_load
+        td_for_each
+        td_wait
+        td_wait_table
+        td_partial_delete
+        td_table_export
+
+        pg
+
+        mail
+        http
+        s3_wait
+        redshift
+        redshift_load
+        redshift_unload
+        emr
+
+        gcs_wait
+        bq
+        bq_ddl
+        bq_extract
+        bq_load
+
+        sh
+        py
+        rb
+        embulk
+      ).map { |name| "#{name}>"} + %w(
+        _do
+        _parallel
+      ))
+
+      prepend :block_nodes do
+        rule /(#{KEYWORD_PATTERN})(:)(?=\s|$)/ do |m|
+          groups Keyword::Reserved, Punctuation::Indicator
+          set_indent m[0], :implicit => true
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/docker.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Docker < RegexLexer
+      title "Docker"
+      desc "Dockerfile syntax"
+      tag 'docker'
+      aliases 'dockerfile'
+      filenames 'Dockerfile', '*.docker'
+      mimetypes 'text/x-dockerfile-config'
+
+      KEYWORDS = %w(
+        FROM MAINTAINER CMD LABEL EXPOSE ENV ADD COPY ENTRYPOINT VOLUME USER WORKDIR ARG STOPSIGNAL HEALTHCHECK SHELL
+      ).join('|')
+
+      start { @shell = Shell.new(@options) }
+
+      state :root do
+        rule /\s+/, Text
+
+        rule /^(ONBUILD)(\s+)(#{KEYWORDS})(.*)/io do |m|
+          groups Keyword, Text::Whitespace, Keyword, Str
+        end
+
+        rule /^(#{KEYWORDS})\b(.*)/io do |m|
+          groups Keyword, Str
+        end
+
+        rule /#.*?$/, Comment
+
+        rule /^(ONBUILD\s+)?RUN(\s+)/i do
+          token Keyword
+          push :run
+          @shell.reset!
+        end
+
+        rule /\w+/, Text
+        rule /[^\w]+/, Text
+        rule /./, Text
+      end
+
+      state :run do
+        rule /\n/, Text, :pop!
+        rule /\\./m, Str::Escape
+        rule(/(\\.|[^\n\\])+/) { delegate @shell }
+      end
+    end
+  end
+end

data/lib/rouge/lexers/dot.rb

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Dot < RegexLexer
+      title "DOT"
+      desc "graph description language"
+
+      tag 'dot'
+      filenames '*.dot'
+      mimetypes 'text/vnd.graphviz'
+
+      start do
+        @html = HTML.new(options)
+      end
+
+      state :comments_and_whitespace do
+        rule /\s+/, Text
+        rule %r(#.*?\n), Comment::Single
+        rule %r(//.*?\n), Comment::Single
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+      end
+
+      state :html do
+        rule /[^<>]+/ do
+          delegate @html
+        end
+        rule /<.+?>/m do
+          delegate @html
+        end
+        rule />/, Punctuation, :pop!
+      end
+
+      state :ID do
+        rule /([a-zA-Z][a-zA-Z_0-9]*)(\s*)(=)/ do |m|
+          token Name, m[1]
+          token Text, m[2]
+          token Punctuation, m[3]
+        end
+        rule /[a-zA-Z][a-zA-Z_0-9]*/, Name::Variable
+        rule /([0-9]+)?\.[0-9]+/, Num::Float
+        rule /[0-9]+/, Num::Integer
+        rule /"(\\"|[^"])*"/, Str::Double
+        rule /</ do
+          token Punctuation
+          @html.reset!
+          push :html
+        end
+      end
+
+      state :a_list do
+        mixin :comments_and_whitespace
+        mixin :ID
+        rule /[=;,]/, Punctuation
+        rule /\]/, Operator, :pop!
+      end
+
+      state :root do
+        mixin :comments_and_whitespace
+        rule /\b(strict|graph|digraph|subgraph|node|edge)\b/i, Keyword
+        rule /[{};:=]/, Punctuation
+        rule /-[->]/, Operator
+        rule /\[/, Operator, :a_list
+        mixin :ID
+      end
+    end
+  end
+end

data/lib/rouge/lexers/ecl.rb

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class ECL < RegexLexer
+      title "ECL"
+      desc "The ECL Programming Language (hpccsystems.com/about#Platform)"
+
+      tag 'ECL'
+      aliases 'ecl'
+
+      filenames '*.ecl'
+
+      mimetypes 'text/x-ecl', 'application/x-ecl'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          AND OR IN NOT ALL ANY AS FROM ATMOST BEFORE BEGINC BEST BETWEEN CASE CONST
+          COUNTER CSV DESCEND EMBED ENCRYPT END ENDC ENDEMBED ENDMACRO ENUM EXCEPT
+          EXCLUSIVE EXPIRE EXPORT EXTEND FAIL FEW FIRST FLAT FULL FUNCTION FUNCTIONMACRO
+          GROUP HEADING HOLE IFBLOCK IMPORT IN JOINED KEEP KEYED LAST LEFT LIMIT LOAD
+          LOCAL LOCALE LOOKUP MACRO MANY MAXCOUNT MAXLENGTH MIN SKEW MODULE INTERFACE
+          NAMED NOCASE NOROOT NOSCAN NOSORT OF ONLY OPT OUTER OVERWRITE PACKED
+          PARTITION PENALTY PHYSICALLENGTH PIPE QUOTE RECORD REPEAT RETURN RIGHT
+          ROWS SCAN SELF SEPARATOR SERVICE SHARED SKEW SKIP SQL STORE TERMINATOR
+          THOR THRESHOLD TOKEN TRANSFORM TRIM TYPE UNICODEORDER UNSORTED VALIDATE
+          VIRTUAL WHOLE WILD WITHIN XML XPATH AFTER CLUSTER COMPRESSED COMPRESSION
+          DEFAULT ENCODING ESCAPE FILEPOSITION FORWARD GROUPED INNER INTERNAL
+          LINKCOUNTED LITERAL LITTLE_ENDIAN LZW MOFN MULTIPLE NAMESPACE NOCASE
+          WNOTRIM NOXPATH ONFAIL OVERWRITE PREFETCH RETRY RIGHT1 RIGHT2 ROWSET
+          XPATH SCOPE SMART SOAPACTION STABLE TIMELIMIT TIMEOUT UNORDERED UNSTABLE
+          UPDATE USE WIDTH __COMPRESSED__
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          ABS ACOS AGGREGATE ALLNODES APPLY ASCII ASIN ASSTRING ATAN ATAN2 AVE CASE
+          CATCH CHOOSE CHOOSEN CHOOSESETS CLUSTERSIZE COMBINE CORRELATION COS COSH
+          COUNT COVARIANCE CRON DATASET DEDUP DEFINE DENORMALIZE DICTIONARY DISTRIBUTE
+          DISTRIBUTED DISTRIBUTION EBCDIC ENTH ERROR EVALUATE EVENT EVENTEXTRA EVENTNAME
+          EXISTS EXP FAILCODE FAILMESSAGE FETCH FROMUNICODE FROMXML GETENV GETISVALID GLOBAL
+          GRAPH GROUP HASH HASH32 HASH64 HASHCRC HASHMD5 HAVING HTTPCALL HTTPHEADER IF IFF
+          INDEX INTFORMAT ISVALID ITERATE JOIN KEYUNICODE LENGTH LIBRARY LIMIT LN LOCAL LOG
+          LOOP MAP MATCHED MATCHLENGTH MATCHPOSITION MATCHTEXT MATCHUNICODE MAX MERGE MERGEJOIN
+          MIN NOFOLD NOLOCAL NONEMPTY NORMALIZE PARSE PIPE POWER PRELOAD PROCESS PROJECT PULL RANDOM
+          RANGE RANK RANKED REALFORMAT RECORDOF REGEXFIND REGEXREPLACE REGROUP REJECTED ROLLUP ROUND
+          ROUNDUP ROW ROWDIFF SAMPLE SET SIN SINH SIZEOF SOAPCALL SORT SORTED SQRT STEPPED STORED
+          SUM TABLE TAN TANH THISNODE TOPN TOUNICODE TOXML TRANSFER TRANSFORM TRIM TRUNCATE TYPEOF
+          UNGROUP UNICODEORDER VARIANCE WHICH WORKUNIT XMLDECODE XMLENCODE XMLTEXT XMLUNICODE
+        )
+      end
+
+      def self.actions
+        @actions ||= Set.new %w(
+          APPLY ASSERT BUILD BUILDINDEX EVALUATE FAIL KEYDIFF KEYPATCH LOADXML NOTHOR NOTIFY OUTPUT
+          PARALLEL SEQUENTIAL SOAPCALL WAIT
+        )
+      end
+
+      def self.template
+        @template ||= Set.new %w(
+          APPEND BREAK DECLARE DEMANGLE END FOR GETDATATYPE IF INMODULE LOOP MANGLE ONWARNING OPTION
+          SET STORED UNIQUENAME WORKUNIT
+        )
+      end
+
+      state :root do
+        rule /\s+/m, Text
+        rule %r(//(\\.|.)*?$), Comment::Single
+        rule %r(/\*), Comment::Multiline, :multiline_comments
+        rule /\d+/, Num::Integer
+        rule /\b(?i:(abs|acos|aggregate|allnodes|apply|ascii|asin|asstring|atan|atan2|ave|case|catch|choose|choosen|choosesets|clustersize|combine|correlation|cos|cosh|count|covariance|cron|dataset|dedup|define|denormalize|dictionary|distribute|distributed|distribution|ebcdic|enth|error|evaluate|event|eventextra|eventname|exists|exp|failcode|failmessage|fetch|fromunicode|fromxml|getenv|getisvalid|global|graph|group|hash|hash32|hash64|hashcrc|hashmd5|having|httpcall|httpheader|if|iff|index|intformat|isvalid|iterate|join|keyunicode|length|library|limit|ln|local|log|loop|map|matched|matchlength|matchposition|matchtext|matchunicode|max|merge|mergejoin|min|nofold|nolocal|nonempty|normalize|parse|pipe|power|preload|process|project|pull|random|range|rank|ranked|realformat|recordof|regexfind|regexreplace|regroup|rejected|rollup|round|roundup|row|rowdiff|sample|set|sin|sinh|sizeof|soapcall|sort|sorted|sqrt|stepped|stored|sum|table|tan|tanh|thisnode|topn|tounicode|toxml|transfer|transform|trim|truncate|typeof|ungroup|unicodeorder|variance|which|workunit|xmldecode|xmlencode|xmltext|xmlunicode))\b/, Operator
+        rule /\b(?i:(data|string|qstring|varstring|varunicode|unicode))\d+\b/, Keyword::Type
+        rule /\b(?i:(integer|unsigned))[1-8]\b/, Keyword::Type
+        rule /\b(?i:(ascii|big_endian|boolean|data|decimal|ebcdic|grouped|integer|linkcounted|pattern|qstring|real|record|rule|set of|streamed|string|token|udecimal|unicode|unsigned|varstring|varunicode))\b/, Keyword::Type
+        rule /\b(?i)(u?)decimal(\d+(_\d+)?)\b/, Keyword::Type
+        rule /\b(?i:(apply|assert|build|buildindex|evaluate|fail|keydiff|keypatch|loadxml|nothor|notify|output|parallel|sequential|soapcall|wait))\b/, Operator
+        
+        rule /'/, Str::Single, :single_string
+        rule /"/, Name::Variable, :double_string
+        rule /`/, Name::Variable, :backtick
+
+        rule /(#)(?i)(\w+)/, Operator
+
+        rule /([A-Za-z_]+)\s*(\()/ do |m|
+          if !(self.class.keywords.include? m[1].upcase or self.class.builtins.include? m[1].upcase)
+            token Name::Function
+          end
+          if self.class.keywords.include? m[1].upcase
+            token Keyword
+          end
+          if self.class.builtins.include? m[1].upcase
+            token Operator
+          end
+        end
+        rule /[\$\w][\w\d]*/ do |m|
+          if self.class.keywords.include? m[0].upcase
+            token Keyword
+          else
+            token Name
+          end
+        end
+        
+        rule %r([+*/<>=~!@#%^&|?^-]), Operator
+        rule /[;:()\[\],.]/, Punctuation
+      end
+
+      state :multiline_comments do
+        rule %r(/[*]), Comment::Multiline, :multiline_comments
+        rule %r([*]/), Comment::Multiline, :pop!
+        rule %r([^/*]+), Comment::Multiline
+        rule %r([/*]), Comment::Multiline
+      end
+
+      state :backtick do
+        rule /\\./, Str::Escape
+        rule /``/, Str::Escape
+        rule /`/, Name::Variable, :pop!
+        rule /[^\\`]+/, Name::Variable
+      end
+
+      state :single_string do
+        rule /\\./, Str::Escape
+        rule /''/, Str::Escape
+        rule /'/, Str::Single, :pop!
+        rule /[^\\']+/, Str::Single
+      end
+
+      state :double_string do
+        rule /\\./, Str::Escape
+        rule /""/, Str::Escape
+        rule /"/, Name::Variable, :pop!
+        rule /[^\\"]+/, Name::Variable
+      end
+    end
+  end
+end

data/lib/rouge/lexers/eiffel.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Eiffel < RegexLexer
+      title "Eiffel"
+      desc "Eiffel programming language"
+
+      tag 'eiffel'
+      filenames '*.e'
+      mimetypes 'text/x-eiffel'
+
+      LanguageKeywords = %w(
+        across agent alias all and attached as assign attribute check
+        class convert create debug deferred detachable do else elseif end
+        ensure expanded export external feature from frozen if implies  inherit
+        inspect invariant like local loop not note obsolete old once or
+        Precursor redefine rename require rescue retry select separate
+        some then undefine until variant Void when xor
+      )
+
+      BooleanConstants = %w(True False)
+
+      LanguageVariables = %w(Current Result)
+
+      SimpleString = /(?:[^"%\b\f\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)+?/
+
+      state :root do
+        rule /"\[/, Str::Other, :aligned_verbatim_string
+        rule /"\{/, Str::Other, :non_aligned_verbatim_string
+        rule /"(?:[^%\b\f\n\r\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)*?"/, Str::Double
+        rule /--.*/, Comment::Single
+        rule /'(?:[^%\b\f\n\r\t\v]|%[A-DFHLNQR-V%'"()<>]|%\/(?:0[xX][\da-fA-F](?:_*[\da-fA-F])*|0[cC][0-7](?:_*[0-7])*|0[bB][01](?:_*[01])*|\d(?:_*\d)*)\/)'/, Str::Char
+
+        rule /(?:#{LanguageKeywords.join('|')})\b/, Keyword
+        rule /(?:#{LanguageVariables.join('|')})\b/, Keyword::Variable
+        rule /(?:#{BooleanConstants.join('|')})\b/, Keyword::Constant
+
+        rule  /\b0[xX][\da-fA-F](?:_*[\da-fA-F])*b/, Num::Hex
+        rule /\b0[cC][0-7](?:_*[0-7])*\b/, Num::Oct
+        rule /\b0[bB][01](?:_*[01])*\b/, Num::Bin
+        rule /\d(?:_*\d)*/, Num::Integer
+        rule /(?:\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?[eE][+-]?)?\d(?:_*\d)*|\d(?:_*\d)*\.?/, Num::Float
+
+        rule /:=|<<|>>|\(\||\|\)|->|\.|[{}\[\];(),:?]/, Punctuation::Indicator
+        rule /\\\\|\|\.\.\||\.\.|\/[~\/]?|[><\/]=?|[-+*^=~]/, Operator
+
+        rule /[A-Z][\dA-Z_]*/, Name::Class
+        rule /[A-Za-z][\dA-Za-z_]*/, Name
+        rule /\s+/, Text
+      end
+
+      state :aligned_verbatim_string do
+        rule /]"/, Str::Other, :pop!
+        rule SimpleString, Str::Other
+      end
+
+      state :non_aligned_verbatim_string do
+        rule /}"/, Str::Other, :pop!
+        rule SimpleString, Str::Other
+      end
+    end
+  end
+end
+

data/lib/rouge/lexers/elixir.rb

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    # Direct port of pygments Lexer.
+    # See: https://bitbucket.org/birkenfeld/pygments-main/src/7304e4759ae65343d89a51359ca538912519cc31/pygments/lexers/functional.py?at=default#cl-2362
+    class Elixir < RegexLexer
+      title "Elixir"
+      desc "Elixir language (elixir-lang.org)"
+
+      tag 'elixir'
+      aliases 'elixir', 'exs'
+
+      filenames '*.ex', '*.exs'
+
+      mimetypes 'text/x-elixir', 'application/x-elixir'
+
+      state :root do
+        rule /\s+/m, Text
+        rule /#.*$/, Comment::Single
+        rule %r{\b(case|cond|end|bc|lc|if|unless|try|loop|receive|fn|defmodule|
+             defp?|defprotocol|defimpl|defrecord|defmacrop?|defdelegate|
+             defexception|exit|raise|throw|after|rescue|catch|else)\b(?![?!])|
+             (?<!\.)\b(do|\-\>)\b}x, Keyword
+        rule /\b(import|require|use|recur|quote|unquote|super|refer)\b(?![?!])/, Keyword::Namespace
+        rule /(?<!\.)\b(and|not|or|when|xor|in)\b/, Operator::Word
+        rule %r{%=|\*=|\*\*=|\+=|\-=|\^=|\|\|=|
+             <=>|<(?!<|=)|>(?!<|=|>)|<=|>=|===|==|=~|!=|!~|(?=[\s\t])\?|
+             (?<=[\s\t])!+|&(&&?|(?!\d))|\|\||\^|\*|\+|\-|/|
+             \||\+\+|\-\-|\*\*|\/\/|\<\-|\<\>|<<|>>|=|\.|~~~}x, Operator
+        rule %r{(?<!:)(:)([a-zA-Z_]\w*([?!]|=(?![>=]))?|\<\>|===?|>=?|<=?|
+             <=>|&&?|%\(\)|%\[\]|%\{\}|\+\+?|\-\-?|\|\|?|\!|//|[%&`/\|]|
+             \*\*?|=?~|<\-)|([a-zA-Z_]\w*([?!])?)(:)(?!:)}, Str::Symbol
+        rule /:"/, Str::Symbol, :interpoling_symbol
+        rule /\b(nil|true|false)\b(?![?!])|\b[A-Z]\w*\b/, Name::Constant
+        rule /\b(__(FILE|LINE|MODULE|MAIN|FUNCTION)__)\b(?![?!])/, Name::Builtin::Pseudo
+        rule /[a-zA-Z_!][\w_]*[!\?]?/, Name
+        rule %r{::|[%(){};,/\|:\\\[\]]}, Punctuation
+        rule /@[a-zA-Z_]\w*|&\d/, Name::Variable
+        rule %r{\b(0[xX][0-9A-Fa-f]+|\d(_?\d)*(\.(?![^\d\s])
+             (_?\d)*)?([eE][-+]?\d(_?\d)*)?|0[bB][01]+)\b}x, Num
+
+        mixin :strings
+        mixin :sigil_strings
+      end
+
+      state :strings do
+        rule /(%[A-Ba-z])?"""(?:.|\n)*?"""/, Str::Doc
+        rule /'''(?:.|\n)*?'''/, Str::Doc
+        rule /"/, Str::Doc, :dqs
+        rule /'.*?'/, Str::Single
+        rule %r{(?<!\w)\?(\\(x\d{1,2}|\h{1,2}(?!\h)\b|0[0-7]{0,2}(?![0-7])\b[^x0MC])|(\\[MC]-)+\w|[^\s\\])}, Str::Other
+
+      end
+
+      state :dqs do
+        rule /"/, Str::Double, :pop!
+        mixin :enddoublestr
+      end
+
+      state :interpoling do
+        rule /#\{/, Str::Interpol, :interpoling_string
+      end
+
+      state :interpoling_string do
+        rule /\}/, Str::Interpol, :pop!
+        mixin :root
+      end
+
+      state :interpoling_symbol do
+        rule /"/, Str::Symbol, :pop!
+        mixin :interpoling
+        rule /[^#"]+/, Str::Symbol
+      end
+
+      state :enddoublestr do
+        mixin :interpoling
+        rule /[^#"]+/, Str::Double
+      end
+
+      state :sigil_strings do
+        # ~-sigiled strings
+        # ~(abc), ~[abc], ~<abc>, ~|abc|, ~r/abc/, etc
+        # Cribbed and adjusted from Ruby lexer
+        delimiter_map = { '{' => '}', '[' => ']', '(' => ')', '<' => '>' }
+        # Match a-z for custom sigils too
+        sigil_opens = Regexp.union(delimiter_map.keys + %w(| / ' "))
+        rule /~([A-Za-z])?(#{sigil_opens})/ do |m|
+          open = Regexp.escape(m[2])
+          close = Regexp.escape(delimiter_map[m[2]] || m[2])
+          interp = /[SRCW]/ === m[1]
+          toktype = Str::Other
+
+          puts "    open: #{open.inspect}" if @debug
+          puts "    close: #{close.inspect}" if @debug
+
+          # regexes
+          if 'Rr'.include? m[1]
+            toktype = Str::Regex
+            push :regex_flags
+          end
+
+          if 'Ww'.include? m[1]
+            push :list_flags
+          end
+
+          token toktype
+
+          push do
+            rule /#{close}/, toktype, :pop!
+
+            if interp
+              mixin :interpoling
+              rule /#/, toktype
+            else
+              rule /[\\#]/, toktype
+            end
+
+            rule /[^##{open}#{close}\\]+/m, toktype
+          end
+        end
+      end
+
+      state :regex_flags do
+        rule /[fgimrsux]*/, Str::Regex, :pop!
+      end
+
+      state :list_flags do
+        rule /[csa]?/, Str::Other, :pop!
+      end
+    end
+  end
+end