rouge 3.17.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

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Pascal < RegexLexer
+      tag 'pascal'
+      title "Pascal"
+      desc 'a procedural programming language commonly used as a teaching language.'
+      filenames '*.pas'
+
+      mimetypes 'text/x-pascal'
+
+      id = /@?[_a-z]\w*/i
+
+      keywords = %w(
+        absolute abstract all and and_then array as asm assembler attribute
+        begin bindable case class const constructor delay destructor div do
+        downto else end except exit export exports external far file finalization
+        finally for forward function goto if implementation import in inc index
+        inherited initialization inline interface interrupt is label library
+        message mod module near nil not object of on only operator or or_else
+        otherwise out overload override packed pascal pow private procedure program
+        property protected public published qualified raise read record register
+        repeat resident resourcestring restricted safecall segment set shl shr
+        stdcall stored string then threadvar to try type unit until uses value var
+        view virtual while with write writeln xor
+      )
+
+      keywords_type = %w(
+        ansichar ansistring bool boolean byte bytebool cardinal char comp currency
+        double dword extended int64 integer iunknown longbool longint longword pansichar
+        pansistring pbool pboolean pbyte pbytearray pcardinal pchar pcomp pcurrency
+        pdate pdatetime pdouble pdword pextended phandle pint64 pinteger plongint plongword
+        pointer ppointer pshortint pshortstring psingle psmallint pstring pvariant pwidechar
+        pwidestring pword pwordarray pwordbool real real48 shortint shortstring single
+        smallint string tclass tdate tdatetime textfile thandle tobject ttime variant
+        widechar widestring word wordbool
+      )
+
+      state :whitespace do
+        # Spaces
+        rule %r/\s+/m, Text
+        # // Comments
+        rule %r((//).*$\n?), Comment::Single
+        # -- Comments
+        rule %r((--).*$\n?), Comment::Single
+        # (* Comments *)
+        rule %r(\(\*.*?\*\))m, Comment::Multiline
+        # { Comments }
+        rule %r(\{.*?\})m, Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+
+        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 %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
+  end
+end

data/lib/rouge/lexers/perl.rb

@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Perl < RegexLexer
+      title "Perl"
+      desc "The Perl scripting language (perl.org)"
+
+      tag 'perl'
+      aliases 'pl'
+
+      filenames '*.pl', '*.pm', '*.t'
+      mimetypes 'text/x-perl', 'application/x-perl'
+
+      def self.detect?(text)
+        return true if text.shebang? 'perl'
+      end
+
+      keywords = %w(
+        case continue do else elsif for foreach if last my next our
+        redo reset then unless until while use print new BEGIN CHECK
+        INIT END return
+      )
+
+      builtins = %w(
+        abs accept alarm atan2 bind binmode bless caller chdir chmod
+        chomp chop chown chr chroot close closedir connect continue cos
+        crypt dbmclose dbmopen defined delete die dump each endgrent
+        endhostent endnetent endprotoent endpwent endservent eof eval
+        exec exists exit exp fcntl fileno flock fork format formline getc
+        getgrent getgrgid getgrnam gethostbyaddr gethostbyname gethostent
+        getlogin getnetbyaddr getnetbyname getnetent getpeername
+        getpgrp getppid getpriority getprotobyname getprotobynumber
+        getprotoent getpwent getpwnam getpwuid getservbyname getservbyport
+        getservent getsockname getsockopt glob gmtime goto grep hex
+        import index int ioctl join keys kill last lc lcfirst length
+        link listen local localtime log lstat map mkdir msgctl msgget
+        msgrcv msgsnd my next no oct open opendir ord our pack package
+        pipe pop pos printf prototype push quotemeta rand read readdir
+        readline readlink readpipe recv redo ref rename require reverse
+        rewinddir rindex rmdir scalar seek seekdir select semctl semget
+        semop send setgrent sethostent setnetent setpgrp setpriority
+        setprotoent setpwent setservent setsockopt shift shmctl shmget
+        shmread shmwrite shutdown sin sleep socket socketpair sort splice
+        split sprintf sqrt srand stat study substr symlink syscall sysopen
+        sysread sysseek system syswrite tell telldir tie tied time times
+        tr truncate uc ucfirst umask undef unlink unpack unshift untie
+        utime values vec wait waitpid wantarray warn write
+      )
+
+      re_tok = Str::Regex
+
+      state :balanced_regex do
+        rule %r(/(\\[\\/]|[^/])*/[egimosx]*)m, re_tok, :pop!
+        rule %r(!(\\[\\!]|[^!])*![egimosx]*)m, re_tok, :pop!
+        rule %r(\\(\\\\|[^\\])*\\[egimosx]*)m, re_tok, :pop!
+        rule %r({(\\[\\}]|[^}])*}[egimosx]*), re_tok, :pop!
+        rule %r(<(\\[\\>]|[^>])*>[egimosx]*), re_tok, :pop!
+        rule %r(\[(\\[\\\]]|[^\]])*\][egimosx]*), re_tok, :pop!
+        rule %r[\((\\[\\\)]|[^\)])*\)[egimosx]*], re_tok, :pop!
+        rule %r(@(\\[\\@]|[^@])*@[egimosx]*), re_tok, :pop!
+        rule %r(%(\\[\\%]|[^%])*%[egimosx]*), re_tok, :pop!
+        rule %r(\$(\\[\\\$]|[^\$])*\$[egimosx]*), re_tok, :pop!
+      end
+
+      state :root do
+        rule %r/#.*?$/, Comment::Single
+        rule %r/^=[a-zA-Z0-9]+\s+.*?\n=cut/m, Comment::Multiline
+        rule %r/(?:#{keywords.join('|')})\b/, Keyword
+
+        rule %r/(format)(\s+)([a-zA-Z0-9_]+)(\s*)(=)(\s*\n)/ do
+          groups Keyword, Text, Name, Text, Punctuation, Text
+
+          push :format
+        end
+
+        rule %r/(?:eq|lt|gt|le|ge|ne|not|and|or|cmp)\b/, Operator::Word
+
+        # 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
+
+        # 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
+
+        # matches: common case, m-optional
+        rule %r(m?/(\\\\|\\/|[^/\n])*/[msixpodualngc]*), re_tok
+        rule %r(m(?=[/!\\{<\[\(@%\$])), re_tok, :balanced_regex
+
+        # 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 %r/\s+/, Text
+        rule %r/(?:#{builtins.join('|')})\b/, Name::Builtin
+        rule %r/((__(DIE|WARN)__)|(DATA|STD(IN|OUT|ERR)))\b/,
+          Name::Builtin::Pseudo
+
+        rule %r/<<([\'"]?)([a-zA-Z_][a-zA-Z0-9_]*)\1;?\n.*?\n\2\n/m, Str
+
+        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 %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 %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 %r/[()\[\]:;,<>\/?{}]/, Punctuation
+        rule(/(?=\w)/) { push :name }
+      end
+
+      state :format do
+        rule %r/\.\n/, Str::Interpol, :pop!
+        rule %r/.*?\n/, Str::Interpol
+      end
+
+      state :name_common do
+        rule %r/\w+::/, Name::Namespace
+        rule %r/[\w:]+/, Name::Variable, :pop!
+      end
+
+      state :varname do
+        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 %r/[A-Z_]+(?=[^a-zA-Z0-9_])/, Name::Constant, :pop!
+        rule(/(?=\W)/) { pop! }
+      end
+
+      state :modulename do
+        rule %r/[a-z_]\w*/i, Name::Namespace, :pop!
+      end
+
+      state :funcname do
+        rule %r/[a-zA-Z_]\w*[!?]?/, Name::Function
+        rule %r/\s+/, Text
+
+        # argument declaration
+        rule %r/(\([$@%]*\))(\s*)/ do
+          groups Punctuation, Text
+        end
+
+        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, '\{', '\}'],
+       [:rb, '\(', '\)'],
+       [:sb, '\[', '\]'],
+       [:lt, '<',  '>']].each do |name, open, close|
+        tok = Str::Other
+        state :"#{name}_string" do
+          rule %r/\\[#{open}#{close}\\]/, tok
+          rule %r/\\/, tok
+          rule(/#{open}/) { token tok; push }
+          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 %r/.+/m, Comment::Preproc, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/php.rb

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class PHP < TemplateLexer
+      title "PHP"
+      desc "The PHP scripting language (php.net)"
+      tag 'php'
+      aliases 'php', 'php3', 'php4', 'php5'
+      filenames '*.php', '*.php[345t]','*.phtml',
+                # Support Drupal file extensions, see:
+                # https://github.com/gitlabhq/gitlabhq/issues/8900
+                '*.module', '*.inc', '*.profile', '*.install', '*.test'
+      mimetypes 'text/x-php'
+
+      option :start_inline, 'Whether to start with inline php or require <?php ... ?>. (default: best guess)'
+      option :funcnamehighlighting, 'Whether to highlight builtin functions (default: true)'
+      option :disabledmodules, 'Disable certain modules from being highlighted as builtins (default: empty)'
+
+      def initialize(*)
+        super
+
+        # if truthy, the lexer starts highlighting with php code
+        # (no <?php required)
+        @start_inline = bool_option(:start_inline) { :guess }
+        @funcnamehighlighting = bool_option(:funcnamehighlighting) { true }
+        @disabledmodules = list_option(:disabledmodules)
+      end
+
+      def self.builtins
+        load File.join(__dir__, 'php/builtins.rb')
+        self.builtins
+      end
+
+      def builtins
+        return [] unless @funcnamehighlighting
+
+        @builtins ||= Set.new.tap do |builtins|
+          self.class.builtins.each do |mod, fns|
+            next if @disabledmodules.include? mod
+            builtins.merge(fns)
+          end
+        end
+      end
+
+      # source: http://php.net/manual/en/language.variables.basics.php
+      # the given regex is invalid utf8, so... we're using the unicode
+      # "Letter" property instead.
+      id = /[\p{L}_][\p{L}\p{N}_]*/
+      nsid = /#{id}(?:\\#{id})*/
+
+      start do
+        case @start_inline
+        when true
+          push :template
+          push :php
+        when false
+          push :template
+        when :guess
+          # pass
+        end
+      end
+
+      def self.keywords
+        @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 finally throw this use namespace yield
+        )
+      end
+
+      def self.detect?(text)
+        return true if text.shebang?('php')
+        return false if /^<\?hh/ =~ text
+        return true if /^<\?php/ =~ text
+      end
+
+      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(//) { push :template; push :php }
+      end
+
+      state :template do
+        rule %r/<\?(php|=)?/, Comment::Preproc, :php
+        rule(/.*?(?=<\?)|.*/m) { delegate parent }
+      end
+
+      state :php do
+        rule %r/\?>/, Comment::Preproc, :pop!
+        # heredocs
+        rule %r/<<<('?)(#{id})\1\n.*?\n\s*\2;?/im, Str::Heredoc
+        rule %r/\s+/, Text
+        rule %r/#.*?$/, Comment::Single
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*\*(?!/).*?\*/)m, Comment::Doc
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+        
+        rule %r/(->|::)(\s*)(#{id})/ do
+          groups Operator, Text, Name::Attribute
+        end
+
+        rule %r/[~!%^&*+=\|:.<>\/?@-]+/, Operator
+        rule %r/[\[\]{}();,]/, Punctuation
+        rule %r/(class|interface|trait)(\s+)(#{nsid})/ do
+          groups Keyword::Declaration, Text, Name::Class
+        end
+        rule %r/(use)(\s+)(function|const|)(\s*)(#{nsid})/ do
+          groups Keyword::Namespace, Text, Keyword::Namespace, Text, Name::Namespace
+          push :use
+        end
+        rule %r/(namespace)(\s+)(#{nsid})/ do
+          groups Keyword::Namespace, Text, Name::Namespace
+        end
+        # anonymous functions
+        rule %r/(function)(\s*)(?=\()/ do
+          groups Keyword, Text
+        end
+
+        # named functions
+        rule %r/(function)(\s+)(&?)(\s*)/ do
+          groups Keyword, Text, Operator, Text
+          push :funcname
+        end
+
+        rule %r/(const)(\s+)(#{id})/i do
+          groups Keyword, Text, Name::Constant
+        end
+
+        rule %r/(true|false|null)\b/, Keyword::Constant
+        rule %r/\$\{\$+#{id}\}/i, Name::Variable
+        rule %r/\$+#{id}/i, Name::Variable
+
+        # may be intercepted for builtin highlighting
+        rule %r/\\?#{nsid}/i do |m|
+          name = m[0]
+
+          if self.class.keywords.include? name
+            token Keyword
+          elsif self.builtins.include? name
+            token Name::Builtin
+          else
+            token Name::Other
+          end
+        end
+
+        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/'([^'\\]*(?:\\.[^'\\]*)*)'/, Str::Single
+        rule %r/`([^`\\]*(?:\\.[^`\\]*)*)`/, Str::Backtick
+        rule %r/"/, Str::Double, :string
+      end
+      
+      state :use do
+        rule %r/(\s+)(as)(\s+)(#{id})/ 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})/ do
+          groups Keyword, Text, Name
+        end
+        rule %r/#{id}/, Name::Namespace
+      end
+
+      state :funcname do
+        rule %r/#{id}/, Name::Function, :pop!
+      end
+
+      state :string do
+        rule %r/"/, Str::Double, :pop!
+        rule %r/[^\\{$"]+/, Str::Double
+        rule %r/\\([nrt\"$\\]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2})/,
+          Str::Escape
+        rule %r/\$#{id}(\[\S+\]|->#{id})?/, Name::Variable
+
+        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 %r/[${\\]+/, Str::Double
+      end
+
+      state :interp_double do
+        rule %r/\}\}/, Str::Interpol, :pop!
+        mixin :php
+      end
+
+      state :interp_single do
+        rule %r/\}/, Str::Interpol, :pop!
+        mixin :php
+      end
+    end
+  end
+end