rouge 4.6.1 → 5.0.0

data/lib/rouge/lexers/brightscript.rb

@@ -64,19 +64,18 @@ module Rouge
         @builtins ||= Set.new %w(
           roAppendFile roAppInfo roAppManager roArray roAssociativeArray
           roAudioGuide roAudioMetadata roAudioPlayer roAudioPlayerEvent
-          roAudioResourceroBitmap roBoolean roBoolean roBrightPackage roBrSub
+          roAudioResourceroBitmap roBoolean roBrightPackage roBrSub
           roButton roByteArray roCaptionRenderer roCaptionRendererEvent
           roCecInterface roCECStatusEvent roChannelStore roChannelStoreEvent
           roClockWidget roCodeRegistrationScreen
-          roCodeRegistrationScreenEventroCompositor roControlDown roControlPort
-          roControlPort roControlUp roCreateFile roDatagramReceiver
+          roCodeRegistrationScreenEventroCompositor roControlDown roControlPort roControlUp roCreateFile roDatagramReceiver
           roDatagramSender roDataGramSocket roDateTime roDeviceInfo
           roDeviceInfoEvent roDoubleroEVPCipher roEVPDigest roFileSystem
           roFileSystemEvent roFloat roFont roFontMetrics roFontRegistry
           roFunction roGlobal roGpio roGridScreen roGridScreenEvent
           roHdmiHotPlugEventroHdmiStatus roHdmiStatusEvent roHMAC roHttpAgent
           roImageCanvas roImageCanvasEvent roImageMetadata roImagePlayer
-          roImageWidgetroInput roInputEvent roInt roInt roInvalid roInvalid
+          roImageWidgetroInput roInputEvent roInt roInvalid
           roIRRemote roKeyboard roKeyboardPress roKeyboardScreen
           roKeyboardScreenEventroList roListScreen roListScreenEvent
           roLocalization roLongInteger roMessageDialog roMessageDialogEvent

data/lib/rouge/lexers/c.rb

@@ -17,9 +17,10 @@ module Rouge
 
       def self.keywords
         @keywords ||= Set.new %w(
-          auto break case const continue default do else enum extern
-          for goto if register restricted return sizeof static struct
-          switch typedef union volatile virtual while
+          alignas alignof auto break case const constexpr continue
+          default do else enum extern for goto if register return
+          sizeof static static_assert struct switch typedef typeof
+          typeof_unqual union volatile while
 
           _Alignas _Alignof _Atomic _Generic _Imaginary
           _Noreturn _Static_assert _Thread_local
@@ -44,6 +45,8 @@ module Rouge
           uintmax_t
 
           char16_t char32_t
+
+          _BitInt _Decimal128 _Decimal32 _Decimal64 bool nullptr_t
         )
       end
 
@@ -52,7 +55,8 @@ module Rouge
           __asm __int8 __based __except __int16 __stdcall __cdecl
           __fastcall __int32 __declspec __finally __int61 __try __leave
           inline _inline __inline naked _naked __naked restrict _restrict
-          __restrict thread _thread __thread typename _typename __typename
+          __restrict thread _thread __thread thread_local
+          typename _typename __typename
         )
       end
 
@@ -108,7 +112,7 @@ module Rouge
         rule %r([~!%^&*+=\|?:<>/-]), Operator
         rule %r/[()\[\],.;]/, Punctuation
         rule %r/\bcase\b/, Keyword, :case
-        rule %r/(?:true|false|NULL)\b/, Name::Builtin
+        rule %r/(?:true|false|NULL|nullptr)\b/, Name::Builtin
         rule id do |m|
           name = m[0]
 

data/lib/rouge/lexers/cobol.rb

@@ -7,7 +7,7 @@ module Rouge
       title 'COBOL'
       desc 'COBOL (Common Business-Oriented Language) programming language'
       tag 'cobol'
-      filenames '*.cob', '*.cbl'
+      filenames '*.cob', '*.cbl', '*.cpy', '*.cpb'
       mimetypes 'text/x-cobol'
 
       identifier = /\p{Alpha}[\p{Alnum}-]*/

data/lib/rouge/lexers/console.rb

@@ -75,7 +75,7 @@ module Rouge
 
       def end_chars
         @end_chars ||= if @prompt.any?
-          @prompt.reject { |c| c.empty? }
+          @prompt.reject { |c| c.empty? }.uniq.first(20)
         elsif allow_comments?
           %w($ > ;)
         else
@@ -85,7 +85,9 @@ module Rouge
 
       def error_regex
         @error_regex ||= if @error.any?
-          /^(?:#{@error.map(&Regexp.method(:escape)).join('|')})/
+          #rubocop:disable Rouge/NoBuildingAlternationPatternInRegexp
+          /^(?:#{@error.first(20).map { |e| Regexp.escape(e) }.join('|')})/
+          #rubocop:enable Rouge/NoBuildingAlternationPatternInRegexp
         end
       end
 
@@ -144,7 +146,7 @@ module Rouge
           yield Text::Whitespace, $& unless $&.empty?
 
           lang_lexer.continue_lex($', &output)
-        elsif comment_regex =~ input[0].strip
+        elsif allow_comments? && comment_regex =~ input[0].strip
           puts "console: matched comment #{input[0].inspect}" if @debug
           output_lexer.reset!
           lang_lexer.reset!
@@ -173,13 +175,17 @@ module Rouge
       end
 
       def prompt_regex
+        # [jneen] these characters can come from user input. They are escaped here,
+        # and we limit the user to 20.
+        #rubocop:disable Rouge/NoBuildingAlternationPatternInRegexp
         @prompt_regex ||= begin
-          /^#{prompt_prefix_regex}(?:#{end_chars.map(&Regexp.method(:escape)).join('|')})/
+          /^#{prompt_prefix_regex}(?:#{end_chars.map { |c| Regexp.escape(c) }.join('|')})/
         end
+        #rubocop:enable Rouge/NoBuildingAlternationPatternInRegexp
       end
 
       def stream_tokens(input, &output)
-        input = StringScanner.new(input)
+        input = StringScanner.new(input, fixed_anchor: true)
         lang_lexer.reset!
         output_lexer.reset!
 

data/lib/rouge/lexers/cpp.rb

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*- #
 # frozen_string_literal: true
 
+require_relative 'c'
+
 module Rouge
   module Lexers
-    load_lexer 'c.rb'
-
     class Cpp < C
       title "C++"
       desc "The C++ programming language"
@@ -22,21 +22,19 @@ module Rouge
 
       def self.keywords
         @keywords ||= super + Set.new(%w(
-          asm auto catch char8_t concept
-          consteval constexpr constinit const_cast co_await co_return co_yield
-          delete dynamic_cast explicit export friend
-          mutable namespace new operator private protected public
-          reinterpret_cast requires restrict size_of static_cast this throw throws
-          typeid typename using virtual final override import module
-
-          alignas alignof decltype noexcept static_assert
-          thread_local try
+          and and_eq asm bitand bitor catch compl concept consteval
+          constinit const_cast co_await co_return co_yield decltype
+          delete dynamic_cast explicit export final friend import
+          module mutable namespace new noexcept not not_eq operator or
+          or_eq override private protected public reinterpret_cast
+          requires size_of static_cast this throw throws try typeid
+          typename using virtual xor xor_eq
         ))
       end
 
       def self.keywords_type
         @keywords_type ||= super + Set.new(%w(
-          bool
+          char8_t
         ))
       end
 

data/lib/rouge/lexers/crystal.rb

@@ -80,7 +80,7 @@ module Rouge
         rule %r/\b[\p{Ll}_]\p{Word}*?[?!]?:\s+/, Str::Symbol, :expr_start
         rule %r/"/, Str::Double, :simple_string
         rule %r/(?<!\.)`/, Str::Backtick, :simple_backtick
-        rule %r/(')(\\u[a-fA-F0-9]{4}|\\u\{[a-fA-F0-9]{1,6}\}|\\[abefnrtv])?(\\\\|\\'|[^'])*(')/ do
+        rule %r/(')(\\u[a-fA-F0-9]{4}|\\u\{[a-fA-F0-9]{1,6}\}|\\[abefnrtv])?(\\\\|\\'|[^'\n])*(')/ do
           groups Str::Single, Str::Escape, Str::Single, Str::Single
         end
       end

data/lib/rouge/lexers/css.rb

@@ -13,7 +13,19 @@ module Rouge
 
       # Documentation: https://www.w3.org/TR/CSS21/syndata.html#characters
 
-      identifier = /[\p{L}_-][\p{Word}\p{Cf}-]*/
+      # [jneen] workaround for:
+      # https://bugs.ruby-lang.org/issues/21870#change-116371
+      #
+      # As of ruby 4+, \p{Word} matches ZWJ and ZWNJ, so the additional
+      # \p{Cf} is not needed.
+      #
+      # That being said... this still warns, but at least it's only once?
+      identifier = if RUBY_VERSION < '4'
+        /[\p{L}_-][\p{Word}\p{Cf}-]*/
+      else
+        /[\p{L}_-][\p{Word}-]*/
+      end
+
       number = /-?(?:[0-9]+(\.[0-9]+)?|\.[0-9]+)/
 
       def self.properties
@@ -126,7 +138,7 @@ module Rouge
           above absolute accumulate add additive all alpha alphabetic
           alternate alternate-reverse always armenian aural auto auto-fill
           auto-fit avoid backwards balance baseline behind below bidi-override
-          blink block bold bolder border-box both bottom bottom break-spaces
+          blink block bold bolder border-box both bottom break-spaces
           capitalize center center-left center-right circle cjk-ideographic
           close-quote closest-corner closest-side collapse
           color color-burn color-dodge column column-reverse
@@ -192,6 +204,7 @@ module Rouge
           seagreen seashell sienna silver skyblue slateblue slategray snow
           springgreen steelblue tan teal thistle tomato
           turquoise violet wheat white whitesmoke yellow yellowgreen
+          rebeccapurple
         )
       end
 
@@ -245,6 +258,10 @@ module Rouge
         rule %r/(true|false)/i, Name::Constant
         rule %r/\-\-#{identifier}/, Literal
         rule %r([*+/-]), Operator
+        rule %r/(url(?:-prefix)?)([(])(.*?)([)])/ do
+          groups Name::Function, Punctuation, Str::Other, Punctuation
+        end
+
         rule(identifier) do |m|
           if self.class.colors.include? m[0].downcase
             token Name::Other
@@ -304,6 +321,8 @@ module Rouge
 
           push :stanza_value
         end
+
+        mixin :root
       end
 
       state :stanza_value do

data/lib/rouge/lexers/cuda.rb

@@ -1,9 +1,9 @@
 # -*- coding: utf-8 -*- #
 
+require_relative 'cpp'
+
 module Rouge
   module Lexers
-    load_lexer 'cpp.rb'
-
     class CUDA < Cpp
       title "CUDA"
       desc "Compute Unified Device Architecture, used for programming with NVIDIA GPU"
@@ -24,8 +24,8 @@ module Rouge
           short1 short2 short3 short4 ushort1 ushort2 ushort3 ushort4
           int1 int2 int3 int4 uint1 uint2 uint3 uint4
           long1 long2 long3 long4 ulong1 ulong2 ulong3 ulong4
-          longlong1 longlong2 longlong3 longlong4 
-          ulonglong1 ulonglong2 ulonglong3 ulonglong4 
+          longlong1 longlong2 longlong3 longlong4
+          ulonglong1 ulonglong2 ulonglong3 ulonglong4
           float1 float2 float3 float4 double1 double2 double3 double4
           dim3
         ))

data/lib/rouge/lexers/cython.rb

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*- #
 # frozen_string_literal: true
 
+require_relative 'python'
+
 module Rouge
   module Lexers
-    load_lexer 'python.rb'
-
     class Cython < Python
       title "Cython"
       desc "Cython and Pyrex source code (cython.org)"
@@ -25,13 +25,20 @@ module Rouge
       end
 
       def self.c_keywords
-        @ckeywords ||= %w(
+        @c_keywords ||= Set.new %w(
           public readonly extern api inline enum union
         )
       end
 
+      def self.builtins
+        @builtins ||= super + %w(python_call)
+      end
+
       identifier = /[a-z_]\w*/i
-      dotted_identifier = /[a-z_.][\w.]*/i
+
+      prepend :from_import do
+        rule %r/cimport\b/, Keyword::Namespace, :pop!
+      end
 
       prepend :root do
         rule %r/cp?def|ctypedef/ do
@@ -40,54 +47,16 @@ module Rouge
           push :c_start
         end
 
-        rule %r/(from)((?:\\\s|\s)+)(#{dotted_identifier})((?:\\\s|\s)+)(cimport)/ do
-          groups Keyword::Namespace,
-                 Text,
-                 Name::Namespace,
-                 Text,
-                 Keyword::Namespace
-        end
-
-        rule %r/(cimport)(\s+)(#{dotted_identifier})/ do
-          groups Keyword::Namespace, Text, Name::Namespace
-        end
+        rule %r/cimport\b/, Keyword::Namespace, :import
 
         rule %r/(struct)((?:\\\s|\s)+)/ do
           groups Keyword, Text
           push :classname
         end
 
-        mixin :func_call_fix
-
         rule %r/[(,]/, Punctuation, :c_start
       end
 
-      prepend :classname do
-        rule %r/(?:\\\s|\s)+/, Text
-      end
-
-      prepend :funcname do
-        rule %r/(?:\\\s|\s)+/, Text
-      end
-      # This is a fix for the way that function calls are lexed in the Python
-      # lexer. This should be moved to the Python lexer once confirmed that it
-      # does not cause any regressions.
-      state :func_call_fix do
-        rule %r/#{identifier}(?=\()/ do |m|
-          if self.class.keywords.include? m[0]
-            token Keyword
-          elsif self.class.exceptions.include? m[0]
-            token Name::Builtin
-          elsif self.class.builtins.include? m[0]
-            token Name::Builtin
-          elsif self.class.builtins_pseudo.include? m[0]
-            token Name::Builtin::Pseudo
-          else
-            token Name::Function
-          end
-        end
-      end
-
       # The Cython lexer adds three states to those already in the Python lexer.
       # Calls to `cdef`, `cpdef` and `ctypedef` move the lexer into the :c_start
       # state. The primary purpose of this state is to highlight datatypes. Once
@@ -97,7 +66,7 @@ module Rouge
       # have moved out of a C block.
 
       state :c_start do
-        rule %r/[^\S\n]+/, Text
+        mixin :inline_whitespace
 
         rule %r/cp?def|ctypedef/, Keyword
 
@@ -106,16 +75,16 @@ module Rouge
         # This rule matches identifiers that could be type declarations. The
         # lookahead matches (1) pointers, (2) arrays and (3) variable names.
         rule %r/#{identifier}(?=(?:\*+)|(?:[ \t]*\[)|(?:[ \t]+\w))/ do |m|
-          if self.class.keywords.include? m[0]
+          if self.class.keywords.include?(m[0])
             token Keyword
             pop!
-          elsif %w(def).include? m[0]
+          elsif m[0] == 'def'
             token Keyword
             goto :funcname
-          elsif %w(struct class).include? m[0]
-            token Keyword::Reserved
+          elsif %w(struct class).include?(m[0])
+            token Keyword
             goto :classname
-          elsif self.class.c_keywords.include? m[0]
+          elsif self.class.c_keywords.include?(m[0])
             token Keyword::Reserved
           else
             token Keyword::Type
@@ -144,7 +113,14 @@ module Rouge
           end
         end
 
-        rule(//) { @indentation = nil; reset_stack }
+        rule(//) do
+          @indentation = nil
+          # pop c_indent
+          pop!
+
+          # replace :c_definitions with :newline
+          goto :newline
+        end
       end
     end
   end

data/lib/rouge/lexers/dafny.rb

@@ -58,7 +58,7 @@ module Rouge
       schar = /(?:[^\\"\n\r]|\\["'ntr\\0])/
       uchar = /(?:\\u#{hex_digit}{4})/
 
-      ## IMPORTANT: Rules are ordered, which allows later rules to be 
+      ## IMPORTANT: Rules are ordered, which allows later rules to be
       ## simpler than they would otherwise be
       state :root do
         rule %r(/\*), Comment::Multiline, :comment

data/lib/rouge/lexers/dart.rb

@@ -45,6 +45,8 @@ module Rouge
         rule %r(/\*.*?\*/)m, Comment::Multiline
         rule %r/"/, Str, :dqs
         rule %r/'/, Str, :sqs
+        rule %r/r""".*?"""/m, Str::Other
+        rule %r/r'''.*?'''/m, Str::Other
         rule %r/r"[^"]*"/, Str::Other
         rule %r/r'[^']*'/, Str::Other
         rule %r/##{id}*/i, Str::Symbol

data/lib/rouge/lexers/datastudio.rb

@@ -124,7 +124,7 @@ module Rouge
         rule %r/#{id}(?=\s*[(])/, Name::Function
         rule id do |m|
           name = m[0].upcase
-          
+
           if self.class.sql_keywords.include? name
             token Keyword
           else

data/lib/rouge/lexers/digdag.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-require 'set'
+require_relative 'yaml'
+
 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/)'

data/lib/rouge/lexers/dylan.rb

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Dylan < RegexLexer
+      title 'Dylan'
+      desc 'Dylan Language (https://opendylan.org)'
+      tag 'dylan'
+      filenames '*.dylan'
+
+      # Definitions from the Dylan Reference Manual
+      # see:
+      # https://opendylan.org/books/drm/Modules
+      # https://opendylan.org/books/drm/Conditional_Execution
+      # https://opendylan.org/books/drm/Statement_Macros
+      reserved_words = Set.new %w(
+        begin block case class constant create define domain else
+        end exception for function generic handler if let library local
+        macro method module otherwise select unless until variable while
+      )
+
+      hash_word = Set.new %w(#t #f #next #rest #key #all-keys #include)
+      operators = Set.new %w(+ - * / ^ = == ~ ~= ~== < <= > >= & | :=)
+
+      state :root do
+        rule %r/^[\w.-]+:/, Comment::Preproc, :header
+        rule %r/\s+/, Text::Whitespace
+        rule(%r//) { goto :main }
+      end
+
+      # see https://opendylan.org/books/drm/Dylan_Interchange_Format
+      state :header do
+        rule(/.*?$/) { token Comment; goto :header_value }
+      end
+
+      state :header_value do
+        # line continuations are defined as any line that starts with whitespace
+        rule %r/^[ \t]+.*?$/, Comment
+        rule %r/\n+/, Comment
+        rule(//) { pop! }
+      end
+
+      state :main do
+        # Comments
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        rule %r/\s+/, Text::Whitespace
+
+        # Keywords
+        rule %r/\w+/ do |m|
+          if reserved_words.include?(m[0])
+            token Keyword
+          elsif hash_word.include?(m[0])
+            token Keyword::Constant
+          else
+            fallthrough!
+          end
+        end
+
+        rule %r/#(t|f|next|rest|key|all-keys|include)\b/, Keyword::Constant
+
+        # Numbers
+        rule %r([+-]?\d+/\d+), Literal::Number::Other
+        rule %r/[+-]?\d*[.]\d+(?:e[+-]?\d+)?/i, Literal::Number::Float
+        rule %r/[+-]?\d+[.]\d*(?:e[+-]?\d+)?/i, Literal::Number::Float
+        rule %r/[+-]\d+(?:e[+-]?\d+)?/i, Literal::Number::Float
+        rule %r/#b[01]+/, Literal::Number::Bin
+        rule %r/#o[0-7]+/, Literal::Number::Oct
+        rule %r/[+-]?[0-9]+/, Literal::Number::Integer
+        rule %r/#x[0-9a-f]+/i, Literal::Number::Hex
+
+        # Operators and punctuation
+        rule %r/::|=>|#[(\[#]|[.][.][.]|[(),.;\[\]{}=?]/, Punctuation
+
+        word_re = %r([\w!&*<>|^\$%@][\w!&*<>|^\$%@=/?~+-]*|[+-~])
+
+        rule %r/\\#{word_re}/, Str::Symbol
+
+        rule word_re do |m|
+          word = m[0]
+          if operators.include?(word)
+            token Operator
+          elsif word.start_with?('<') && word.end_with?('>')
+            token Name::Class
+          elsif word.start_with?('*') && word.end_with?('*')
+            token Name::Variable::Instance
+          elsif word.start_with?('$')
+            token Name::Constant
+          else
+            token Name
+          end
+        end
+
+        rule %r/:/, Operator # For 'constrained names'
+        # Strings, characters and whitespace
+        rule %r/"/, Str::Double, :dq
+        rule %r/'([^\\']|(\\[\\'abefnrt0])|(\\[0-9a-f]+))'/, Str::Char
+      end
+
+      state :dq do
+        rule %r/\\[\\'"abefnrt0]/, Str::Escape
+        rule %r/\\<\h+>/, Str::Escape
+        rule %r/[^\\"]+/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/ecl.rb

@@ -42,9 +42,9 @@ module Rouge
           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 apply assert
-          build buildindex evaluate fail keydiff keypatch loadxml nothor notify
-          output parallel sequential soapcall wait
+          which workunit xmldecode xmlencode xmltext xmlunicode assert
+          build buildindex fail keydiff keypatch loadxml nothor notify
+          output parallel sequential wait
         )
       end
 

data/lib/rouge/lexers/elixir.rb

@@ -99,43 +99,48 @@ module Rouge
 
       state :sigil_strings do
         # ~-sigiled strings
-        # ~(abc), ~[abc], ~<abc>, ~|abc|, ~r/abc/, etc
+        # ~r(abc), ~r[abc], ~r<abc>, ~r|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 %r/~([A-Za-z])?(#{sigil_opens})/ do |m|
+        sigil_opens = Regexp.union(delimiter_map.keys + [%r/"{3}/] + %w(| / ' "))
+        rule %r/~([a-z]|[A-Z][A-Z0-9]*)(#{sigil_opens})/ do |m|
           open = Regexp.escape(m[2])
           close = Regexp.escape(delimiter_map[m[2]] || m[2])
-          interp = /[SRCW]/ === m[1]
+          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]
+          if m[1] == 'r' || m[1] == 'R'
             toktype = Str::Regex
             push :regex_flags
           end
 
-          if 'Ww'.include? m[1]
+          if m[1] == 'w' || m[1] == 'W'
             push :list_flags
           end
 
+          if open == '"""'
+            toktype = Str::Doc
+          end
+
           token toktype
 
           push do
             rule %r/#{close}/, toktype, :pop!
 
-            if interp
+            if toktype == Str::Doc
+              rule %r/(?:.|\n)*?"""/, toktype, :pop!
+            elsif interp
               mixin :interpoling
               rule %r/#/, toktype
             else
               rule %r/[\\#]/, toktype
             end
 
-            uniq_chars = [open, close].uniq.join
+            uniq_chars = [open, close].uniq.join.squeeze
             rule %r/[^##{uniq_chars}\\]+/m, toktype
           end
         end

data/lib/rouge/lexers/escape.rb

@@ -33,7 +33,7 @@ module Rouge
       end
 
       def stream_tokens(str, &b)
-        stream = StringScanner.new(str)
+        stream = StringScanner.new(str, fixed_anchor: true)
 
         loop do
           if stream.scan(to_start_regex)

data/lib/rouge/lexers/factor.rb

@@ -25,7 +25,7 @@ module Rouge
             do unless* if* loop bi-curry* drop when* assert= retainstack
             assert? -rot execute 2bi@ 2tri@ boa with either? 3drop bi
             curry?  datastack until 3dip over 3curry tri-curry* tri-curry@
-            swap and 2nip throw bi-curry (clone) hashcode* compose 2dip if
+            swap and 2nip throw bi-curry (clone) hashcode* compose 2dip
             3tri unless compose? tuple keep 2curry equal? assert tri 2drop
             most <wrapper> boolean? identity-hashcode identity-tuple?
             null new dip bi-curry@ rot xor identity-tuple boolean

data/lib/rouge/lexers/freefem.rb

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*- #
 # frozen_string_literal: true
 
+require_relative 'cpp'
+
 module Rouge
   module Lexers
-    load_lexer 'cpp.rb'
-
     class FreeFEM < Cpp
       title "FreeFEM"
       desc "The FreeFEM programming language (freefem.org)"

data/lib/rouge/lexers/ghc_cmm.rb

@@ -245,7 +245,7 @@ module Rouge
         #   `(type /* optional whitespace */ var_name /* optional whitespace */)`
         # Note: Only the token for type is produced here.
         rule %r{
-                (^#{id})
+                (#{id})
                 (#{ws}+)
                 (#{id})
               }mx do |m|