rouge 3.17.0 → 3.18.0

data/lib/rouge/lexers/cpp.rb

@@ -22,10 +22,10 @@ module Rouge
 
       def self.keywords
         @keywords ||= super + Set.new(%w(
-          asm auto catch const_cast delete dynamic_cast explicit export
-          friend mutable namespace new operator private protected public
-          reinterpret_cast restrict size_of static_cast template this throw
-          throws typeid typename using virtual final override
+          asm auto catch const_cast delete dynamic_cast explicit export friend
+          mutable namespace new operator private protected public
+          reinterpret_cast restrict size_of static_cast this throw throws
+          typeid typename using virtual final override
 
           alignas alignof constexpr decltype noexcept static_assert
           thread_local try
@@ -57,7 +57,8 @@ module Rouge
       dq = /\d('?\d)*/
 
       prepend :statements do
-        rule %r/class\b/, Keyword, :classname
+        rule %r/(class|struct)\b/, Keyword, :classname
+        rule %r/template\b/, Keyword, :template
         rule %r/\d+(\.\d+)?(?:h|(?:min)|s|(?:ms)|(?:us)|(?:ns))/, Num::Other
         rule %r((#{dq}[.]#{dq}?|[.]#{dq})(e[+-]?#{dq}[lu]*)?)i, Num::Float
         rule %r(#{dq}e[+-]?#{dq}[lu]*)i, Num::Float
@@ -77,6 +78,12 @@ module Rouge
         rule %r/[.]{3}/, Operator
         mixin :whitespace
       end
+
+      state :template do
+        rule %r/>/, Punctuation, :pop!
+        rule %r/typename\b/, Keyword, :classname
+        mixin :root
+      end
     end
   end
 end

data/lib/rouge/lexers/cypher.rb

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Cypher < RegexLexer
+      tag 'cypher'
+      aliases 'cypher'
+      filenames '*.cypher'
+      mimetypes 'application/x-cypher-query'
+
+      title "Cypher"
+      desc 'The Cypher query language (neo4j.com/docs/cypher-manual)'
+
+      def self.functions
+        @functions ||= Set.new %w(
+          ABS ACOS ALLSHORTESTPATHS ASIN ATAN ATAN2 AVG CEIL COALESCE COLLECT
+          COS COT COUNT DATE DEGREES E ENDNODE EXP EXTRACT FILTER FLOOR
+          HAVERSIN HEAD ID KEYS LABELS LAST LEFT LENGTH LOG LOG10 LOWER LTRIM
+          MAX MIN NODE NODES PERCENTILECONT PERCENTILEDISC PI RADIANS RAND
+          RANGE REDUCE REL RELATIONSHIP RELATIONSHIPS REPLACE REVERSE RIGHT
+          ROUND RTRIM SHORTESTPATH SIGN SIN SIZE SPLIT SQRT STARTNODE STDEV
+          STDEVP STR SUBSTRING SUM TAIL TAN TIMESTAMP TOFLOAT TOINT TOINTEGER
+          TOSTRING TRIM TYPE UPPER
+        )
+      end
+
+      def self.predicates
+        @predicates ||= Set.new %w(
+          ALL AND ANY CONTAINS EXISTS HAS IN NONE NOT OR SINGLE XOR
+        )
+      end
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          AS ASC ASCENDING ASSERT BY CASE COMMIT CONSTRAINT CREATE CSV CYPHER
+          DELETE DESC DESCENDING DETACH DISTINCT DROP ELSE END ENDS EXPLAIN
+          FALSE FIELDTERMINATOR FOREACH FROM HEADERS IN INDEX IS JOIN LIMIT
+          LOAD MATCH MERGE NULL ON OPTIONAL ORDER PERIODIC PROFILE REMOVE
+          RETURN SCAN SET SKIP START STARTS THEN TRUE UNION UNIQUE UNWIND USING
+          WHEN WHERE WITH CALL YIELD
+        )
+      end
+
+      state :root do
+        rule %r/[\s]+/, Text
+        rule %r(//.*?$), Comment::Single
+
+        rule %r([*+\-<>=&|~%^]), Operator
+        rule %r/[{}),;\[\]]/, Str::Symbol
+
+        # literal number
+        rule %r/(\w+)(:)(\s*)(-?[._\d]+)/ do
+          groups Name::Label, Str::Delimiter, Text::Whitespace, Num
+        end
+
+        # function-like
+        # - "name("
+        # - "name  ("
+        # - "name ("
+        rule %r/(\w+)(\s*)(\()/ do |m|
+          name = m[1].upcase
+          if self.class.functions.include? name
+            groups Name::Function, Text::Whitespace, Str::Symbol
+          elsif self.class.keywords.include? name
+            groups Keyword, Text::Whitespace, Str::Symbol
+          else
+            groups Name, Text::Whitespace, Str::Symbol
+          end
+        end
+
+        rule %r/:\w+/, Name::Class
+
+        # number range
+        rule %r/(-?\d+)(\.\.)(-?\d+)/ do
+          groups Num, Operator, Num
+        end
+
+        # numbers
+        rule %r/(\d+\.\d*|\d*\.\d+)(e[+-]?\d+)?/i, Num::Float
+        rule %r/\d+e[+-]?\d+/i, Num::Float
+        rule %r/0[0-7]+/, Num::Oct
+        rule %r/0x[a-f0-9]+/i, Num::Hex
+        rule %r/\d+/, Num::Integer
+
+        rule %r([.\w]+:), Name::Property
+
+        # remaining "("
+        rule %r/\(/, Str::Symbol
+
+        rule %r/[.\w$]+/ do |m|
+          match = m[0].upcase
+          if self.class.predicates.include? match
+            token Operator::Word
+          elsif self.class.keywords.include? match
+            token Keyword
+          else
+            token Name
+          end
+        end
+
+        rule %r/"(\\\\|\\"|[^"])*"/, Str::Double
+        rule %r/'(\\\\|\\'|[^'])*'/, Str::Single
+        rule %r/`(\\\\|\\`|[^`])*`/, Str::Backtick
+      end
+    end
+  end
+end

data/lib/rouge/lexers/datastudio.rb

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Datastudio < RegexLexer
+      tag 'datastudio'
+      filenames '*.job'
+      mimetypes 'text/x-datastudio'
+
+      title "Datastudio"
+      desc 'Datastudio scripting language'
+
+      id = /@?[_a-z]\w*/i
+
+      def self.sql_keywords
+        @sql_keywords ||= %w(
+          ABORT ABS ABSOLUTE ACCESS ADA ADD ADMIN AFTER AGGREGATE ALIAS
+          ALL ALLOCATE ALTER ANALYSE ANALYZE AND ANY ARE AS ASC ASENSITIVE
+          ASSERTION ASSIGNMENT ASYMMETRIC AT ATOMIC AUTHORIZATION
+          AVG BACKWARD BEFORE BEGIN BETWEEN BITVAR BIT_LENGTH BOTH
+          BREADTH BY C CACHE CALL CALLED CARDINALITY CASCADE CASCADED
+          CASE CAST CATALOG CATALOG_NAME CHAIN CHARACTERISTICS
+          CHARACTER_LENGTH CHARACTER_SET_CATALOG CHARACTER_SET_NAME
+          CHARACTER_SET_SCHEMA CHAR_LENGTH CHECK CHECKED CHECKPOINT
+          CLASS CLASS_ORIGIN CLOB CLOSE CLUSTER COALSECE COBOL COLLATE
+          COLLATION COLLATION_CATALOG COLLATION_NAME COLLATION_SCHEMA
+          COLUMN COLUMN_NAME COMMAND_FUNCTION COMMAND_FUNCTION_CODE
+          COMMENT COMMIT COMMITTED COMPLETION CONDITION_NUMBER
+          CONNECT CONNECTION CONNECTION_NAME CONSTRAINT CONSTRAINTS
+          CONSTRAINT_CATALOG CONSTRAINT_NAME CONSTRAINT_SCHEMA
+          CONSTRUCTOR CONTAINS CONTINUE CONVERSION CONVERT COPY
+          CORRESPONTING COUNT CREATE CREATEDB CREATEUSER CROSS CUBE
+          CURRENT CURRENT_DATE CURRENT_PATH CURRENT_ROLE CURRENT_TIME
+          CURRENT_TIMESTAMP CURRENT_USER CURSOR CURSOR_NAME CYCLE DATA
+          DATABASE DATETIME_INTERVAL_CODE DATETIME_INTERVAL_PRECISION
+          DAY DEALLOCATE DECLARE DEFAULT DEFAULTS DEFERRABLE DEFERRED
+          DEFINED DEFINER DELETE DELIMITER DELIMITERS DEREF DESC DESCRIBE
+          DESCRIPTOR DESTROY DESTRUCTOR DETERMINISTIC DIAGNOSTICS
+          DICTIONARY DISCONNECT DISPATCH DISTINCT DO DOMAIN DROP
+          DYNAMIC DYNAMIC_FUNCTION DYNAMIC_FUNCTION_CODE EACH ELSE
+          ENCODING ENCRYPTED END END-EXEC EQUALS ESCAPE EVERY EXCEPT
+          ESCEPTION EXCLUDING EXCLUSIVE EXEC EXECUTE EXISTING EXISTS
+          EXPLAIN EXTERNAL EXTRACT FALSE FETCH FINAL FIRST FOR FORCE
+          FOREIGN FORTRAN FORWARD FOUND FREE FREEZE FROM FULL FUNCTION
+          G GENERAL GENERATED GET GLOBAL GO GOTO GRANT GRANTED GROUP
+          GROUPING HANDLER HAVING HIERARCHY HOLD HOST IDENTITY IGNORE
+          ILIKE IMMEDIATE IMMUTABLE IMPLEMENTATION IMPLICIT IN INCLUDING
+          INCREMENT INDEX INDITCATOR INFIX INHERITS INITIALIZE INITIALLY
+          INNER INOUT INPUT INSENSITIVE INSERT INSTANTIABLE INSTEAD
+          INTERSECT INTO INVOKER IS ISNULL ISOLATION ITERATE JOIN KEY
+          KEY_MEMBER KEY_TYPE LANCOMPILER LANGUAGE LARGE LAST LATERAL
+          LEADING LEFT LENGTH LESS LEVEL LIKE LIMIT LISTEN LOAD LOCAL
+          LOCALTIME LOCALTIMESTAMP LOCATION LOCATOR LOCK LOWER MAP MATCH
+          MAX MAXVALUE MESSAGE_LENGTH MESSAGE_OCTET_LENGTH MESSAGE_TEXT
+          METHOD MIN MINUTE MINVALUE MOD MODE MODIFIES MODIFY MONTH
+          MORE MOVE MUMPS NAMES NATURAL NCLOB NEW NEXT
+          NO NOCREATEDB NOCREATEUSER NONE NOT NOTHING NOTIFY NOTNULL
+          NULL NULLABLE NULLIF OBJECT OCTET_LENGTH OF OFF OFFSET OIDS
+          OLD ON ONLY OPEN OPERATION OPERATOR OPTION OPTIONS OR ORDER
+          ORDINALITY OUT OUTER OUTPUT OVERLAPS OVERLAY OVERRIDING
+          OWNER PAD PARAMETER PARAMETERS PARAMETER_MODE PARAMATER_NAME
+          PARAMATER_ORDINAL_POSITION PARAMETER_SPECIFIC_CATALOG
+          PARAMETER_SPECIFIC_NAME PARAMATER_SPECIFIC_SCHEMA PARTIAL PASCAL
+          PENDANT PLACING PLI POSITION POSTFIX PREFIX PREORDER
+          PREPARE PRESERVE PRIMARY PRIOR PRIVILEGES PROCEDURAL PROCEDURE
+          PUBLIC READ READS RECHECK RECURSIVE REF REFERENCES REFERENCING
+          REINDEX RELATIVE RENAME REPEATABLE REPLACE RESET RESTART
+          RESTRICT RESULT RETURN RETURNED_LENGTH RETURNED_OCTET_LENGTH
+          RETURNED_SQLSTATE RETURNS REVOKE RIGHT ROLE ROLLBACK ROLLUP
+          ROUTINE ROUTINE_CATALOG ROUTINE_NAME ROUTINE_SCHEMA ROW ROWS
+          ROW_COUNT RULE SAVE_POINT SCALE SCHEMA SCHEMA_NAME SCOPE SCROLL
+          SEARCH SECOND SECURITY SELECT SELF SENSITIVE SERIALIZABLE
+          SERVER_NAME SESSION SESSION_USER SET SETOF SETS SHARE SHOW
+          SIMILAR SIMPLE SIZE SOME SOURCE SPACE SPECIFIC SPECIFICTYPE
+          SPECIFIC_NAME SQL SQLCODE SQLERROR SQLEXCEPTION SQLSTATE
+          SQLWARNINIG STABLE START STATE STATEMENT STATIC STATISTICS
+          STDIN STDOUT STORAGE STRICT STRUCTURE STYPE SUBCLASS_ORIGIN
+          SUBLIST SUBSTRING SUM SYMMETRIC SYSID SYSTEM SYSTEM_USER
+          TABLE TABLE_NAME  TEMP TEMPLATE TEMPORARY TERMINATE THAN THEN
+          TIMEZONE_HOUR TIMEZONE_MINUTE TO TOAST TRAILING
+          TRANSATION TRANSACTIONS_COMMITTED TRANSACTIONS_ROLLED_BACK
+          TRANSATION_ACTIVE TRANSFORM TRANSFORMS TRANSLATE TRANSLATION
+          TREAT TRIGGER TRIGGER_CATALOG TRIGGER_NAME TRIGGER_SCHEMA TRIM
+          TRUE TRUNCATE TRUSTED TYPE UNCOMMITTED UNDER UNENCRYPTED UNION
+          UNIQUE UNKNOWN UNLISTEN UNNAMED UNNEST UNTIL UPDATE UPPER
+          USAGE USER USER_DEFINED_TYPE_CATALOG USER_DEFINED_TYPE_NAME
+          USER_DEFINED_TYPE_SCHEMA USING VACUUM VALID VALIDATOR VALUES
+          VARIABLE VERBOSE VERSION VIEW VOLATILE WHEN WHENEVER WHERE
+          WITH WITHOUT WORK WRITE ZONE
+        )
+      end
+
+      state :whitespace do
+        rule %r/\s+/m, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/[*].*?[*]/)m, Comment::Multiline
+      end
+
+      state :string do
+        rule %r/%(\\.|.)+?%/, Str::Escape
+        rule %r/\\"/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+        rule %r/./m, Str::Double
+      end
+
+      state :string_s do
+        rule %r/%(\\.|.)+?%/, Str::Escape
+        rule %r/\\'/, Str::Single
+        rule %r/'/, Str::Single, :pop!
+        rule %r/./m, Str::Single
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r/^:#{id}/, Name::Label
+        rule %r/@#{id}(\.#{id})?/m, Name::Entity
+        rule %r/%(\\.|.)+?%/, Name::Variable
+        rule %r/[~!%^&*()+=|\[\]{}:;,.<>\/?-]/, Punctuation
+        rule %r/"/, Str::Double, :string
+        rule %r/'/, Str::Single, :string_s
+        rule %r/\d(\.\d*)?/i, Num
+        rule %r/#{id}(?=\s*[(])/, Name::Function
+        rule id do |m|
+          name = m[0].upcase
+          
+          if self.class.sql_keywords.include? name
+            token Keyword
+          else
+            token Name
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/fsharp.rb

@@ -113,6 +113,7 @@ module Rouge
         rule %r/#{upper_id}(?=\s*[.])/, Name::Namespace
         rule upper_id, Name::Class, :pop!
         rule id, Name, :pop!
+        rule %r/\[/, Punctuation, :pop!
       end
     end
   end

data/lib/rouge/lexers/ghc_cmm.rb

@@ -0,0 +1,340 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# C minus minus (Cmm) is a pun on the name C++. It's an intermediate language
+# of the Glasgow Haskell Compiler (GHC) that is very similar to C, but with
+# many features missing and some special constructs.
+#
+# Cmm is a dialect of C--. The goal of this lexer is to use what GHC produces
+# and parses (Cmm); C-- itself is not supported.
+#
+# https://gitlab.haskell.org/ghc/ghc/wikis/commentary/compiler/cmm-syntax
+#
+module Rouge
+  module Lexers
+    class GHCCmm < RegexLexer
+      title "GHC Cmm (C--)"
+      desc "GHC Cmm is the intermediate representation of the GHC Haskell compiler"
+      tag 'ghc-cmm'
+      filenames '*.cmm', '*.dump-cmm', '*.dump-cmm-*'
+      aliases 'cmm'
+
+      ws = %r(\s|//.*?\n|/[*](?:[^*]|(?:[*][^/]))*[*]+/)mx
+
+      # Make sure that this is not a preprocessor macro, e.g. `#if` or `#define`.
+      id = %r((?!#[a-zA-Z])[\w#\$%_']+)
+
+      complex_id = %r(
+        (?:[\w#$%_']|\(\)|\(,\)|\[\]|[0-9])*
+        (?:[\w#$%_']+)
+      )mx
+
+      state :root do
+        rule %r/\s+/m, Text
+
+        # sections markers
+        rule %r/^=====.*=====$/, Generic::Heading
+
+        # timestamps
+        rule %r/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+ UTC$/, Comment::Single
+
+        mixin :detect_section
+        mixin :preprocessor_macros
+
+        mixin :info_tbls
+        mixin :comments
+        mixin :literals
+        mixin :keywords
+        mixin :types
+        mixin :infos
+        mixin :names
+        mixin :operators
+
+        # escaped newline
+        rule %r/\\\n/, Text
+
+        # rest is Text
+        rule %r/./, Text
+      end
+
+      state :detect_section do
+        rule %r/(section)(\s+)/ do |m|
+          token Keyword, m[1]
+          token Text, m[2]
+          push :section
+        end
+      end
+
+      state :section do
+        rule %r/"(data|cstring|text|rodata|relrodata|bss)"/, Name::Builtin
+
+        rule %r/{/, Punctuation, :pop!
+
+        mixin :names
+        mixin :operators
+        mixin :keywords
+
+        rule %r/\s+/, Text
+      end
+
+      state :preprocessor_macros do
+        rule %r/#(include|endif|else|if)/, Comment::Preproc
+
+        rule %r{
+            (\#define)
+            (#{ws}*)
+            (#{id})
+          }mx do |m|
+          token Comment::Preproc, m[1]
+          recurse m[2]
+          token Name::Label, m[3]
+        end
+      end
+
+      state :info_tbls do
+        rule %r/({ )(info_tbls)(:)/ do |m|
+          token Punctuation, m[1]
+          token Name::Entity, m[2]
+          token Punctuation, m[3]
+
+          push :info_tbls_body
+        end
+      end
+
+      state :info_tbls_body do
+        rule %r/}/, Punctuation, :pop!
+        rule %r/{/, Punctuation, :info_tbls_body
+
+        rule %r/(?=label:)/ do
+          push :label
+        end
+
+        rule %r{(\()(#{complex_id})(,)}mx do |m|
+          token Punctuation, m[1]
+          token Name::Label, m[2]
+          token Punctuation, m[3]
+        end
+
+        mixin :literals
+        mixin :infos
+        mixin :keywords
+        mixin :operators
+
+        rule %r/#{id}/, Text
+        rule %r/\s+/, Text
+      end
+
+      state :label do
+        mixin :infos
+        mixin :names
+        mixin :keywords
+        mixin :operators
+
+        rule %r/[^\S\n]+/, Text # Tab, space, etc. but not newline!
+        rule %r/\n/, Text, :pop!
+      end
+
+      state :comments do
+        rule %r/\/{2}.*/, Comment::Single
+        rule %r/\(likely.*?\)/, Comment
+        rule %r/\/\*.*?\*\//m, Comment::Multiline
+      end
+
+      state :literals do
+        rule %r/-?[0-9]+\.[0-9]+/, Literal::Number::Float
+        rule %r/-?[0-9]+/, Literal::Number::Integer
+        rule %r/"/, Literal::String::Delimiter, :literal_string
+      end
+
+      state :literal_string do
+        # quotes
+        rule %r/\\./, Literal::String::Escape
+        rule %r/%./, Literal::String::Symbol
+        rule %r/"/, Literal::String::Delimiter, :pop!
+        rule %r/./, Literal::String
+      end
+
+      state :operators do
+        rule %r/\.\./, Operator
+        rule %r/[+\-*\/<>=!&|~]/, Operator
+        rule %r/[\[\].{}:;,()]/, Punctuation
+      end
+
+      state :keywords do
+        rule %r/(const)(\s+)/ do |m|
+          token Keyword::Constant, m[1]
+          token Text, m[2]
+        end
+
+        rule %r/"/, Literal::String::Double
+
+        rule %r/(switch)([^{]*)({)/ do |m|
+          token Keyword, m[1]
+          recurse m[2]
+          token Punctuation, m[3]
+        end
+
+        rule %r/(arg|result)(#{ws}+)(hints)(:)/ do |m|
+          token Name::Property, m[1]
+          recurse m[2]
+          token Name::Property, m[3]
+          token Punctuation, m[4]
+        end
+
+        rule %r/(returns)(#{ws}*)(to)/ do |m|
+          token Keyword, m[1]
+          recurse m[2]
+          token Keyword, m[3]
+        end
+
+        rule %r/(never)(#{ws}*)(returns)/ do |m|
+          token Keyword, m[1]
+          recurse m[2]
+          token Keyword, m[3]
+        end
+
+        rule %r{(return)(#{ws}*)(\()} do |m|
+          token Keyword, m[1]
+          recurse m[2]
+          token Punctuation, m[3]
+        end
+
+        rule %r{(if|else|goto|call|offset|import|jump|ccall|foreign|prim|case|unwind|export|reserve|push)(#{ws})} do |m|
+          token Keyword, m[1]
+          recurse m[2]
+        end
+
+        rule %r{(default)(#{ws}*)(:)} do |m|
+          token Keyword, m[1]
+          recurse m[2]
+          token Punctuation, m[3]
+        end
+      end
+
+      state :types do
+        # Memory access: `type[42]`
+        # Note: Only a token for type is produced.
+        rule %r/(#{id})(?=\[[^\]])/ do |m|
+          token Keyword::Type, m[1]
+        end
+
+        # Array type: `type[]`
+        rule %r/(#{id}\[\])/ do |m|
+          token Keyword::Type, m[1]
+        end
+
+        # Capture macro substitutions before lexing typed declarations
+        # I.e. there is no type in `PREPROCESSOR_MACRO_VARIABLE someFun()`
+        rule %r{
+                (^#{id})
+                (#{ws}+)
+                (#{id})
+                (#{ws}*)
+                (\()
+              }mx do |m|
+          token Name::Label, m[1]
+          recurse m[2]
+          token Name::Function, m[3]
+          recurse m[4]
+          token Punctuation, m[5]
+        end
+
+        # Type in variable or parameter declaration:
+        #   `type /* optional whitespace */ var_name /* optional whitespace */;`
+        #   `type /* optional whitespace */ var_name /* optional whitespace */, var_name2`
+        #   `(type /* optional whitespace */ var_name /* optional whitespace */)`
+        # Note: Only the token for type is produced here.
+        rule %r{
+                (^#{id})
+                (#{ws}+)
+                (#{id})
+              }mx do |m|
+          token Keyword::Type, m[1]
+          recurse m[2]
+          token Name::Label, m[3]
+        end
+      end
+
+      state :infos do
+        rule %r/(args|res|upd|label|rep|srt|arity|fun_type|arg_space|updfr_space)(:)/ do |m|
+          token Name::Property, m[1]
+          token Punctuation, m[2]
+        end
+
+        rule %r/(stack_info)(:)/ do |m|
+          token Name::Entity, m[1]
+          token Punctuation, m[2]
+        end
+      end
+
+      state :names do
+        rule %r/(::)(#{ws}*)([A-Z]\w+)/ do |m|
+          token Operator, m[1]
+          recurse m[2]
+          token Keyword::Type, m[3]
+        end
+
+        rule %r/<(#{id})>/, Name::Builtin
+
+        rule %r/(Sp|SpLim|Hp|HpLim|HpAlloc|BaseReg|CurrentNursery|CurrentTSO|R\d{1,2}|gcptr)(?!#{id})/, Name::Variable::Global
+        rule %r/([A-Z]#{id})(\.)/ do |m|
+          token Name::Namespace, m[1]
+          token Punctuation, m[2]
+          push :namespace_name
+        end
+
+        # Inline function calls:
+        # ```
+        #  arg1 `lt` arg2
+        # ```
+        rule %r/(`)(#{id})(`)/ do |m|
+          token Punctuation, m[1]
+          token Name::Function, m[2]
+          token Punctuation, m[3]
+        end
+
+        # Function: `name /* optional whitespace */ (`
+        # Function (arguments via explicit stack handling): `name /* optional whitespace */ {`
+        rule %r{(?=
+                  #{complex_id}
+             #{ws}*
+                  [\{\(]
+                )}mx do
+          push :function
+        end
+
+        rule %r/CLOSURE/, Keyword::Type
+        rule %r/#{complex_id}/, Name::Label
+      end
+
+      state :namespace_name do
+        rule %r/([A-Z]#{id})(\.)/ do |m|
+          token Name::Namespace, m[1]
+          token Punctuation, m[2]
+        end
+
+        rule %r{(#{complex_id})(#{ws}*)([\{\(])}mx do |m|
+          token Name::Function, m[1]
+          recurse m[2]
+          token Punctuation, m[3]
+          pop!
+        end
+
+        rule %r/#{complex_id}/, Name::Label, :pop!
+
+        rule %r/(?=.)/m do
+          pop!
+        end
+      end
+
+      state :function do
+        rule %r/INFO_TABLE_FUN|INFO_TABLE_CONSTR|INFO_TABLE_SELECTOR|INFO_TABLE_RET|INFO_TABLE/, Name::Builtin
+        rule %r/%#{id}/, Name::Builtin
+        rule %r/#{complex_id}/, Name::Function
+        rule %r/\s+/, Text
+        rule %r/[({]/, Punctuation, :pop!
+        mixin :comments
+      end
+    end
+  end
+end