rouge 3.2.0 → 3.18.0

data/lib/rouge/lexers/opentype_feature_file.rb

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class OpenTypeFeatureFile < RegexLexer
+      title "OpenType Feature File"
+      desc "Feature specifications for an OpenType font (adobe-type-tools.github.io/afdko)"
+      tag 'opentype_feature_file'
+      aliases 'fea', 'opentype', 'opentypefeature'
+      filenames '*.fea'
+
+      def self.keywords
+        @keywords ||= %w(
+          Ascender Attach CapHeight CaretOffset CodePageRange Descender FontRevision FSType
+          GlyphClassDef HorizAxis.BaseScriptList HorizAxis.BaseTagList HorizAxis.MinMax
+          IgnoreBaseGlyphs IgnoreLigatures IgnoreMarks LigatureCaretByDev LigatureCaretByIndex
+          LigatureCaretByPos LineGap MarkAttachClass MarkAttachmentType NULL Panose RightToLeft
+          TypoAscender TypoDescender TypoLineGap UnicodeRange UseMarkFilteringSet Vendor
+          VertAdvanceY VertAxis.BaseScriptList VertAxis.BaseTagList VertAxis.MinMax VertOriginY
+          VertTypoAscender VertTypoDescender VertTypoLineGap WeightClass WidthClass XHeight
+
+          anchorDef anchor anonymous anon by contour cursive device enumerate enum
+          exclude_dflt featureNames feature from ignore include_dflt include languagesystem
+          language lookupflag lookup markClass mark nameid name parameters position pos required
+          reversesub rsub script sizemenuname substitute subtable sub table useExtension
+          valueRecordDef winAscent winDescent
+        )
+      end
+
+
+      identifier = %r/[a-z_][a-z0-9\/_]*/i
+
+      state :root do
+        rule %r/\s+/m, Text::Whitespace
+        rule %r/#.*$/, Comment
+
+        # feature <tag>
+        rule %r/(anonymous|anon|feature|lookup|table)((?:\s)+)/ do
+          groups Keyword, Text
+          push :featurename
+        end
+        # } <tag> ;
+        rule %r/(\})((?:\s)*)/ do
+          groups Punctuation, Text
+          push :featurename
+        end
+        # solve include( ../path)
+        rule %r/(include)/i, Keyword, :includepath
+
+        rule %r/[\-\[\]\/(){},.:;=%*<>']/, Punctuation
+
+        rule %r/`.*?/, Str::Backtick
+        rule %r/\"/, Str, :dqs
+
+        # classes, start with @<nameOfClass>
+        rule %r/@#{identifier}/, Name::Class
+
+        # using negative lookbehind so we don't match property names
+        rule %r/(?<!\.)#{identifier}/ do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          else
+            token Name
+          end
+        end
+
+        rule identifier, Name
+        rule %r/-?\d+/, Num::Integer
+      end
+
+      state :featurename do
+        rule identifier, Name::Function, :pop!
+      end
+
+      state :includepath do
+        rule %r/\s+/, Text::Whitespace
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/\(/, Punctuation
+        rule %r/[a-z0-9\/_.]*/i, Str
+      end
+
+      state :strings do
+        rule %r/(\([a-z0-9_]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?/i, Str
+      end
+
+      state :strings_double do
+        rule %r/[^\\"%\n]+/, Str
+        mixin :strings
+      end
+
+      state :escape do
+        rule %r(\\
+          ( [\\abfnrtv"']
+          | \n
+          | N{[a-zA-z][a-zA-Z ]+[a-zA-Z]}
+          | u[a-fA-F0-9]{4}
+          | U[a-fA-F0-9]{8}
+          | x[a-fA-F0-9]{2}
+          | [0-7]{1,3}
+          )
+        )x, Str::Escape
+      end
+
+      state :dqs do
+        rule %r/"/, Str, :pop!
+        mixin :escape
+        mixin :strings_double
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/pascal.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -6,7 +7,7 @@ module Rouge
       tag 'pascal'
       title "Pascal"
       desc 'a procedural programming language commonly used as a teaching language.'
-      filenames '*.pas'
+      filenames '*.pas', '*.lpr'
 
       mimetypes 'text/x-pascal'
 
@@ -39,7 +40,7 @@ module Rouge
 
       state :whitespace do
         # Spaces
-        rule /\s+/m, Text
+        rule %r/\s+/m, Text
         # // Comments
         rule %r((//).*$\n?), Comment::Single
         # -- Comments
@@ -56,9 +57,9 @@ module Rouge
         rule %r{((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?}, Num
         rule %r{[~!@#\$%\^&\*\(\)\+`\-={}\[\]:;<>\?,\.\/\|\\]}, Punctuation
         rule %r{'([^']|'')*'}, Str
-        rule /(true|false|nil)\b/i, Name::Builtin
-        rule /\b(#{keywords.join('|')})\b/i, Keyword
-        rule /\b(#{keywords_type.join('|')})\b/i, Keyword::Type
+        rule %r/(true|false|nil)\b/i, Name::Builtin
+        rule %r/\b(#{keywords.join('|')})\b/i, Keyword
+        rule %r/\b(#{keywords_type.join('|')})\b/i, Keyword::Type
         rule id, Name
       end
     end

data/lib/rouge/lexers/perl.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -64,113 +65,136 @@ module Rouge
       end
 
       state :root do
-        rule /#.*?$/, Comment::Single
-        rule /^=[a-zA-Z0-9]+\s+.*?\n=cut/m, Comment::Multiline
-        rule /(?:#{keywords.join('|')})\b/, Keyword
+        rule %r/#.*?$/, Comment::Single
+        rule %r/^=[a-zA-Z0-9]+\s+.*?\n=cut/m, Comment::Multiline
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword
 
-        rule /(format)(\s+)([a-zA-Z0-9_]+)(\s*)(=)(\s*\n)/ do
+        rule %r/(format)(\s+)([a-zA-Z0-9_]+)(\s*)(=)(\s*\n)/ do
           groups Keyword, Text, Name, Text, Punctuation, Text
 
           push :format
         end
 
-        rule /(?:eq|lt|gt|le|ge|ne|not|and|or|cmp)\b/, Operator::Word
+        rule %r/(?:eq|lt|gt|le|ge|ne|not|and|or|cmp)\b/, Operator::Word
 
-        # common delimiters
-        rule %r(s/(\\\\|\\/|[^/])*/(\\\\|\\/|[^/])*/[egimosx]*), re_tok
-        rule %r(s!(\\\\|\\!|[^!])*!(\\\\|\\!|[^!])*![egimosx]*), re_tok
-        rule %r(s\\(\\\\|[^\\])*\\(\\\\|[^\\])*\\[egimosx]*), re_tok
-        rule %r(s@(\\\\|\\@|[^@])*@(\\\\|\\@|[^@])*@[egimosx]*), re_tok
-        rule %r(s%(\\\\|\\%|[^%])*%(\\\\|\\%|[^%])*%[egimosx]*), re_tok
+        # substitution/transliteration: balanced delimiters
+        rule %r((?:s|tr|y){(\\\\|\\}|[^}])*}\s*), re_tok, :balanced_regex
+        rule %r((?:s|tr|y)<(\\\\|\\>|[^>])*>\s*), re_tok, :balanced_regex
+        rule %r((?:s|tr|y)\[(\\\\|\\\]|[^\]])*\]\s*), re_tok, :balanced_regex
+        rule %r[(?:s|tr|y)\((\\\\|\\\)|[^\)])*\)\s*], re_tok, :balanced_regex
 
-        # balanced delimiters
-        rule %r(s{(\\\\|\\}|[^}])*}\s*), re_tok, :balanced_regex
-        rule %r(s<(\\\\|\\>|[^>])*>\s*), re_tok, :balanced_regex
-        rule %r(s\[(\\\\|\\\]|[^\]])*\]\s*), re_tok, :balanced_regex
-        rule %r[s\((\\\\|\\\)|[^\)])*\)\s*], re_tok, :balanced_regex
+        # substitution/transliteration: arbitrary non-whitespace delimiters
+        rule %r((?:s|tr|y)\s*([^\w\s])((\\\\|\\\1)|[^\1])*?\1((\\\\|\\\1)|[^\1])*?\1[msixpodualngcr]*)m, re_tok
+        rule %r((?:s|tr|y)\s+(\w)((\\\\|\\\1)|[^\1])*?\1((\\\\|\\\1)|[^\1])*?\1[msixpodualngcr]*)m, re_tok
 
-        rule %r(m?/(\\\\|\\/|[^/\n])*/[gcimosx]*), re_tok
+        # matches: common case, m-optional
+        rule %r(m?/(\\\\|\\/|[^/\n])*/[msixpodualngc]*), re_tok
         rule %r(m(?=[/!\\{<\[\(@%\$])), re_tok, :balanced_regex
-        rule %r(((?<==~)|(?<=\())\s*/(\\\\|\\/|[^/])*/[gcimosx]*),
+
+        # arbitrary non-whitespace delimiters
+        rule %r(m\s*([^\w\s])((\\\\|\\\1)|[^\1])*?\1[msixpodualngc]*)m, re_tok
+        rule %r(m\s+(\w)((\\\\|\\\1)|[^\1])*?\1[msixpodualngc]*)m, re_tok
+
+        rule %r(((?<==~)|(?<=\())\s*/(\\\\|\\/|[^/])*/[msixpodualngc]*),
           re_tok, :balanced_regex
 
-        rule /\s+/, Text
-        rule /(?:#{builtins.join('|')})\b/, Name::Builtin
-        rule /((__(DATA|DIE|WARN)__)|(STD(IN|OUT|ERR)))\b/,
+        rule %r/\s+/, Text
+        rule %r/(?:#{builtins.join('|')})\b/, Name::Builtin
+        rule %r/((__(DIE|WARN)__)|(DATA|STD(IN|OUT|ERR)))\b/,
           Name::Builtin::Pseudo
 
-        rule /<<([\'"]?)([a-zA-Z_][a-zA-Z0-9_]*)\1;?\n.*?\n\2\n/m, Str
+        rule %r/<<([\'"]?)([a-zA-Z_][a-zA-Z0-9_]*)\1;?\n.*?\n\2\n/m, Str
 
-        rule /__END__\b/, Comment::Preproc, :end_part
-        rule /\$\^[ADEFHILMOPSTWX]/, Name::Variable::Global
-        rule /\$[\\"'\[\]&`+*.,;=%~?@$!<>(^\|\/-](?!\w)/, Name::Variable::Global
-        rule /[-+\/*%=<>&^\|!\\~]=?/, Operator
-        rule /[$@%#]+/, Name::Variable, :varname
+        rule %r/(__(END|DATA)__)\b/, Comment::Preproc, :end_part
+        rule %r/\$\^[ADEFHILMOPSTWX]/, Name::Variable::Global
+        rule %r/\$[\\"'\[\]&`+*.,;=%~?@$!<>(^\|\/-](?!\w)/, Name::Variable::Global
+        rule %r/[-+\/*%=<>&^\|!\\~]=?/, Operator
+        rule %r/[$@%#]+/, Name::Variable, :varname
 
-        rule /0_?[0-7]+(_[0-7]+)*/, Num::Oct
-        rule /0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*/, Num::Hex
-        rule /0b[01]+(_[01]+)*/, Num::Bin
-        rule /(\d*(_\d*)*\.\d+(_\d*)*|\d+(_\d*)*\.\d+(_\d*)*)(e[+-]?\d+)?/i,
+        rule %r/0_?[0-7]+(_[0-7]+)*/, Num::Oct
+        rule %r/0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*/, Num::Hex
+        rule %r/0b[01]+(_[01]+)*/, Num::Bin
+        rule %r/(\d*(_\d*)*\.\d+(_\d*)*|\d+(_\d*)*\.\d+(_\d*)*)(e[+-]?\d+)?/i,
           Num::Float
-        rule /\d+(_\d*)*e[+-]?\d+(_\d*)*/i, Num::Float
-        rule /\d+(_\d+)*/, Num::Integer
-
-        rule /'(\\\\|\\'|[^'])*'/, Str
-        rule /"(\\\\|\\"|[^"])*"/, Str
-        rule /`(\\\\|\\`|[^`])*`/, Str::Backtick
-        rule /<([^\s>]+)>/, re_tok
-        rule /(q|qq|qw|qr|qx)\{/, Str::Other, :cb_string
-        rule /(q|qq|qw|qr|qx)\(/, Str::Other, :rb_string
-        rule /(q|qq|qw|qr|qx)\[/, Str::Other, :sb_string
-        rule /(q|qq|qw|qr|qx)</, Str::Other, :lt_string
-        rule /(q|qq|qw|qr|qx)([^a-zA-Z0-9])(.|\n)*?\2/, Str::Other
-
-        rule /package\s+/, Keyword, :modulename
-        rule /sub\s+/, Keyword, :funcname
-        rule /\[\]|\*\*|::|<<|>>|>=|<=|<=>|={3}|!=|=~|!~|&&?|\|\||\.{1,3}/,
+        rule %r/\d+(_\d*)*e[+-]?\d+(_\d*)*/i, Num::Float
+        rule %r/\d+(_\d+)*/, Num::Integer
+
+        rule %r/'/, Punctuation, :sq
+        rule %r/"/, Punctuation, :dq
+        rule %r/`/, Punctuation, :bq
+        rule %r/<([^\s>]+)>/, re_tok
+        rule %r/(q|qq|qw|qr|qx)\{/, Str::Other, :cb_string
+        rule %r/(q|qq|qw|qr|qx)\(/, Str::Other, :rb_string
+        rule %r/(q|qq|qw|qr|qx)\[/, Str::Other, :sb_string
+        rule %r/(q|qq|qw|qr|qx)</, Str::Other, :lt_string
+        rule %r/(q|qq|qw|qr|qx)(\W)(.|\n)*?\2/, Str::Other
+
+        rule %r/package\s+/, Keyword, :modulename
+        rule %r/sub\s+/, Keyword, :funcname
+        rule %r/\[\]|\*\*|::|<<|>>|>=|<=|<=>|={3}|!=|=~|!~|&&?|\|\||\.{1,3}/,
           Operator
-        rule /[()\[\]:;,<>\/?{}]/, Punctuation
+        rule %r/[()\[\]:;,<>\/?{}]/, Punctuation
         rule(/(?=\w)/) { push :name }
       end
 
       state :format do
-        rule /\.\n/, Str::Interpol, :pop!
-        rule /.*?\n/, Str::Interpol
+        rule %r/\.\n/, Str::Interpol, :pop!
+        rule %r/.*?\n/, Str::Interpol
       end
 
       state :name_common do
-        rule /\w+::/, Name::Namespace
-        rule /[\w:]+/, Name::Variable, :pop!
+        rule %r/\w+::/, Name::Namespace
+        rule %r/[\w:]+/, Name::Variable, :pop!
       end
 
       state :varname do
-        rule /\s+/, Text
-        rule /\{/, Punctuation, :pop! # hash syntax
-        rule /\)|,/, Punctuation, :pop! # arg specifier
+        rule %r/\s+/, Text
+        rule %r/\{/, Punctuation, :pop! # hash syntax
+        rule %r/\)|,/, Punctuation, :pop! # arg specifier
         mixin :name_common
       end
 
       state :name do
         mixin :name_common
-        rule /[A-Z_]+(?=[^a-zA-Z0-9_])/, Name::Constant, :pop!
+        rule %r/[A-Z_]+(?=[^a-zA-Z0-9_])/, Name::Constant, :pop!
         rule(/(?=\W)/) { pop! }
       end
 
       state :modulename do
-        rule /[a-z_]\w*/i, Name::Namespace, :pop!
+        rule %r/[a-z_]\w*/i, Name::Namespace, :pop!
       end
 
       state :funcname do
-        rule /[a-zA-Z_]\w*[!?]?/, Name::Function
-        rule /\s+/, Text
+        rule %r/[a-zA-Z_]\w*[!?]?/, Name::Function
+        rule %r/\s+/, Text
 
         # argument declaration
-        rule /(\([$@%]*\))(\s*)/ do
+        rule %r/(\([$@%]*\))(\s*)/ do
           groups Punctuation, Text
         end
 
-        rule /.*?{/, Punctuation, :pop!
-        rule /;/, Punctuation, :pop!
+        rule %r/.*?{/, Punctuation, :pop!
+        rule %r/;/, Punctuation, :pop!
+      end
+
+      state :sq do
+        rule %r/\\[']/, Str::Escape
+        rule %r/[^\\']+/, Str::Single
+        rule %r/'/, Punctuation, :pop!
+      end
+
+      state :dq do
+        mixin :string_intp
+        rule %r/\\[\\tnr"]/, Str::Escape
+        rule %r/[^\\"]+?/, Str::Double
+        rule %r/"/, Punctuation, :pop!
+      end
+
+      state :bq do
+        mixin :string_intp
+        rule %r/\\[\\tnr`]/, Str::Escape
+        rule %r/[^\\`]+?/, Str::Backtick
+        rule %r/`/, Punctuation, :pop!
       end
 
       [[:cb, '\{', '\}'],
@@ -179,17 +203,28 @@ module Rouge
        [:lt, '<',  '>']].each do |name, open, close|
         tok = Str::Other
         state :"#{name}_string" do
-          rule /\\[#{open}#{close}\\]/, tok
-          rule /\\/, tok
+          rule %r/\\[#{open}#{close}\\]/, tok
+          rule %r/\\/, tok
           rule(/#{open}/) { token tok; push }
-          rule /#{close}/, tok, :pop!
-          rule /[^#{open}#{close}\\]+/, tok
+          rule %r/#{close}/, tok, :pop!
+          rule %r/[^#{open}#{close}\\]+/, tok
         end
       end
 
+      state :in_interp do
+        rule %r/}/, Str::Interpol, :pop!
+        rule %r/\s+/, Text
+        rule %r/[a-z_]\w*/i, Str::Interpol
+      end
+
+      state :string_intp do
+        rule %r/[$@][{]/, Str::Interpol, :in_interp
+        rule %r/[$@][a-z_]\w*/i, Str::Interpol
+      end
+
       state :end_part do
         # eat the rest of the stream
-        rule /.+/m, Comment::Preproc, :pop!
+        rule %r/.+/m, Comment::Preproc, :pop!
       end
     end
   end

data/lib/rouge/lexers/php.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*- #
+# frozen_string_literal: true
 
 module Rouge
   module Lexers
@@ -28,7 +29,7 @@ module Rouge
       end
 
       def self.builtins
-        load Pathname.new(__FILE__).dirname.join('php/builtins.rb')
+        load File.join(Lexers::BASE_DIR, 'php/builtins.rb')
         self.builtins
       end
 
@@ -62,16 +63,23 @@ module Rouge
       end
 
       def self.keywords
+        # (echo parent ; echo self ; sed -nE 's/<ST_IN_SCRIPTING>"((__)?[[:alpha:]_]+(__)?)".*/\1/p' zend_language_scanner.l | tr '[A-Z]' '[a-z]') | sort -u | grep -Fwv -e isset -e unset -e empty -e const -e use -e function -e namespace
+        # - isset, unset and empty are actually keywords (directly handled by PHP's lexer but let's pretend these are functions, you use them like so)
+        # - self and parent are kind of keywords, they are not handled by PHP's lexer
+        # - use, const, namespace and function are handled by specific rules to highlight what's next to the keyword
+        # - class is also listed here, in addition to the rule below, to handle anonymous classes
         @keywords ||= Set.new %w(
-          and E_PARSE old_function E_ERROR or as E_WARNING parent eval
-          PHP_OS break exit case extends PHP_VERSION cfunction FALSE
-          print for require continue foreach require_once declare return
-          default static do switch die stdClass echo else TRUE elseif
-          var empty if xor enddeclare include virtual endfor include_once
-          while endforeach global __FILE__ endif list __LINE__ endswitch
-          new __sleep endwhile not array __wakeup E_ALL NULL final
-          php_user_filter interface implements public private protected
-          abstract clone try catch throw this use namespace yield
+          old_function cfunction
+          __class__ __dir__ __file__ __function__ __halt_compiler
+          __line__ __method__ __namespace__ __trait__ abstract and
+          array as break callable case catch class clone continue
+          declare default die do echo else elseif enddeclare
+          endfor endforeach endif endswitch endwhile eval exit
+          extends final finally fn for foreach global goto if
+          implements include include_once instanceof insteadof
+          interface list new or parent print private protected
+          public require require_once return self static switch
+          throw trait try var while xor yield
         )
       end
 
@@ -84,56 +92,71 @@ module Rouge
       state :root do
         # some extremely rough heuristics to decide whether to start inline or not
         rule(/\s*(?=<)/m) { delegate parent; push :template }
-        rule(/[^$]+(?=<\?(php|=))/) { delegate parent; push :template }
+        rule(/[^$]+(?=<\?(php|=))/i) { delegate parent; push :template }
 
         rule(//) { push :template; push :php }
       end
 
       state :template do
-        rule /<\?(php|=)?/, Comment::Preproc, :php
+        rule %r/<\?(php|=)?/i, Comment::Preproc, :php
         rule(/.*?(?=<\?)|.*/m) { delegate parent }
       end
 
       state :php do
-        rule /\?>/, Comment::Preproc, :pop!
+        rule %r/\?>/, Comment::Preproc, :pop!
         # heredocs
-        rule /<<<('?)(#{id})\1\n.*?\n\2;?\n/im, Str::Heredoc
-        rule /\s+/, Text
-        rule /#.*?$/, Comment::Single
+        rule %r/<<<(["']?)(#{id})\1\n.*?\n\s*\2;?/im, Str::Heredoc
+        rule %r/\s+/, Text
+        rule %r/#.*?$/, Comment::Single
         rule %r(//.*?$), Comment::Single
-        # empty comment, otherwise seen as the start of a docstring
-        rule %r(/\*\*/), Comment::Multiline
-        rule %r(/\*\*.*?\*/)m, Str::Doc
+        rule %r(/\*\*(?!/).*?\*/)m, Comment::Doc
         rule %r(/\*.*?\*/)m, Comment::Multiline
-        rule /(->|::)(\s*)(#{id})/ do
+
+        rule %r/(->|::)(\s*)(#{id})/ do
           groups Operator, Text, Name::Attribute
         end
 
-        rule /[~!%^&*+=\|:.<>\/?@-]+/, Operator
-        rule /[\[\]{}();,]/, Punctuation
-        rule /class\b/, Keyword, :classname
+        rule %r/(void|\??(int|float|bool|string|iterable|self|callable))\b/i, Keyword::Type
+        rule %r/[~!%^&*+=\|:.<>\/@-]+/, Operator
+        rule %r/\?/, Operator
+        rule %r/[\[\]{}();,]/, Punctuation
+        rule %r/(class|interface|trait)(\s+)(#{nsid})/i do
+          groups Keyword::Declaration, Text, Name::Class
+        end
+        rule %r/(use)(\s+)(function|const|)(\s*)(#{nsid})/i do
+          groups Keyword::Namespace, Text, Keyword::Namespace, Text, Name::Namespace
+          push :use
+        end
+        rule %r/(namespace)(\s+)(#{nsid})/i do
+          groups Keyword::Namespace, Text, Name::Namespace
+        end
         # anonymous functions
-        rule /(function)(\s*)(?=\()/ do
+        rule %r/(function)(\s*)(?=\()/i do
           groups Keyword, Text
         end
 
         # named functions
-        rule /(function)(\s+)(&?)(\s*)/ do
+        rule %r/(function)(\s+)(&?)(\s*)/i do
           groups Keyword, Text, Operator, Text
           push :funcname
         end
 
-        rule /(const)(\s+)(#{id})/i do
+        rule %r/(const)(\s+)(#{id})/i do
           groups Keyword, Text, Name::Constant
         end
 
-        rule /(true|false|null)\b/, Keyword::Constant
-        rule /\$\{\$+#{id}\}/i, Name::Variable
-        rule /\$+#{id}/i, Name::Variable
+        rule %r/stdClass\b/i, Name::Class
+        rule %r/(true|false|null)\b/i, Keyword::Constant
+        rule %r/(E|PHP)(_[[:upper:]]+)+\b/, Keyword::Constant
+        rule %r/\$\{\$+#{id}\}/i, Name::Variable
+        rule %r/\$+#{id}/i, Name::Variable
+        rule %r/(yield)([ \n\r\t]+)(from)/i do
+          groups Keyword, Text, Keyword
+        end
 
         # may be intercepted for builtin highlighting
-        rule /\\?#{nsid}/i do |m|
-          name = m[0]
+        rule %r/\\?#{nsid}/i do |m|
+          name = m[0].downcase
 
           if self.class.keywords.include? name
             token Keyword
@@ -144,48 +167,63 @@ module Rouge
           end
         end
 
-        rule /(\d+\.\d*|\d*\.\d+)(e[+-]?\d+)?/i, Num::Float
-        rule /\d+e[+-]?\d+/i, Num::Float
-        rule /0[0-7]+/, Num::Oct
-        rule /0x[a-f0-9]+/i, Num::Hex
-        rule /\d+/, Num::Integer
-        rule /'([^'\\]*(?:\\.[^'\\]*)*)'/, Str::Single
-        rule /`([^`\\]*(?:\\.[^`\\]*)*)`/, Str::Backtick
-        rule /"/, Str::Double, :string
+        rule %r/(\d[_\d]*)?\.(\d[_\d]*)?(e[+-]?\d[_\d]*)?/i, Num::Float
+        rule %r/0[0-7][0-7_]*/, Num::Oct
+        rule %r/0b[01][01_]*/i, Num::Bin
+        rule %r/0x[a-f0-9][a-f0-9_]*/i, Num::Hex
+        rule %r/\d[_\d]*/, Num::Integer
+        rule %r/'([^'\\]*(?:\\.[^'\\]*)*)'/, Str::Single
+        rule %r/`([^`\\]*(?:\\.[^`\\]*)*)`/, Str::Backtick
+        rule %r/"/, Str::Double, :string
       end
 
-      state :classname do
-        rule /\s+/, Text
-        rule /#{nsid}/, Name::Class, :pop!
+      state :use do
+        rule %r/(\s+)(as)(\s+)(#{id})/i do
+          groups Text, Keyword, Text, Name
+          :pop!
+        end
+        rule %r/\\\{/, Operator, :uselist
+        rule %r/;/, Punctuation, :pop!
+      end
+
+      state :uselist do
+        rule %r/\s+/, Text
+        rule %r/,/, Operator
+        rule %r/\}/, Operator, :pop!
+        rule %r/(as)(\s+)(#{id})/i do
+          groups Keyword, Text, Name
+        end
+        rule %r/#{id}/, Name::Namespace
       end
 
       state :funcname do
-        rule /#{id}/, Name::Function, :pop!
+        rule %r/#{id}/, Name::Function, :pop!
       end
 
       state :string do
-        rule /"/, Str::Double, :pop!
-        rule /[^\\{$"]+/, Str::Double
-        rule /\\([nrt\"$\\]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2})/,
+        rule %r/"/, Str::Double, :pop!
+        rule %r/[^\\{$"]+/, Str::Double
+        rule %r/\\u\{[0-9a-fA-F]+\}/, Str::Escape
+        rule %r/\\([efrntv\"$\\]|[0-7]{1,3}|[xX][0-9a-fA-F]{1,2})/,
           Str::Escape
-        rule /\$#{id}(\[\S+\]|->#{id})?/, Name::Variable
+        rule %r/\$#{id}(\[\S+\]|->#{id})?/, Name::Variable
 
-        rule /\{\$\{/, Str::Interpol, :interp_double
-        rule /\{(?=\$)/, Str::Interpol, :interp_single
-        rule /(\{)(\S+)(\})/ do
+        rule %r/\{\$\{/, Str::Interpol, :interp_double
+        rule %r/\{(?=\$)/, Str::Interpol, :interp_single
+        rule %r/(\{)(\S+)(\})/ do
           groups Str::Interpol, Name::Variable, Str::Interpol
         end
 
-        rule /[${\\]+/, Str::Double
+        rule %r/[${\\]+/, Str::Double
       end
 
       state :interp_double do
-        rule /\}\}/, Str::Interpol, :pop!
+        rule %r/\}\}/, Str::Interpol, :pop!
         mixin :php
       end
 
       state :interp_single do
-        rule /\}/, Str::Interpol, :pop!
+        rule %r/\}/, Str::Interpol, :pop!
         mixin :php
       end
     end