rouge 3.18.0

data/lib/rouge/lexers/fortran.rb

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+# vim: set ts=2 sw=2 et:
+
+# TODO: Implement format list support.
+
+module Rouge
+  module Lexers
+    class Fortran < RegexLexer
+      title "Fortran"
+      desc "Fortran 2008 (free-form)"
+
+      tag 'fortran'
+      filenames '*.f', '*.f90', '*.f95', '*.f03', '*.f08',
+                '*.F', '*.F90', '*.F95', '*.F03', '*.F08'
+      mimetypes 'text/x-fortran'
+
+      name = /[A-Z][_A-Z0-9]*/i
+      kind_param = /(\d+|#{name})/
+      exponent = /[ED][+-]?\d+/i
+
+      def self.keywords
+        # Special rules for two-word keywords are defined further down.
+        # Note: Fortran allows to omit whitespace between certain keywords.
+        @keywords ||= Set.new %w(
+          abstract allocatable allocate assign assignment associate asynchronous
+          backspace bind block blockdata call case class close codimension
+          common concurrent contains contiguous continue critical cycle data
+          deallocate deferred dimension do elemental else elseif elsewhere end
+          endassociate endblock endblockdata enddo endenum endfile endforall
+          endfunction endif endinterface endmodule endprogram endselect
+          endsubmodule endsubroutine endtype endwhere endwhile entry enum
+          enumerator equivalence exit extends external final flush forall format
+          function generic goto if implicit import in include inout inquire
+          intent interface intrinsic is lock module namelist non_overridable
+          none nopass nullify only open operator optional out parameter pass
+          pause pointer print private procedure program protected public pure
+          read recursive result return rewind save select selectcase sequence
+          stop submodule subroutine target then type unlock use value volatile
+          wait where while write
+        )
+      end
+
+      def self.types
+        # A special rule for the two-word version "double precision" is
+        # defined further down.
+        @types ||= Set.new %w(
+          character complex doubleprecision integer logical real
+        )
+      end
+
+      def self.intrinsics
+        @intrinsics ||= Set.new %w(
+          abs achar acos acosh adjustl adjustr aimag aint all allocated anint
+          any asin asinh associated atan atan2 atanh atomic_define atomic_ref
+          bessel_j0 bessel_j1 bessel_jn bessel_y0 bessel_y1 bessel_yn bge bgt
+          bit_size ble blt btest c_associated c_f_pointer c_f_procpointer
+          c_funloc c_loc c_sizeof ceiling char cmplx command_argument_count
+          compiler_options compiler_version conjg cos cosh count cpu_time cshift
+          date_and_time dble digits dim dot_product dprod dshiftl dshiftr
+          eoshift epsilon erf erfc_scaled erfc execute_command_line exp exponent
+          extends_type_of findloc floor fraction gamma get_command_argument
+          get_command get_environment_variable huge hypot iachar iall iand iany
+          ibclr ibits ibset ichar ieee_class ieee_copy_sign ieee_get_flag
+          ieee_get_halting_mode ieee_get_rounding_mode ieee_get_status
+          ieee_get_underflow_mode ieee_is_finite ieee_is_nan ieee_is_normal
+          ieee_logb ieee_next_after ieee_rem ieee_rint ieee_scalb
+          ieee_selected_real_kind ieee_set_flag ieee_set_halting_mode
+          ieee_set_rounding_mode ieee_set_status ieee_set_underflow_mode
+          ieee_support_datatype ieee_support_denormal ieee_support_divide
+          ieee_support_flag ieee_support_halting ieee_support_inf
+          ieee_support_io ieee_support_nan ieee_support_rounding
+          ieee_support_sqrt ieee_support_standard ieee_support_underflow_control
+          ieee_unordered ieee_value ieor image_index index int ior iparity
+          is_contiguous is_iostat_end is_iostat_eor ishft ishftc kind lbound
+          lcobound leadz len_trim len lge lgt lle llt log_gamma log log10
+          logical maskl maskr matmul max maxexponent maxloc maxval merge_bits
+          merge min minexponent minloc minval mod modulo move_alloc mvbits
+          nearest new_line nint norm2 not null num_images pack parity popcnt
+          poppar present product radix random_number random_seed range real
+          repeat reshape rrspacing same_type_as scale scan selected_char_kind
+          selected_int_kind selected_real_kind set_exponent shape shifta shiftl
+          shiftr sign sin sinh size spacing spread sqrt storage_size sum
+          system_clock tan tanh this_image tiny trailz transfer transpose trim
+          ubound ucobound unpack verify
+        )
+      end
+
+      state :root do
+        rule %r/[\s]+/, Text::Whitespace
+        rule %r/!.*$/, Comment::Single
+        rule %r/^#.*$/, Comment::Preproc
+
+        rule %r/::|[()\/;,:&\[\]]/, Punctuation
+
+        # TODO: This does not take into account line continuation.
+        rule %r/^(\s*)([0-9]+)\b/m do |m|
+          token Text::Whitespace, m[1]
+          token Name::Label, m[2]
+        end
+
+        # Format statements are quite a strange beast.
+        # Better process them in their own state.
+        rule %r/\b(FORMAT)(\s*)(\()/mi do |m|
+          token Keyword, m[1]
+          token Text::Whitespace, m[2]
+          token Punctuation, m[3]
+          push :format_spec
+        end
+
+        rule %r(
+          [+-]? # sign
+          (
+            (\d+[.]\d*|[.]\d+)(#{exponent})?
+            | \d+#{exponent} # exponent is mandatory
+          )
+          (_#{kind_param})? # kind parameter
+        )xi, Num::Float
+
+        rule %r/[+-]?\d+(_#{kind_param})?/i, Num::Integer
+        rule %r/B'[01]+'|B"[01]+"/i, Num::Bin
+        rule %r/O'[0-7]+'|O"[0-7]+"/i, Num::Oct
+        rule %r/Z'[0-9A-F]+'|Z"[0-9A-F]+"/i, Num::Hex
+        rule %r/(#{kind_param}_)?'/, Str::Single, :string_single
+        rule %r/(#{kind_param}_)?"/, Str::Double, :string_double
+        rule %r/[.](TRUE|FALSE)[.](_#{kind_param})?/i, Keyword::Constant
+
+        rule %r{\*\*|//|==|/=|<=|>=|=>|[-+*/<>=%]}, Operator
+        rule %r/\.(?:EQ|NE|LT|LE|GT|GE|NOT|AND|OR|EQV|NEQV|[A-Z]+)\./i, Operator::Word
+
+        # Special rules for two-word keywords and types.
+        # Note: "doubleprecision" is covered by the normal keyword rule.
+        rule %r/double\s+precision\b/i, Keyword::Type
+        rule %r/go\s+to\b/i, Keyword
+        rule %r/sync\s+(all|images|memory)\b/i, Keyword
+        rule %r/error\s+stop\b/i, Keyword
+
+        rule %r/#{name}/m do |m|
+          match = m[0].downcase
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.types.include? match
+            token Keyword::Type
+          elsif self.class.intrinsics.include? match
+            token Name::Builtin
+          else
+            token Name
+          end
+        end
+
+      end
+
+      state :string_single do
+        rule %r/[^']+/, Str::Single
+        rule %r/''/, Str::Escape
+        rule %r/'/, Str::Single, :pop!
+      end
+
+      state :string_double do
+        rule %r/[^"]+/, Str::Double
+        rule %r/""/, Str::Escape
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      state :format_spec do
+        rule %r/'/, Str::Single, :string_single
+        rule %r/"/, Str::Double, :string_double
+        rule %r/\(/, Punctuation, :format_spec
+        rule %r/\)/, Punctuation, :pop!
+        rule %r/,/, Punctuation
+        rule %r/[\s]+/, Text::Whitespace
+        # Edit descriptors could be seen as a kind of "format literal".
+        rule %r/[^\s'"(),]+/, Literal
+      end
+    end
+  end
+end

data/lib/rouge/lexers/freefem.rb

@@ -0,0 +1,240 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    load_lexer 'cpp.rb'
+
+    class FreeFEM < Cpp
+      title "FreeFEM"
+      desc "The FreeFEM programming language (freefem.org)"
+
+      tag 'freefem'
+      aliases 'ff'
+      filenames '*.edp', '*.idp'
+      mimetypes 'text/x-ffhdr', 'text/x-ffsrc'
+
+      # Override C/C++ ones (for example, `do` does not exists)
+      def self.keywords
+        @keywords ||= Set.new(%w(
+          break catch continue else for if return try while
+        ))
+      end
+
+      # Override C/C++ ones (for example, `double` does not exists)
+      def self.keywords_type
+        @keywords_type ||= Set.new(%w(
+          bool border complex dmatrix fespace func gslspline ifstream int macro
+          matrix mesh mesh3 mpiComm mpiGroup mpiRequest NewMacro EndMacro
+          ofstream Pmmap problem Psemaphore real solve string varf
+        ))
+      end
+
+      # Override C/C++ ones (totally different)
+      def self.reserved
+        @reserved ||= Set.new(%w(
+          BDM1 BDM1Ortho Edge03d Edge13d Edge23d FEQF HCT P0 P03d P0Edge P1
+          P13d P1b P1b3d P1bl P1bl3d P1dc P1Edge P1nc P2 P23d P2b P2BR P2dc
+          P2Edge P2h P2Morley P2pnc P3 P3dc P3Edge P4 P4dc P4Edge P5Edge RT0
+          RT03d RT0Ortho RT1 RT1Ortho RT2 RT2Ortho
+
+          qf1pE qf1pElump qf1pT qf1pTlump qfV1 qfV1lump qf2pE qf2pT qf2pT4P1
+          qfV2 qf3pE qf4pE qf5pE qf5pT qfV5 qf7pT qf9pT qfnbpE
+
+          ARGV append area be binary BoundaryEdge bordermeasure CG Cholesky cin
+          cout Crout default diag edgeOrientation endl FILE fixed GMRES good
+          hTriangle im imax imin InternalEdge l1 l2 label lenEdge length LINE
+          linfty LU m max measure min mpiAnySource mpiBAND mpiBXOR mpiCommWorld
+          mpiLAND mpiLOR mpiLXOR mpiMAX mpiMIN mpiPROD mpirank mpisize mpiSUM
+          mpiUndefined n N nbe ndof ndofK noshowbase noshowpos notaregion nt
+          nTonEdge nuEdge nuTriangle nv P pi precision quantile re region
+          scientific searchMethod setw showbase showpos sparsesolver sum tellp
+          true UMFPACK unused whoinElement verbosity version volume x y z
+        ))
+      end
+
+      def self.builtins
+        @builtins ||= Set.new(%w(
+          abs acos acosh adaptmesh adj AffineCG AffineGMRES arg asin asinh
+          assert atan atan2 atanh atof atoi BFGS broadcast buildlayers
+          buildmesh ceil chi complexEigenValue copysign change checkmovemesh
+          clock cmaes conj convect cos cosh cube d dd dfft diffnp diffpos
+          dimKrylov dist dumptable dx dxx dxy dxz dy dyx dyy dyz dz dzx dzy dzz
+          EigenValue emptymesh erf erfc exec exit exp fdim ffind find floor
+          flush fmax fmin fmod freeyams getARGV getline gmshload gmshload3
+          gslcdfugaussianP gslcdfugaussianQ gslcdfugaussianPinv
+          gslcdfugaussianQinv gslcdfgaussianP gslcdfgaussianQ
+          gslcdfgaussianPinv gslcdfgaussianQinv gslcdfgammaP gslcdfgammaQ
+          gslcdfgammaPinv gslcdfgammaQinv gslcdfcauchyP gslcdfcauchyQ
+          gslcdfcauchyPinv gslcdfcauchyQinv gslcdflaplaceP gslcdflaplaceQ
+          gslcdflaplacePinv gslcdflaplaceQinv gslcdfrayleighP gslcdfrayleighQ
+          gslcdfrayleighPinv gslcdfrayleighQinv gslcdfchisqP gslcdfchisqQ
+          gslcdfchisqPinv gslcdfchisqQinv gslcdfexponentialP gslcdfexponentialQ
+          gslcdfexponentialPinv gslcdfexponentialQinv gslcdfexppowP
+          gslcdfexppowQ gslcdftdistP gslcdftdistQ gslcdftdistPinv
+          gslcdftdistQinv gslcdffdistP gslcdffdistQ gslcdffdistPinv
+          gslcdffdistQinv gslcdfbetaP gslcdfbetaQ gslcdfbetaPinv gslcdfbetaQinv
+          gslcdfflatP gslcdfflatQ gslcdfflatPinv gslcdfflatQinv
+          gslcdflognormalP gslcdflognormalQ gslcdflognormalPinv
+          gslcdflognormalQinv gslcdfgumbel1P gslcdfgumbel1Q gslcdfgumbel1Pinv
+          gslcdfgumbel1Qinv gslcdfgumbel2P gslcdfgumbel2Q gslcdfgumbel2Pinv
+          gslcdfgumbel2Qinv gslcdfweibullP gslcdfweibullQ gslcdfweibullPinv
+          gslcdfweibullQinv gslcdfparetoP gslcdfparetoQ gslcdfparetoPinv
+          gslcdfparetoQinv gslcdflogisticP gslcdflogisticQ gslcdflogisticPinv
+          gslcdflogisticQinv gslcdfbinomialP gslcdfbinomialQ gslcdfpoissonP
+          gslcdfpoissonQ gslcdfgeometricP gslcdfgeometricQ
+          gslcdfnegativebinomialP gslcdfnegativebinomialQ gslcdfpascalP
+          gslcdfpascalQ gslinterpakima gslinterpakimaperiodic
+          gslinterpcsplineperiodic gslinterpcspline gslinterpsteffen
+          gslinterplinear gslinterppolynomial gslranbernoullipdf gslranbeta
+          gslranbetapdf gslranbinomialpdf gslranexponential
+          gslranexponentialpdf gslranexppow gslranexppowpdf gslrancauchy
+          gslrancauchypdf gslranchisq gslranchisqpdf gslranerlang
+          gslranerlangpdf gslranfdist gslranfdistpdf gslranflat gslranflatpdf
+          gslrangamma gslrangammaint gslrangammapdf gslrangammamt
+          gslrangammaknuth gslrangaussian gslrangaussianratiomethod
+          gslrangaussianziggurat gslrangaussianpdf gslranugaussian
+          gslranugaussianratiomethod gslranugaussianpdf gslrangaussiantail
+          gslrangaussiantailpdf gslranugaussiantail gslranugaussiantailpdf
+          gslranlandau gslranlandaupdf gslrangeometricpdf gslrangumbel1
+          gslrangumbel1pdf gslrangumbel2 gslrangumbel2pdf gslranlogistic
+          gslranlogisticpdf gslranlognormal gslranlognormalpdf
+          gslranlogarithmicpdf gslrannegativebinomialpdf gslranpascalpdf
+          gslranpareto gslranparetopdf gslranpoissonpdf gslranrayleigh
+          gslranrayleighpdf gslranrayleightail gslranrayleightailpdf
+          gslrantdist gslrantdistpdf gslranlaplace gslranlaplacepdf gslranlevy
+          gslranweibull gslranweibullpdf gslsfairyAi gslsfairyBi
+          gslsfairyAiscaled gslsfairyBiscaled gslsfairyAideriv gslsfairyBideriv
+          gslsfairyAiderivscaled gslsfairyBiderivscaled gslsfairyzeroAi
+          gslsfairyzeroBi gslsfairyzeroAideriv gslsfairyzeroBideriv
+          gslsfbesselJ0 gslsfbesselJ1 gslsfbesselJn gslsfbesselY0 gslsfbesselY1
+          gslsfbesselYn gslsfbesselI0 gslsfbesselI1 gslsfbesselIn
+          gslsfbesselI0scaled gslsfbesselI1scaled gslsfbesselInscaled
+          gslsfbesselK0 gslsfbesselK1 gslsfbesselKn gslsfbesselK0scaled
+          gslsfbesselK1scaled gslsfbesselKnscaled gslsfbesselj0 gslsfbesselj1
+          gslsfbesselj2 gslsfbesseljl gslsfbessely0 gslsfbessely1 gslsfbessely2
+          gslsfbesselyl gslsfbesseli0scaled gslsfbesseli1scaled
+          gslsfbesseli2scaled gslsfbesselilscaled gslsfbesselk0scaled
+          gslsfbesselk1scaled gslsfbesselk2scaled gslsfbesselklscaled
+          gslsfbesselJnu gslsfbesselYnu gslsfbesselInuscaled gslsfbesselInu
+          gslsfbesselKnuscaled gslsfbesselKnu gslsfbessellnKnu
+          gslsfbesselzeroJ0 gslsfbesselzeroJ1 gslsfbesselzeroJnu gslsfclausen
+          gslsfhydrogenicR1 gslsfdawson gslsfdebye1 gslsfdebye2 gslsfdebye3
+          gslsfdebye4 gslsfdebye5 gslsfdebye6 gslsfdilog gslsfmultiply
+          gslsfellintKcomp gslsfellintEcomp gslsfellintPcomp gslsfellintDcomp
+          gslsfellintF gslsfellintE gslsfellintRC gslsferfc gslsflogerfc
+          gslsferf gslsferfZ gslsferfQ gslsfhazard gslsfexp gslsfexpmult
+          gslsfexpm1 gslsfexprel gslsfexprel2 gslsfexpreln gslsfexpintE1
+          gslsfexpintE2 gslsfexpintEn gslsfexpintE1scaled gslsfexpintE2scaled
+          gslsfexpintEnscaled gslsfexpintEi gslsfexpintEiscaled gslsfShi
+          gslsfChi gslsfexpint3 gslsfSi gslsfCi gslsfatanint gslsffermidiracm1
+          gslsffermidirac0 gslsffermidirac1 gslsffermidirac2 gslsffermidiracint
+          gslsffermidiracmhalf gslsffermidirachalf gslsffermidirac3half
+          gslsffermidiracinc0 gslsflngamma gslsfgamma gslsfgammastar
+          gslsfgammainv gslsftaylorcoeff gslsffact gslsfdoublefact gslsflnfact
+          gslsflndoublefact gslsflnchoose gslsfchoose gslsflnpoch gslsfpoch
+          gslsfpochrel gslsfgammaincQ gslsfgammaincP gslsfgammainc gslsflnbeta
+          gslsfbeta gslsfbetainc gslsfgegenpoly1 gslsfgegenpoly2
+          gslsfgegenpoly3 gslsfgegenpolyn gslsfhyperg0F1 gslsfhyperg1F1int
+          gslsfhyperg1F1 gslsfhypergUint gslsfhypergU gslsfhyperg2F0
+          gslsflaguerre1 gslsflaguerre2 gslsflaguerre3 gslsflaguerren
+          gslsflambertW0 gslsflambertWm1 gslsflegendrePl gslsflegendreP1
+          gslsflegendreP2 gslsflegendreP3 gslsflegendreQ0 gslsflegendreQ1
+          gslsflegendreQl gslsflegendrePlm gslsflegendresphPlm
+          gslsflegendrearraysize gslsfconicalPhalf gslsfconicalPmhalf
+          gslsfconicalP0 gslsfconicalP1 gslsfconicalPsphreg gslsfconicalPcylreg
+          gslsflegendreH3d0 gslsflegendreH3d1 gslsflegendreH3d gslsflog
+          gslsflogabs gslsflog1plusx gslsflog1plusxmx gslsfpowint gslsfpsiint
+          gslsfpsi gslsfpsi1piy gslsfpsi1int gslsfpsi1 gslsfpsin
+          gslsfsynchrotron1 gslsfsynchrotron2 gslsftransport2 gslsftransport3
+          gslsftransport4 gslsftransport5 gslsfsin gslsfcos gslsfhypot
+          gslsfsinc gslsflnsinh gslsflncosh gslsfanglerestrictsymm
+          gslsfanglerestrictpos gslsfzetaint gslsfzeta gslsfzetam1
+          gslsfzetam1int gslsfhzeta gslsfetaint gslsfeta imag int1d int2d int3d
+          intalledges intallfaces interpolate invdiff invdiffnp invdiffpos
+          Isend isInf isNaN isoline Irecv j0 j1 jn jump lgamma LinearCG
+          LinearGMRES log log10 lrint lround max mean medit min mmg3d movemesh
+          movemesh23 mpiAlltoall mpiAlltoallv mpiAllgather mpiAllgatherv
+          mpiAllReduce mpiBarrier mpiGather mpiGatherv mpiRank mpiReduce
+          mpiScatter mpiScatterv mpiSize mpiWait mpiWaitAny mpiWtick mpiWtime
+          mshmet NLCG on plot polar Post pow processor processorblock
+          projection randinit randint31 randint32 random randreal1 randreal2
+          randreal3 randres53 Read readmesh readmesh3 Recv rfind rint round
+          savemesh savesol savevtk seekg Sent set sign signbit sin sinh sort
+          splitComm splitmesh sqrt square srandom srandomdev Stringification
+          swap system tan tanh tellg tetg tetgconvexhull tetgreconstruction
+          tetgtransfo tgamma triangulate trunc Wait Write y0 y1 yn
+        ))
+      end
+
+      def self.attributes
+        @builtinsParameters ||= Set.new(%w(
+          A A1 abserror absolute aniso aspectratio B B1 bb beginend bin
+          boundary bw close cmm coef composante cutoff datafilename dataname
+          dim distmax displacement doptions dparams eps err errg facemerge
+          facetcl factorize file fill fixedborder flabel flags floatmesh
+          floatsol fregion gradation grey hmax hmin holelist hsv init inquire
+          inside IsMetric iso ivalue keepbackvertices label labeldown labelmid
+          labelup levelset loptions lparams maxit maxsubdiv meditff mem memory
+          metric mode nbarrow nbiso nbiter nbjacoby nboffacetcl nbofholes
+          nbofregions nbregul nbsmooth nbvx ncv nev nomeshgeneration
+          normalization omega op optimize option options order orientation
+          periodic power precon prev ps ptmerge qfe qforder qft qfV ratio
+          rawvector reffacelow reffacemid reffaceup refnum reftet reftri region
+          regionlist renumv rescaling ridgeangle save sigma sizeofvolume
+          smoothing solver sparams split splitin2 splitpbedge stop strategy
+          swap switch sym t tgv thetamax tol tolpivot tolpivotsym transfo U2Vc
+          value varrow vector veps viso wait width withsurfacemesh WindowIndex
+          which zbound
+        ))
+      end
+
+      id = /[a-z_]\w*/i
+
+      state :expr_bol do
+        mixin :inline_whitespace
+
+        rule %r/include/, Comment::Preproc, :macro
+        rule %r/load/, Comment::Preproc, :macro
+        rule %r/ENDIFMACRO/, Comment::Preproc, :macro
+        rule %r/IFMACRO/, Comment::Preproc, :macro
+
+        rule(//) { pop! }
+      end
+
+      state :statements do
+        mixin :whitespace
+        rule %r/(u8|u|U|L)?"/, Str, :string
+        rule %r((u8|u|U|L)?'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\'\n])')i, Str::Char
+        rule %r((\d+[.]\d*|[.]?\d+)e[+-]?\d+[lu]*)i, Num::Float
+        rule %r(\d+e[+-]?\d+[lu]*)i, Num::Float
+        rule %r/0x[0-9a-f]+[lu]*/i, Num::Hex
+        rule %r/0[0-7]+[lu]*/i, Num::Oct
+        rule %r/\d+[lu]*/i, Num::Integer
+        rule %r(\*/), Error
+        rule %r([~!%^&*+=\|?:<>/-]), Operator
+        rule %r/'/, Operator
+        rule %r/[()\[\],.;]/, Punctuation
+        rule %r/\bcase\b/, Keyword, :case
+        rule %r/(?:true|false|NaN)\b/, Name::Builtin
+        rule id do |m|
+          name = m[0]
+
+          if self.class.keywords.include? name
+            token Keyword
+          elsif self.class.keywords_type.include? name
+            token Keyword::Type
+          elsif self.class.reserved.include? name
+            token Keyword::Reserved
+          elsif self.class.builtins.include? name
+            token Name::Builtin
+          elsif self.class.attributes.include? name
+            token Name::Attribute
+          else
+            token Name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rouge/lexers/fsharp.rb

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class FSharp < RegexLexer
+      title "FSharp"
+      desc 'F# (fsharp.net)'
+      tag 'fsharp'
+      filenames '*.fs', '*.fsi', '*.fsx'
+      mimetypes 'application/fsharp-script', 'text/x-fsharp', 'text/x-fsi'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          abstract and as assert base begin class default delegate do
+          done downcast downto elif else end exception extern false
+          finally for fun function global if in inherit inline interface
+          internal lazy let let! match member module mutable namespace
+          new not null of open or override private public rec return
+          return! select static struct then to true try type upcast
+          use use! val void when while with yield yield! sig atomic
+          break checked component const constraint constructor
+          continue eager event external fixed functor include method
+          mixin object parallel process protected pure sealed tailcall
+          trait virtual volatile
+        )
+      end
+
+      def self.keyopts
+        @keyopts ||= Set.new %w(
+          != # & && ( ) * \+ , - -. -> . .. : :: := :> ; ;; < <- =
+          > >] >} ? ?? [ [< [> [| ] _ ` { {< | |] } ~ |> <| <>
+        )
+      end
+
+      def self.word_operators
+        @word_operators ||= Set.new %w(and asr land lor lsl lxor mod or)
+      end
+
+      def self.primitives
+        @primitives ||= Set.new %w(unit int float bool string char list array)
+      end
+
+      operator = %r([\[\];,{}_()!$%&*+./:<=>?@^|~#-]+)
+      id = /([a-z][\w']*)|(``[^`\n\r\t]+``)/i
+      upper_id = /[A-Z][\w']*/
+
+      state :root do
+        rule %r/\s+/m, Text
+        rule %r/false|true|[(][)]|\[\]/, Name::Builtin::Pseudo
+        rule %r/#{upper_id}(?=\s*[.])/, Name::Namespace, :dotted
+        rule upper_id, Name::Class
+        rule %r/[(][*](?![)])/, Comment, :comment
+        rule %r(//.*?$), Comment::Single
+        rule id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.word_operators.include? match
+            token Operator::Word
+          elsif self.class.primitives.include? match
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        rule operator do |m|
+          match = m[0]
+          if self.class.keyopts.include? match
+            token Punctuation
+          else
+            token Operator
+          end
+        end
+
+        rule %r/-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
+        rule %r/0x\h[\h_]*/i, Num::Hex
+        rule %r/0o[0-7][0-7_]*/i, Num::Oct
+        rule %r/0b[01][01_]*/i, Num::Bin
+        rule %r/\d[\d_]*/, Num::Integer
+
+        rule %r/'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
+        rule %r/'[.]'/, Str::Char
+        rule %r/'/, Keyword
+        rule %r/"/, Str::Double, :string
+        rule %r/[~?]#{id}/, Name::Variable
+      end
+
+      state :comment do
+        rule %r/[^(*)]+/, Comment
+        rule(/[(][*]/) { token Comment; push }
+        rule %r/[*][)]/, Comment, :pop!
+        rule %r/[(*)]/, Comment
+      end
+
+      state :string do
+        rule %r/[^\\"]+/, Str::Double
+        mixin :escape_sequence
+        rule %r/\\\n/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      state :escape_sequence do
+        rule %r/\\[\\"'ntbr]/, Str::Escape
+        rule %r/\\\d{3}/, Str::Escape
+        rule %r/\\x\h{2}/, Str::Escape
+      end
+
+      state :dotted do
+        rule %r/\s+/m, Text
+        rule %r/[.]/, Punctuation
+        rule %r/#{upper_id}(?=\s*[.])/, Name::Namespace
+        rule upper_id, Name::Class, :pop!
+        rule id, Name, :pop!
+        rule %r/\[/, Punctuation, :pop!
+      end
+    end
+  end
+end