3 �;�e�E � @ s^ d Z ddlZddlmZmZmZmZ ddlmZm Z m Z mZmZm Z dgZG dd� de�ZdS )z� pygments.lexers.factor ~~~~~~~~~~~~~~~~~~~~~~ Lexers for the Factor language. :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. � N)� RegexLexer�bygroups�default�words)�Text�Comment�Keyword�Name�String�Number�FactorLexerc � @ s( e Zd ZdZdZdgZdgZdgZej ej B Ze�ddudv�Z e�ddudv�Ze�ddudv�Ze�ddudv�Ze�ddudv�Ze�ddudv�Ze�ddudv�Ze�ddudv�Ze�ddudv�Ze�ddudv�Ze�ddudv�Z�d�ejfe�d҃g�d�ef�d�eeeej�f�d�eeeej eej�f�d�eeeejeej �f�d�eeeej�f�d�eeeejeej�f�d�ej�d�f�d�ef�d�eej!e��d�f�d�eej!eej!�f�d�eej!eej!eej!�f�d�eej!eej!e��d�f�d�eej!eejeej!eej�f�d�eej!eejeej�f�d�eej!eej�f�d�eeeej eej ��d�f�d�eeeej ��d�f�d�eeeej �f�d�eeeej eej �f�d�eeeejeej �f�d�eeeej eej �f�d�eeeej�f�d�eeeej �f�d�e�d�f�d�eeeej�f�d�e�d�f�d�ef�d�ef�d�eeeej �f�d�eej!eeje�f�d�eej!eejeeje�f�d�ej!f�d�e"f�d�e"f�d�e"f�d�e"j#f�d�ef�d�ef�d�ef�d�ej$f�d�ej$f�d ej$f�de%f�de%f�de%f�de%f�de%j&f�de%j'f�de%f�de%f�d efe ej(feej(feej(feej(feej(feej(feej(feej(feej(feej(feej(f�d efg?�d�ef�dej�d�f�dej�d f�dejf�d ej)fg�d�ef�d�e�d f�deeej)e�f�d ej)fg�d�ef�d�e�d f�d ej!fg�d�ef�d�e�d f�d ej fg�d�ef�d�e�d f�d ejfg�d�Z*�dS ( r z^ Lexer for the `Factor <http://factorcode.org>`_ language. .. versionadded:: 1.4 ZFactorZfactorz*.factorz text/x-factor�-rot�2bi�2bi@�2bi*�2curry�2dip�2drop�2dup�2keep�2nip�2over�2tri�2tri@�2tri*�3bi�3curry�3dip�3drop�3dup�3keep�3tri�4dip�4drop�4dup�4keep� <wrapper>�=�>boolean�clone�?�?execute�?if�and�assert�assert=�assert?�bi�bi-curry� bi-curry@� bi-curry*�bi@�bi*�boa�boolean�boolean?�both?�build�call� callstack�callstack>array� callstack?�clear�(clone)�compose�compose?�curry�curry?� datastack�die�dip�do�drop�dup�dupd�either?�eq?�equal?�execute�hashcode� hashcode*�identity-hashcode�identity-tuple�identity-tuple?�if�if*�keep�loop�most�new�nip�not�null�object�or�over�pick�prepose�retainstack�rot�same?�swap�swapd�throw�tri� tri-curry� tri-curry@� tri-curry*�tri@�tri*�tuple�tuple?�unless�unless*�until�when�when*�while�with�wrapper�wrapper?�xorz\s)�suffix�2cache�<enum>�>alist�?at�?of�assoc� assoc-all?� assoc-any?�assoc-clone-like� assoc-combine� assoc-diff�assoc-diff!�assoc-differ� assoc-each�assoc-empty?�assoc-filter� assoc-filter!�assoc-filter-as� assoc-find�assoc-hashcode�assoc-intersect� assoc-like� assoc-map�assoc-map-as�assoc-partition�assoc-refine� assoc-size�assoc-stack� assoc-subset?�assoc-union�assoc-union!�assoc=� assoc>map�assoc?�at�at+�at*�cache� change-at�clear-assoc� delete-at� delete-at*�enum�enum?�extract-keys�inc-at�key?�keys� map>assoc�maybe-set-at� new-assoc�of�push-at� rename-at�set-at� sift-keys�sift-values� substitute�unzip�value-at� value-at*�value?�values�zip�2cleave�2cleave>quot�3cleave�3cleave>quot�4cleave�4cleave>quot� alist>quot�call-effect�case� case-find� case>quot�cleave�cleave>quot�cond� cond>quot�deep-spread>quot�execute-effect�linear-case-quot�no-case�no-case?�no-cond�no-cond?�recursive-hashcode�shallow-spread>quot�spread�to-fixed-point�wrong-values� wrong-values?�-�/�/f�/i�/mod�2/�2^�<�<=�<fp-nan>�>�>=�>bignum�>fixnum�>float�>integer�(all-integers?)�(each-integer)�(find-integer)�*�+�?1+�abs�align� all-integers?�bignum�bignum?�bit?�bitand�bitnot�bitor�bits>double� bits>float�bitxor�complex�complex?�denominator�double>bits�each-integer�even?�find-integer�find-last-integer�fixnum�fixnum?�float� float>bits�float?�fp-bitwise=�fp-infinity?�fp-nan-payload�fp-nan?�fp-qnan?�fp-sign�fp-snan?�fp-special?�if-zero�imaginary-part�integer�integer>fixnum�integer>fixnum-strict�integer?�log2�log2-expects-positive�log2-expects-positive?�mod�neg�neg?� next-float�next-power-of-2�number�number=�number?� numerator�odd?�out-of-fixnum-range�out-of-fixnum-range?�power-of-2?� prev-float�ratio�ratio?�rational� rational?�real� real-part�real?�recip�rem�sgn�shift�sq�times�u<�u<=�u>�u>=�unless-zero� unordered?� when-zero�zero?� 1sequence�2all?�2each�2map�2map-as�2map-reduce�2reduce� 2selector� 2sequence�3append� 3append-as�3each�3map�3map-as� 3sequence� 4sequence�<repetition>� <reversed>�<slice>�?first�?last�?nth�?second�?set-nth� accumulate�accumulate!� accumulate-as�all?�any?�append�append!� append-as�assert-sequence�assert-sequence=�assert-sequence?� binary-reduce�bounds-check� bounds-check?�bounds-error� bounds-error?�but-last�but-last-slice�cartesian-each� cartesian-map�cartesian-product� change-nth�check-slice�check-slice-error� clone-like�collapse-slice� collector� collector-for�concat� concat-as�copy�count�cut� cut-slice�cut*� delete-all�delete-slice�drop-prefix�each� each-from� each-index�empty?�exchange�filter�filter!� filter-as�find� find-from� find-index�find-index-from� find-last�find-last-from�first�first2�first3�first4�flip�follow�fourth�glue�halves�harvest�head� head-slice�head-slice*�head*�head?�if-empty� immutable�immutable-sequence�immutable-sequence?� immutable?�index� index-from�indices�infimum� infimum-by� insert-nth� interleave�iota� iota-tuple�iota-tuple?�join�join-as�last� last-index�last-index-from�length�lengthen�like�longer�longer?�longest�map�map!�map-as�map-find� map-find-last� map-index�map-integers� map-reduce�map-sum� max-length� member-eq?�member?� midpoint@� min-length�mismatch�move�new-like� new-resizable�new-sequence�non-negative-integer-expected�non-negative-integer-expected?�nth�nths�pad-head�pad-tail�padding� partition�pop�pop*�prefix�prepend� prepend-as�produce� produce-as�product�push�push-all�push-either�push-if�reduce�reduce-index�remove�remove!� remove-eq� remove-eq!� remove-nth�remove-nth!� repetition�repetition?� replace-slice� replicate�replicate-as�rest� rest-slice�reverse�reverse!�reversed� reversed?�second�selector�selector-for�sequence�sequence-hashcode� sequence=� sequence?� set-first� set-fourth�set-last� set-length�set-nth� set-second� set-third�short�shorten�shorter�shorter?�shortest�sift�slice�slice-error�slice-error?�slice?�snip� snip-slice�start�start*�subseq�subseq?r| �suffix!�sum�sum-lengths�supremum�supremum-by�surround�tail� tail-slice�tail-slice*�tail*�tail?�third�trim� trim-head�trim-head-slice� trim-slice� trim-tail�trim-tail-slice�unclip�unclip-last�unclip-last-slice�unclip-slice�unless-empty�virtual-exemplar�virtual-sequence�virtual-sequence?�virtual@� when-empty�+@�change� change-global�counter�dec�get� get-global�global�inc�init-namespaces� initialize� is-global� make-assoc� namespace� namestack�off�on�set� set-global� set-namestack�toggle�with-global� with-scope� with-variable�with-variables�1array�2array�3array�4array�<array>�>array�array�array?�pair�pair?�resize-array�(each-stream-block-slice)�(each-stream-block)�(stream-contents-by-block)�(stream-contents-by-element)�$(stream-contents-by-length-or-block)�(stream-contents-by-length)�+byte+�+character+� bad-seek-type�bad-seek-type?�bl�contents� each-block�each-block-size�each-block-slice� each-line�each-morsel�each-stream-block�each-stream-block-slice�each-stream-line�error-stream�flush�input-stream� input-stream?�invalid-read-buffer�invalid-read-buffer?�lines�nl� output-stream�output-stream?�print�read� read-into�read-partial�read-partial-into� read-until�read1�readln� seek-absolute�seek-absolute?�seek-end� seek-end?� seek-input�seek-output� seek-relative�seek-relative?� stream-bl�stream-contents�stream-contents*�stream-copy�stream-copy*�stream-element-type�stream-flush� stream-length�stream-lines� stream-nl�stream-print�stream-read�stream-read-into�stream-read-partial�stream-read-partial-into�stream-read-partial-unsafe�stream-read-unsafe�stream-read-until�stream-read1� stream-readln�stream-seek�stream-seekable?�stream-tell�stream-write� stream-write1� tell-input�tell-output�with-error-stream�with-error-stream*�with-error>output�with-input-output+error-streams� with-input-output+error-streams*�with-input-stream�with-input-stream*�with-output-stream�with-output-stream*�with-output>error�with-output+error-stream�with-output+error-stream*�with-streams� with-streams*�write�write1�1string�<string>�>string� resize-string�string�string?�1vector�<vector>�>vector�?push�vector�vector?�<condition>�<continuation>� <restart>�attempt-all�attempt-all-error�attempt-all-error?�callback-error-hook�callcc0�callcc1�cleanup�compute-restarts� condition� condition?�continuation� continuation?�continue�continue-restart� continue-with�current-continuation�error�error-continuation�error-in-thread�error-thread�ifcc� ignore-errors�in-callback?�original-error�recover�restart�restart?�restarts�rethrow�rethrow-restarts�return�return-continuation�thread-error-hook�throw-continue�throw-restarts�with-datastack�with-returnz#!.*$�basez\s+z&((?:MACRO|MEMO|TYPED)?:[:]?)(\s+)(\S+)z(M:[:]?)(\s+)(\S+)(\s+)(\S+)z(C:)(\s+)(\S+)(\s+)(\S+)z(GENERIC:)(\s+)(\S+)z$(HOOK:|GENERIC#)(\s+)(\S+)(\s+)(\S+)z\(\s�stackeffectz;\sz (USING:)(\s+)�vocabsz&(USE:|UNUSE:|IN:|QUALIFIED:)(\s+)(\S+)z%(QUALIFIED-WITH:)(\s+)(\S+)(\s+)(\S+)z#(FROM:|EXCLUDE:)(\s+)(\S+)(\s+=>\s)r z,(RENAME:)(\s+)(\S+)(\s+)(\S+)(\s+=>\s+)(\S+)z%(ALIAS:|TYPEDEF:)(\s+)(\S+)(\s+)(\S+)z$(DEFER:|FORGET:|POSTPONE:)(\s+)(\S+)z'(TUPLE:|ERROR:)(\s+)(\S+)(\s+<\s+)(\S+)�slotsz"(TUPLE:|ERROR:|BUILTIN:)(\s+)(\S+)z'(MIXIN:|UNION:|INTERSECTION:)(\s+)(\S+)z$(PREDICATE:)(\s+)(\S+)(\s+<\s+)(\S+)z(INSTANCE:)(\s+)(\S+)(\s+)(\S+)z(SLOT:)(\s+)(\S+)z(SINGLETON:)(\s+)(\S+)zSINGLETONS:�classesz)(CONSTANT:|SYMBOL:|MAIN:|HELP:)(\s+)(\S+)z SYMBOLS:\sz SYNTAX:\szALIEN:\sz(STRUCT:)(\s+)(\S+)z.(FUNCTION:)(\s+\S+\s+)(\S+)(\s+\(\s+[^)]+\)\s)z>(FUNCTION-ALIAS:)(\s+)(\S+)(\s+\S+\s+)(\S+)(\s+\(\s+[^)]+\)\s)z(?:<PRIVATE|PRIVATE>)\sz"""\s(?:.|\n)*?\s"""z"(?:\\\\|\\"|[^"])*"z\S+"\s+(?:\\\\|\\"|[^"])*"z%CHAR:\s+(?:\\[\\abfnrstv]|[^\\]\S*)\sz!\s+.*$z#!\s+.*$z/\*\s+(?:.|\n)*?\s\*/\sz[tf]\sz[\\$]\s+\S+zM\\\s+\S+\s+\S+z9[+-]?(?:[\d,]*\d)?\.(?:\d([\d,]*\d)?)?(?:[eE][+-]?\d+)?\sz'[+-]?\d(?:[\d,]*\d)?(?:[eE][+-]?\d+)?\sz<0x[a-fA-F\d](?:[a-fA-F\d,]*[a-fA-F\d])?(?:p\d([\d,]*\d)?)?\szANAN:\s+[a-fA-F\d](?:[a-fA-F\d,]*[a-fA-F\d])?(?:p\d([\d,]*\d)?)?\sz 0b[01]+\sz 0o[0-7]+\sz5(?:\d([\d,]*\d)?)?\+\d(?:[\d,]*\d)?/\d(?:[\d,]*\d)?\sz7(?:\-\d([\d,]*\d)?)?\-\d(?:[\d,]*\d)?/\d(?:[\d,]*\d)?\sz:(?:deprecated|final|foldable|flushable|inline|recursive)\sz\S+z\(\s+z\)\sz#popz--\sz(\{\s+)(\S+)(\s[^}]+\s\}\s))�rootr� r� r� r� r� r N)or r r r r r r r r r r r r r r r r r r r r! r"