rouge 3.5.1 → 3.10.0

data/lib/rouge/lexers/apache.rb

@@ -50,7 +50,7 @@ module Rouge
 
       state :section do
         # Match section arguments
-        rule %r/([^>]+)?(>(?:\r\n?|\n)?)/ do |m|
+        rule %r/([^>]+)?(>(?:\r\n?|\n)?)/ do
           groups Literal::String::Regex, Punctuation
           pop!
         end

data/lib/rouge/lexers/armasm.rb

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class ArmAsm < RegexLexer
+      title "ArmAsm"
+      desc "Arm assembly syntax"
+      tag 'armasm'
+      filenames '*.s'
+
+      def self.preproc_keyword
+        @preproc_keyword ||= %w(
+          define elif else endif error if ifdef ifndef include line pragma undef warning
+        )
+      end
+
+      def self.file_directive
+        @file_directive ||= %w(
+          BIN GET INCBIN INCLUDE LNK
+        )
+      end
+
+      def self.general_directive
+        @general_directive ||= %w(
+          ALIAS ALIGN AOF AOUT AREA ARM ASSERT ATTR CN CODE16 CODE32 COMMON CP
+          DATA DCB DCD DCDO DCDU DCFD DCFDU DCFH DCFHU DCFS DCFSU DCI DCI.N DCI.W
+          DCQ DCQU DCW DCWU DN ELIF ELSE END ENDFUNC ENDIF ENDP ENTRY EQU EXPORT
+          EXPORTAS EXTERN FIELD FILL FN FRAME FUNCTION GBLA GBLL GBLS GLOBAL IF
+          IMPORT INFO KEEP LCLA LCLL LCLS LEADR LEAF LTORG MACRO MAP MEND MEXIT
+          NOFP OPT ORG PRESERVE8 PROC QN RELOC REQUIRE REQUIRE8 RLIST RN ROUT
+          SETA SETL SETS SN SPACE STRONG SUBT THUMB THUMBX TTL WEND WHILE
+          \[ \] [|!#*=%&^]
+        )
+      end
+
+      def self.shift_or_condition
+        @shift_or_condition ||= %w(
+          ASR LSL LSR ROR RRX AL CC CS EQ GE GT HI HS LE LO LS LT MI NE PL VC VS
+          asr lsl lsr ror rrx al cc cs eq ge gt hi hs le lo ls lt mi ne pl vc vs
+        )
+      end
+
+      def self.builtin
+        @builtin ||= %w(
+          ARCHITECTURE AREANAME ARMASM_VERSION CODESIZE COMMANDLINE CONFIG CPU
+          ENDIAN FALSE FPIC FPU INPUTFILE INTER LINENUM LINENUMUP LINENUMUPPER
+          OBJASM_VERSION OPT PC PCSTOREOFFSET REENTRANT ROPI RWPI TRUE VAR
+        )
+      end
+
+      def self.operator
+        @operator ||= %w(
+          AND BASE CC CC_ENCODING CHR DEF EOR FATTR FEXEC FLOAD FSIZE INDEX LAND
+          LEFT LEN LEOR LNOT LOR LOWERCASE MOD NOT OR RCONST REVERSE_CC RIGHT ROL
+          ROR SHL SHR STR TARGET_ARCH_[0-9A-Z_]+ TARGET_FEATURE_[0-9A-Z_]+
+          TARGET_FPU_[A-Z_] TARGET_PROFILE_[ARM] UAL UPPERCASE
+        )
+      end
+
+      state :root do
+        rule %r/\n/, Text
+        rule %r/^([ \t]*)(#[ \t]*(?:(?:#{ArmAsm.preproc_keyword.join('|')})(?:[ \t].*)?)?)(\n)/ do
+          groups Text, Comment::Preproc, Text
+        end
+        rule %r/[ \t]+/, Text, :command
+        rule %r/;.*/, Comment
+        rule %r/\$[a-z_]\w*\.?/i, Name::Namespace # variable substitution or macro argument
+        rule %r/\w+|\|[^|\n]+\|/, Name::Label
+      end
+
+      state :command do
+        rule %r/\n/, Text, :pop!
+        rule %r/[ \t]+/ do |m|
+          token Text
+          goto :args
+        end
+        rule %r/;.*/, Comment, :pop!
+        rule %r/(?:#{ArmAsm.file_directive.join('|')})\b/ do |m|
+          token Keyword
+          goto :filespec
+        end
+        rule %r/(?:#{ArmAsm.general_directive.join('|')})(?=[; \t\n])/, Keyword
+        rule %r/(?:[A-Z][\dA-Z]*|[a-z][\da-z]*)(?:\.[NWnw])?(?:\.[DFIPSUdfipsu]?(?:8|16|32|64)?){,3}\b/, Name::Builtin # rather than attempt to list all opcodes, rely on all-uppercase or all-lowercase rule
+        rule %r/[a-z_]\w*|\|[^|\n]+\|/i, Name::Function # probably a macro name
+        rule %r/\$[a-z]\w*\.?/i, Name::Namespace
+      end
+
+      state :args do
+        rule %r/\n/, Text, :pop!
+        rule %r/[ \t]+/, Text
+        rule %r/;.*/, Comment, :pop!
+        rule %r/(?:#{ArmAsm.shift_or_condition.join('|')})\b/, Name::Builtin
+        rule %r/[a-z_]\w*|\|[^|\n]+\|/i, Name::Variable # various types of symbol
+        rule %r/%[bf]?[at]?\d+(?:[a-z_]\w*)?/i, Name::Label
+        rule %r/(?:&|0x)\h+(?!p)/i, Literal::Number::Hex
+        rule %r/(?:&|0x)[.\h]+(?:p[-+]?\d+)?/i, Literal::Number::Float
+        rule %r/0f_\h{8}|0d_\h{16}/i, Literal::Number::Float
+        rule %r/(?:2_[01]+|3_[0-2]+|4_[0-3]+|5_[0-4]+|6_[0-5]+|7_[0-6]+|8_[0-7]+|9_[0-8]+|\d+)(?!e)/i, Literal::Number::Integer
+        rule %r/(?:2_[.01]+|3_[.0-2]+|4_[.0-3]+|5_[.0-4]+|6_[.0-5]+|7_[.0-6]+|8_[.0-7]+|9_[.0-8]+|[.\d]+)(?:e[-+]?\d+)?/i, Literal::Number::Float
+        rule %r/[@:](?=[ \t]*(?:8|16|32|64|128|256)[^\d])/, Operator
+        rule %r/[.@]|\{(?:#{ArmAsm.builtin.join('|')})\}/, Name::Constant
+        rule %r/[-!#%&()*+,\/<=>?^{|}]|\[|\]|!=|&&|\/=|<<|<=|<>|==|><|>=|>>|\|\||:(?:#{ArmAsm.operator.join('|')}):/, Operator
+        rule %r/\$[a-z]\w*\.?/i, Name::Namespace
+        rule %r/'/ do |m|
+          token Literal::String::Char
+          goto :singlequoted
+        end
+        rule %r/"/ do |m|
+          token Literal::String::Double
+          goto :doublequoted
+        end
+      end
+
+      state :singlequoted do
+        rule %r/\n/, Text, :pop!
+        rule %r/\$\$/, Literal::String::Char
+        rule %r/\$[a-z]\w*\.?/i, Name::Namespace
+        rule %r/'/ do |m|
+          token Literal::String::Char
+          goto :args
+        end
+        rule %r/[^$'\n]+/, Literal::String::Char
+      end
+
+      state :doublequoted do
+        rule %r/\n/, Text, :pop!
+        rule %r/\$\$/, Literal::String::Double
+        rule %r/\$[a-z]\w*\.?/i, Name::Namespace
+        rule %r/"/ do |m|
+          token Literal::String::Double
+          goto :args
+        end
+        rule %r/[^$"\n]+/, Literal::String::Double
+      end
+
+      state :filespec do
+        rule %r/\n/, Text, :pop!
+        rule %r/\$\$/, Literal::String::Other
+        rule %r/\$[a-z]\w*\.?/i, Name::Namespace
+        rule %r/[^$\n]+/, Literal::String::Other
+      end
+    end
+  end
+end

data/lib/rouge/lexers/batchfile.rb

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Batchfile < RegexLexer
+      title "Batchfile"
+      desc "Windows Batch File"
+
+      tag 'batchfile'
+      aliases 'bat', 'batch', 'dosbatch', 'winbatch'
+      filenames '*.bat', '*.cmd'
+
+      mimetypes 'application/bat', 'application/x-bat', 'application/x-msdos-program'
+
+      def self.keywords
+        @keywords ||= %w(
+          if else for in do goto call exit
+        )
+      end
+
+      def self.operator_words
+        @operator_words ||= %w(
+          exist defined errorlevel cmdextversion not equ neq lss leq gtr geq
+        )
+      end
+
+      def self.devices
+        @devices ||= %w(
+          con prn aux nul com1 com2 com3 com4 com5 com6 com7 com8 com9 lpt1 lpt2
+          lpt3 lpt4 lpt5 lpt6 lpt7 lpt8 lpt9
+        )
+      end
+
+      def self.builtin_commands
+        @builtin_commands ||= %w(
+          assoc attrib break bcdedit cacls cd chcp chdir chkdsk chkntfs choice
+          cls cmd color comp compact convert copy date del dir diskpart doskey
+          dpath driverquery echo endlocal erase fc find findstr format fsutil
+          ftype gpresult graftabl help icacls label md mkdir mklink mode more
+          move openfiles path pause popd print prompt pushd rd recover ren
+          rename replace rmdir robocopy setlocal sc schtasks shift shutdown sort
+          start subst systeminfo takeown tasklist taskkill time timeout title
+          tree type ver verify vol xcopy waitfor wmic
+        )
+      end
+
+      def self.other_commands
+        @other_commands ||= %w(
+          addusers admodcmd ansicon arp at bcdboot bitsadmin browstat certreq
+          certutil change cidiag cipher cleanmgr clip cmdkey compress convertcp
+          coreinfo csccmd csvde cscript curl debug defrag delprof deltree devcon
+          diamond dirquota diruse diskshadow diskuse dism dnscmd dsacls dsadd
+          dsget dsquery dsmod dsmove dsrm dsmgmt dsregcmd edlin eventcreate
+          expand extract fdisk fltmc forfiles freedisk ftp getmac gpupdate
+          hostname ifmember inuse ipconfig kill lgpo lodctr logman logoff
+          logtime makecab mapisend mbsacli mem mountvol moveuser msg mshta
+          msiexec msinfo32 mstsc nbtstat net net1 netdom netsh netstat nlsinfo
+          nltest now nslookup ntbackup ntdsutil ntoskrnl ntrights nvspbind
+          pathping perms ping portqry powercfg pngout pnputil printbrm prncnfg
+          prnmngr procdump psexec psfile psgetsid psinfo pskill pslist
+          psloggedon psloglist pspasswd psping psservice psshutdown pssuspend
+          qbasic qgrep qprocess query quser qwinsta rasdial reg reg1 regdump
+          regedt32 regsvr32 regini reset restore rundll32 rmtshare route rpcping
+          run runas scandisk setspn setx sfc share shellrunas shortcut sigcheck
+          sleep slmgr strings subinacl sysmon telnet tftp tlist touch tracerpt
+          tracert tscon tsdiscon tskill tttracer typeperf tzutil undelete
+          unformat verifier vmconnect vssadmin w32tm wbadmin wecutil wevtutil
+          wget where whoami windiff winrm winrs wpeutil wpr wusa wuauclt wscript
+        )
+      end
+
+      def self.attributes
+        @attributes ||= %w(
+          on off disable enableextensions enabledelayedexpansion
+        )
+      end
+
+      state :basic do
+        # Comments
+        rule %r/\brem\b.*$/i, Comment
+        # Empty Labels
+        rule %r/^::.*$/, Comment
+
+        # Labels
+        rule %r/:[a-z]+/i, Name::Label
+
+        rule %r/([a-z]\w*)(\.exe|com|bat|cmd|msi)?/i do |m|
+          if self.class.devices.include? m[1]
+            groups Keyword::Reserved, Error
+          elsif self.class.keywords.include? m[1]
+            groups Keyword, Error
+          elsif self.class.operator_words.include? m[1]
+            groups Operator::Word, Error
+          elsif self.class.builtin_commands.include? m[1]
+            token Name::Builtin
+          elsif self.class.other_commands.include? m[1]
+            token Name::Builtin
+          elsif self.class.attributes.include? m[1]
+            groups Name::Attribute, Error
+          elsif "set".casecmp m[1]
+            groups Keyword::Declaration, Error
+          else
+            token Text
+          end
+        end
+
+        rule %r/([\/\-+][a-z]+)\s*/i, Name::Attribute
+
+        mixin :expansions
+
+        rule %r/[<>&|(){}\[\]\-+=;,~?*]/, Operator
+      end
+
+      state :escape do
+        rule %r/\^./m, Str::Escape
+      end
+
+      state :expansions do
+        # Normal and Delayed expansion
+        rule %r/[%!]+([a-z_$@#]+)[%!]+/i, Name::Variable
+        # For Variables
+        rule %r/(\%+~?[a-z]+\d?)/i, Name::Variable::Magic
+      end
+
+      state :double_quotes do
+        mixin :escape
+        rule %r/["]/, Str::Double, :pop!
+        mixin :expansions
+        rule %r/[^\^"%!]+/, Str::Double
+      end
+
+      state :single_quotes do
+        mixin :escape
+        rule %r/[']/, Str::Single, :pop!
+        mixin :expansions
+        rule %r/[^\^'%!]+/, Str::Single
+      end
+
+      state :backtick do
+        mixin :escape
+        rule %r/[`]/, Str::Backtick, :pop!
+        mixin :expansions
+        rule %r/[^\^`%!]+/, Str::Backtick
+      end
+
+      state :data do
+        rule %r/\s+/, Text
+        rule %r/0x[0-9a-f]+/i, Literal::Number::Hex
+        rule %r/[0-9]/, Literal::Number
+        rule %r/["]/, Str::Double, :double_quotes
+        rule %r/[']/, Str::Single, :single_quotes
+        rule %r/[`]/, Str::Backtick, :backtick
+        rule %r/[^\s&|()\[\]{}\^=;!%+\-,"'`~?*]+/, Text
+        mixin :escape
+      end
+
+      state :root do
+        mixin :basic
+        mixin :data
+      end
+    end
+  end
+end

data/lib/rouge/lexers/bbcbasic.rb

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class BBCBASIC < RegexLexer
+      title "BBCBASIC"
+      desc "BBC BASIC syntax"
+      tag 'bbcbasic'
+      filenames '*,fd1'
+
+      def self.punctuation
+        @punctuation ||= %w(
+          [,;'~] SPC TAB
+        )
+      end
+
+      def self.function
+        @function ||= %w(
+          ABS ACS ADVAL ASC ASN ATN BEATS BEAT BGET# CHR\$ COS COUNT DEG DIM
+          EOF# ERL ERR EVAL EXP EXT# FN GET\$# GET\$ GET HIMEM INKEY\$ INKEY
+          INSTR INT LEFT\$ LEN LN LOG LOMEM MID\$ OPENIN OPENOUT OPENUP PAGE
+          POINT POS PTR# RAD REPORT\$ RIGHT\$ RND SGN SIN SQR STR\$ STRING\$ SUM
+          SUMLEN TAN TEMPO TIME\$ TIME TOP USR VAL VPOS
+        )
+      end
+
+      def self.statement
+        @statement ||= %w(
+          BEATS BPUT# CALL CASE CHAIN CLEAR CLG CLOSE# CLS COLOR COLOUR DATA
+          ELSE ENDCASE ENDIF ENDPROC ENDWHILE END ENVELOPE FOR GCOL GOSUB GOTO
+          IF INSTALL LET LIBRARY MODE NEXT OFF OF ON ORIGIN OSCI OTHERWISE
+          OVERLAY PLOT PRINT# PRINT PROC QUIT READ REPEAT REPORT RETURN SOUND
+          STEP STEREO STOP SWAP SYS THEN TINT TO VDU VOICES VOICE UNTIL WAIT
+          WHEN WHILE WIDTH
+        )
+      end
+
+      def self.operator
+        @operator ||= %w(
+          << <= <> < >= >>> >> > [-!$()*+/=?^|] AND DIV EOR MOD NOT OR
+        )
+      end
+
+      def self.constant
+        @constant ||= %w(
+          FALSE TRUE
+        )
+      end
+
+      state :expression do
+        rule %r/#{BBCBASIC.function.join('|')}/o, Name::Builtin  # function or pseudo-variable
+        rule %r/#{BBCBASIC.operator.join('|')}/o, Operator
+        rule %r/#{BBCBASIC.constant.join('|')}/o, Name::Constant
+        rule %r/"[^"]*"/o, Literal::String
+        rule %r/[a-z_`][\w`]*[$%]?/io, Name::Variable
+        rule %r/@%/o, Name::Variable
+        rule %r/[\d.]+/o, Literal::Number
+        rule %r/%[01]+/o, Literal::Number::Bin
+        rule %r/&[\h]+/o, Literal::Number::Hex
+      end
+
+      state :root do
+        rule %r/(:+)( *)(\*)(.*)/ do
+          groups Punctuation, Text, Keyword, Text # CLI command
+        end
+        rule %r/(\n+ *)(\*)(.*)/ do
+          groups Text, Keyword, Text # CLI command
+        end
+        rule %r/(ELSE|OTHERWISE|REPEAT|THEN)( *)(\*)(.*)/ do
+          groups Keyword, Text, Keyword, Text # CLI command
+        end
+        rule %r/[ \n]+/o, Text
+        rule %r/:+/o, Punctuation
+        rule %r/[\[]/o, Keyword, :assembly1
+        rule %r/REM *>.*/o, Comment::Special
+        rule %r/REM.*/o, Comment
+        rule %r/(?:#{BBCBASIC.statement.join('|')}|CIRCLE(?: *FILL)?|DEF *(?:FN|PROC)|DRAW(?: *BY)?|DIM(?!\()|ELLIPSE(?: *FILL)?|ERROR(?: *EXT)?|FILL(?: *BY)?|INPUT(?:#| *LINE)?|LINE(?: *INPUT)?|LOCAL(?: *DATA| *ERROR)?|MOUSE(?: *COLOUR| *OFF| *ON| *RECTANGLE| *STEP| *TO)?|MOVE(?: *BY)?|ON(?! *ERROR)|ON *ERROR *(?:LOCAL|OFF)?|POINT(?: *BY)?(?!\()|RECTANGE(?: *FILL)?|RESTORE(?: *DATA| *ERROR)?|TRACE(?: *CLOSE| *ENDPROC| *OFF| *STEP(?: *FN| *ON| *PROC)?| *TO)?)/o, Keyword
+        mixin :expression
+        rule %r/#{BBCBASIC.punctuation.join('|')}/o, Punctuation
+      end
+
+      # Assembly statements are parsed as
+      # {label} {directive|opcode |']' {expressions}} {comment}
+      # Technically, you don't need whitespace between opcodes and arguments,
+      # but this is rare in uncrunched source and trying to enumerate all
+      # possible opcodes here is impractical so we colour it as though
+      # the whitespace is required. Opcodes and directives can only easily be
+      # distinguished from the symbols that make up expressions by looking at
+      # their position within the statement. Similarly, ']' is treated as a
+      # keyword at the start of a statement or as punctuation elsewhere. This
+      # requires a two-state state machine.
+
+      state :assembly1 do
+        rule %r/ +/o, Text
+        rule %r/]/o, Keyword, :pop!
+        rule %r/[:\n]/o, Punctuation
+        rule %r/\.[a-z_`][\w`]*%? */io, Name::Label
+        rule %r/(?:REM|;)[^:\n]*/o, Comment
+        rule %r/[^ :\n]+/o, Keyword, :assembly2
+      end
+
+      state :assembly2 do
+        rule %r/ +/o, Text
+        rule %r/[:\n]/o, Punctuation, :pop!
+        rule %r/(?:REM|;)[^:\n]*/o, Comment, :pop!
+        mixin :expression
+        rule %r/[!#,@\[\]^{}]/, Punctuation
+      end
+    end
+  end
+end

data/lib/rouge/lexers/bpf.rb

@@ -18,25 +18,25 @@ module Rouge
 
       state :root do
         # Calls to helpers
-        rule %r/(call)(\s+)(\d+)/i do |m|
+        rule %r/(call)(\s+)(\d+)/i do
           groups Keyword, Text::Whitespace, Literal::Number::Integer
         end
 
         # Unconditional jumps
-        rule %r/(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do |m|
+        rule %r/(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do
           groups Keyword, Text::Whitespace, Literal::Number::Integer, Text::Whitespace, Name::Label
         end
 
         # Conditional jumps
-        rule %r/(if)(\s+)(r\d+)(\s*)([s!=<>]+)(\s*)(0x\h+|[-]?\d+)(\s*)(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do |m|
+        rule %r/(if)(\s+)(r\d+)(\s*)([s!=<>]+)(\s*)(0x\h+|[-]?\d+)(\s*)(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do
           groups Keyword, Text::Whitespace, Name, Text::Whitespace, Operator, Text::Whitespace, Literal::Number, Text::Whitespace, Keyword, Text::Whitespace, Literal::Number::Integer, Text::Whitespace, Name::Label
         end
-        rule %r/(if)(\s+)(r\d+)(\s*)([s!=<>]+)(\s*)(r\d+)(\s*)(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do |m|
+        rule %r/(if)(\s+)(r\d+)(\s*)([s!=<>]+)(\s*)(r\d+)(\s*)(goto)(\s*)(\+\d+)?(\s*)(<?\w+>?)/i do
           groups Keyword, Text::Whitespace, Name, Text::Whitespace, Operator, Text::Whitespace, Name, Text::Whitespace, Keyword, Text::Whitespace, Literal::Number::Integer, Text::Whitespace, Name::Label
         end
 
         # Dereferences
-        rule %r/(\*)(\s*)(\()(#{TYPE_KEYWORDS})(\s*)(\*)(\))/i do |m|
+        rule %r/(\*)(\s*)(\()(#{TYPE_KEYWORDS})(\s*)(\*)(\))/i do
           groups Operator, Text::Whitespace, Punctuation, Keyword::Type, Text::Whitespace, Operator, Punctuation
           push :address
         end
@@ -45,7 +45,7 @@ module Rouge
         rule %r/[+-\/\*&|><^s]{0,3}=/i, Operator
 
         # Registers
-        rule %r/([+-]?)(r\d+)/i do |m|
+        rule %r/([+-]?)(r\d+)/i do
           groups Punctuation, Name
         end
 
@@ -56,15 +56,15 @@ module Rouge
         rule %r/#{MISC_KEYWORDS}/i, Keyword
 
         # Literals and global objects (maps) refered by name
-        rule %r/(0x\h+|[-]?\d+)(\s*)(ll)?/i do |m|
+        rule %r/(0x\h+|[-]?\d+)(\s*)(ll)?/i do
           groups Literal::Number, Text::Whitespace, Keyword::Type
         end
-        rule %r/(\w+)(\s*)(ll)/i do |m|
+        rule %r/(\w+)(\s*)(ll)/i do
           groups Name, Text::Whitespace, Keyword::Type
         end
 
         # Labels
-        rule %r/(\w+)(\s*)(:)/i do |m|
+        rule %r/(\w+)(\s*)(:)/i do
           groups Name::Label, Text::Whitespace, Punctuation
         end
 
@@ -73,17 +73,17 @@ module Rouge
 
       state :address do
         # Address is offset from register
-        rule %r/(\()(r\d+)(\s*)([+-])(\s*)(\d+)(\))/i do |m|
+        rule %r/(\()(r\d+)(\s*)([+-])(\s*)(\d+)(\))/i do
           groups Punctuation, Name, Text::Whitespace, Operator, Text::Whitespace, Literal::Number::Integer, Punctuation
           pop!
         end
 
         # Address is array subscript
-        rule %r/(\w+)(\[)(\d+)(\])/i do |m|
+        rule %r/(\w+)(\[)(\d+)(\])/i do
           groups Name, Punctuation, Literal::Number::Integer, Punctuation
           pop!
         end
-        rule %r/(\w+)(\[)(r\d+)(\])/i do |m|
+        rule %r/(\w+)(\[)(r\d+)(\])/i do
           groups Name, Punctuation, Name, Punctuation
           pop!
         end