rouge 3.27.0 → 3.29.0

data/lib/rouge/lexers/rust.rb

@@ -22,10 +22,13 @@ module Rouge
 
       def self.keywords
         @keywords ||= %w(
-          as assert async await break crate const continue copy do drop dyn else enum extern
-          fail false fn for if impl let log loop macro match mod move mut priv pub pure
-          ref return self Self static struct super true try trait type union unsafe use
-          where while yield box
+          as async await break const continue crate dyn else enum extern false
+          fn for if impl in let log loop match mod move mut pub ref return self
+          Self static struct super trait true type unsafe use where while
+          abstract become box do final macro
+          override priv typeof unsized virtual
+          yield try
+          union
         )
       end
 
@@ -212,7 +215,8 @@ module Rouge
 
       state :has_literals do
         # constants
-        rule %r/\b(?:true|false|nil)\b/, Keyword::Constant
+        rule %r/\b(?:true|false)\b/, Keyword::Constant
+
         # characters/bytes
         rule %r(
           b?' (?: #{escapes} | [^\\] ) '

data/lib/rouge/lexers/sparql.rb

@@ -41,16 +41,17 @@ module Rouge
         rule %r('''), Str::Single, :string_single_literal
         rule %r('), Str::Single, :string_single
 
-        rule %r([$?]\w+), Name::Variable
-        rule %r((\w*:)(\w+)?) do |m|
+        rule %r([$?][[:word:]]+), Name::Variable
+        rule %r(([[:word:]-]*)(:)([[:word:]-]+)?) do |m|
           token Name::Namespace, m[1]
-          token Str::Symbol, m[2]
+          token Operator, m[2]
+          token Str::Symbol, m[3]
         end
         rule %r(<[^>]*>), Name::Namespace
         rule %r(true|false)i, Keyword::Constant
         rule %r/a\b/, Keyword
 
-        rule %r([A-Z]\w+\b)i do |m|
+        rule %r([A-Z][[:word:]]+\b)i do |m|
           if self.class.builtins.include? m[0].upcase
             token Name::Builtin
           elsif self.class.keywords.include? m[0].upcase

data/lib/rouge/lexers/sqf/keywords.rb

@@ -9,4 +9,4 @@ module Rouge
       end
     end
   end
-end
+end

data/lib/rouge/lexers/stan.rb

@@ -0,0 +1,451 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Stan < RegexLexer
+      title "Stan"
+      desc 'Stan Modeling Language (mc-stan.org)'
+      tag 'stan'
+      filenames '*.stan', '*.stanfunctions'
+
+      # optional comment or whitespace
+      WS = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
+      ID = /[a-zA-Z_][a-zA-Z0-9_]*/
+      RT = /(?:(?:[a-z_]\s*(?:\[[0-9, ]\])?)\s+)*/
+      OP = Regexp.new([
+        # Assigment operators
+        "=",
+
+        # Comparison operators
+        "<", "<=", ">", ">=", "==", "!=",
+
+        # Boolean operators
+        "!", "&&", "\\|\\|",
+
+        # Real-valued arithmetic operators
+        "\\+", "-", "\\*", "/", "\\^",
+
+        # Transposition operator
+        "'",
+
+        # Elementwise functions
+        "\\.\\+", "\\.-", "\\.\\*", "\\./", "\\.\\^",
+
+        # Matrix division operators
+        "\\\\",
+
+        # Compound assigment operators
+        "\\+=", "-=", "\\*=", "/=", "\\.\\*=", "\\./=",
+
+        # Sampling
+        "~",
+
+        # Conditional operator
+        "\\?", ":"
+      ].join("|"))
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          if else while for break continue print reject return
+        )
+      end
+
+      def self.types
+        @types ||= Set.new %w(
+          int real vector ordered positive_ordered simplex unit_vector
+          row_vector matrix cholesky_factor_corr cholesky_factor_cov corr_matrix
+          cov_matrix data void complex array
+        )
+      end
+
+      def self.reserved
+        @reserved ||= Set.new [
+          # Reserved words from Stan language
+          "for", "in", "while", "repeat", "until", "if", "then", "else", "true",
+          "false", "target", "functions", "model", "data", "parameters",
+          "quantities", "transformed", "generated",
+
+          # Reserved names from Stan implementation
+          "var", "fvar", "STAN_MAJOR", "STAN_MINOR", "STAN_PATCH",
+          "STAN_MATH_MAJOR", "STAN_MATH_MINOR", "STAN_MATH_PATCH",
+
+          # Reserved names from C++
+          "alignas", "alignof", "and", "and_eq", "asm", "auto", "bitand",
+          "bitor", "bool", "break", "case", "catch", "char", "char16_t",
+          "char32_t", "class", "compl", "const", "constexpr", "const_cast",
+          "continue", "decltype", "default", "delete", "do", "double",
+          "dynamic_cast", "else", "enum", "explicit", "export", "extern",
+          "false", "float", "for", "friend", "goto", "if", "inline", "int",
+          "long", "mutable", "namespace", "new", "noexcept", "not", "not_eq",
+          "nullptr", "operator", "or", "or_eq", "private", "protected",
+          "public", "register", "reinterpret_cast", "return", "short", "signed",
+          "sizeof", "static", "static_assert", "static_cast", "struct",
+          "switch", "template", "this", "thread_local", "throw", "true", "try",
+          "typedef", "typeid", "typename", "union", "unsigned", "using",
+          "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq"
+        ]
+      end
+
+      def self.builtin_functions
+        @builtin_functions ||= Set.new [
+          # Integer-Valued Basic Functions
+
+          ## Absolute functions
+          "abs", "int_step",
+
+          ## Bound functions
+          "min", "max",
+
+          ## Size functions
+          "size",
+
+          # Real-Valued Basic Functions
+
+          ## Log probability function
+          "target", "get_lp",
+
+          ## Logical functions
+          "step", "is_inf", "is_nan",
+
+          ## Step-like functions
+          "fabs", "fdim", "fmin", "fmax", "fmod", "floor", "ceil", "round",
+          "trunc",
+
+          ## Power and logarithm functions
+          "sqrt", "cbrt", "square", "exp", "exp2", "log", "log2", "log10",
+          "pow", "inv", "inv_sqrt", "inv_square",
+
+          ## Trigonometric functions
+          "hypot", "cos", "sin", "tan", "acos", "asin", "atan", "atan2",
+
+          ## Hyperbolic trigonometric functions
+          "cosh", "sinh", "tanh", "acosh", "asinh", "atanh",
+
+          ## Link functions
+          "logit", "inv_logit", "inv_cloglog",
+
+          ## Probability-related functions
+          "erf", "erfc", "Phi", "inv_Phi", "Phi_approx", "binary_log_loss",
+          "owens_t",
+
+          ## Combinatorial functions
+          "beta", "inc_beta", "lbeta", "tgamma", "lgamma", "digamma",
+          "trigamma", "lmgamma", "gamma_p", "gamma_q",
+          "binomial_coefficient_log", "choose", "bessel_first_kind",
+          "bessel_second_kind", "modified_bessel_first_kind",
+          "log_modified_bessel_first_kind", "modified_bessel_second_kind",
+          "falling_factorial", "lchoose", "log_falling_factorial",
+          "rising_factorial", "log_rising_factorial",
+
+          ## Composed functions
+          "expm1", "fma", "multiply_log", "ldexp", "lmultiply", "log1p",
+          "log1m", "log1p_exp", "log1m_exp", "log_diff_exp", "log_mix",
+          "log_sum_exp", "log_inv_logit", "log_inv_logit_diff",
+          "log1m_inv_logit",
+
+          ## Special functions
+          "lambert_w0", "lambert_wm1",
+
+          # Complex-Valued Basic Functions
+
+          ## Complex constructors and accessors
+          "to_complex", "get_real", "get_imag",
+
+          ## Complex special functions
+          "arg", "norm", "conj", "proj", "polar",
+
+          # Array Operations
+
+          ## Reductions
+          "sum", "prod", "log_sum_exp", "mean", "variance", "sd", "distance",
+          "squared_distance", "quantile",
+
+          ## Array size and dimension function
+          "dims", "num_elements",
+
+          ## Array broadcasting
+          "rep_array",
+
+          ## Array concatenation
+          "append_array",
+
+          ## Sorting functions
+          "sort_asc", "sort_desc", "sort_indices_asc", "sort_indices_desc",
+          "rank",
+
+          ## Reversing functions
+          "reverse",
+
+          # Matrix Operations
+
+          ## Integer-valued matrix size functions
+          "num_elements", "rows", "cols",
+
+          ## Dot products and specialized products
+          "dot_product", "columns_dot_product", "rows_dot_product", "dot_self",
+          "columns_dot_self", "rows_dot_self", "tcrossprod", "crossprod",
+          "quad_form", "quad_form_diag", "quad_form_sym", "trace_quad_form",
+          "trace_gen_quad_form", "multiply_lower_tri_self_transpose",
+          "diag_pre_multiply", "diag_post_multiply",
+
+          ## Broadcast functions
+          "rep_vector", "rep_row_vector", "rep_matrix",
+          "symmetrize_from_lower_tri",
+
+          ## Diagonal matrix functions
+          "add_diag", "diagonal", "diag_matrix", "identity_matrix",
+
+          ## Container construction functions
+          "linspaced_array", "linspaced_int_array", "linspaced_vector",
+          "linspaced_row_vector", "one_hot_int_array", "one_hot_array",
+          "one_hot_vector", "one_hot_row_vector", "ones_int_array",
+          "ones_array", "ones_vector", "ones_row_vector", "zeros_int_array",
+          "zeros_array", "zeros_vector", "zeros_row_vector", "uniform_simplex",
+
+          ## Slicing and blocking functions
+          "col", "row", "block", "sub_col", "sub_row", "head", "tail",
+          "segment",
+
+          ## Matrix concatenation
+          "append_col", "append_row",
+
+          ## Special matrix functions
+          "softmax", "log_softmax", "cumulative_sum",
+
+          ## Covariance functions
+          "cov_exp_quad",
+
+          ## Linear algebra functions and solvers
+          "mdivide_left_tri_low", "mdivide_right_tri_low", "mdivide_left_spd",
+          "mdivide_right_spd", "matrix_exp", "matrix_exp_multiply",
+          "scale_matrix_exp_multiply", "matrix_power", "trace", "determinant",
+          "log_determinant", "inverse", "inverse_spd", "chol2inv",
+          "generalized_inverse", "eigenvalues_sym", "eigenvectors_sym",
+          "qr_thin_Q", "qr_thin_R", "qr_Q", "qr_R", "cholseky_decompose",
+          "singular_values", "svd_U", "svd_V",
+
+          # Sparse Matrix Operations
+
+          ## Conversion functions
+          "csr_extract_w", "csr_extract_v", "csr_extract_u",
+          "csr_to_dense_matrix",
+
+          ## Sparse matrix arithmetic
+          "csr_matrix_times_vector",
+
+          # Mixed Operations
+          "to_matrix", "to_vector", "to_row_vector", "to_array_2d",
+          "to_array_1d",
+
+          # Higher-Order Functions
+
+          ## Algebraic equation solver
+          "algebra_solver", "algebra_solver_newton",
+
+          ## Ordinary differential equation
+          "ode_rk45", "ode_rk45_tol", "ode_ckrk", "ode_ckrk_tol", "ode_adams",
+          "ode_adams_tol", "ode_bdf", "ode_bdf_tol", "ode_adjoint_tol_ctl",
+
+          ## 1D integrator
+          "integrate_1d",
+
+          ## Reduce-sum function
+          "reduce_sum", "reduce_sum_static",
+
+          ## Map-rect function
+          "map_rect",
+
+          # Deprecated Functions
+          "integrate_ode_rk45", "integrate_ode", "integrate_ode_adams",
+          "integrate_ode_bdf",
+
+          # Hidden Markov Models
+          "hmm_marginal", "hmm_latent_rng", "hmm_hidden_state_prob"
+        ]
+      end
+
+      def self.distributions
+        @distributions ||= Set.new(
+          [
+            # Discrete Distributions
+
+            ## Binary Distributions
+            "bernoulli", "bernoulli_logit", "bernoulli_logit_glm",
+
+            ## Bounded Discrete Distributions
+            "binomial", "binomial_logit", "beta_binomial", "hypergeometric",
+            "categorical", "categorical_logit_glm", "discrete_range",
+            "ordered_logistic", "ordered_logistic_glm", "ordered_probit",
+
+            ## Unbounded Discrete Distributions
+            "neg_binomial", "neg_binomial_2", "neg_binomial_2_log",
+            "neg_binomial_2_log_glm", "poisson", "poisson_log",
+            "poisson_log_glm",
+
+            ## Multivariate Discrete Distributions
+            "multinomial", "multinomial_logit",
+
+            # Continuous Distributions
+
+            ## Unbounded Continuous Distributions
+            "normal", "std_normal", "normal_id_glm", "exp_mod_normal",
+            "skew_normal", "student_t", "cauchy", "double_exponential",
+            "logistic", "gumbel", "skew_double_exponential",
+
+            ## Positive Continuous Distributions
+            "lognormal", "chi_square", "inv_chi_square",
+            "scaled_inv_chi_square", "exponential", "gamma", "inv_gamma",
+            "weibull", "frechet", "rayleigh",
+
+            ## Positive Lower-Bounded Distributions
+            "pareto", "pareto_type_2", "wiener",
+
+            ## Continuous Distributions on [0, 1]
+            "beta", "beta_proportion",
+
+            ## Circular Distributions
+            "von_mises",
+
+            ## Bounded Continuous Distributions
+            "uniform",
+
+            ## Distributions over Unbounded Vectors
+            "multi_normal", "multi_normal_prec", "multi_normal_cholesky",
+            "multi_gp", "multi_gp_cholesky", "multi_student_t",
+            "gaussian_dlm_obs",
+
+            ## Simplex Distributions
+            "dirichlet",
+
+            ## Correlation Matrix Distributions
+            "lkj_corr", "lkj_corr_cholesky",
+
+            ## Covariance Matrix Distributions
+            "wishart", "inv_wishart"
+          ].product([
+            "", "_lpmf", "_lupmf", "_lpdf", "_lcdf", "_lccdf", "_rng", "_log",
+            "_cdf_log", "_ccdf_log"
+          ]).map {|s| "#{s[0]}#{s[1]}"}
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new [
+          # Mathematical constants
+          "pi", "e", "sqrt2", "log2", "log10",
+
+          # Special values
+          "not_a_number", "positive_infinity", "negative_infinity",
+          "machine_precision"
+        ]
+      end
+
+      state :root do
+        mixin :whitespace
+        rule %r/#include/, Comment::Preproc, :include
+        rule %r/#.*$/, Generic::Deleted
+        rule %r(
+          functions
+          |(?:transformed\s+)?data
+          |(?:transformed\s+)?parameters
+          |model
+          |generated\s+quantities
+        )x, Name::Namespace
+        rule %r(\{), Punctuation, :bracket_scope
+        mixin :scope
+      end
+
+      state :include do
+        rule %r((\s+)(\S+)(\s*)) do |m|
+          token Text, m[1]                          
+          token Comment::PreprocFile, m[2]           
+          token Text, m[3]
+          pop!
+        end
+      end
+
+      state :whitespace do
+        rule %r(\n+)m, Text
+        rule %r(//(\\.|.)*?$), Comment::Single
+        mixin :inline_whitespace
+      end
+
+      state :inline_whitespace do
+        rule %r([ \t\r]+), Text
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+      end
+
+      state :statements do
+        mixin :whitespace
+        rule %r/#include/, Comment::Preproc, :include
+        rule %r/#.*$/, Generic::Deleted
+        rule %r("), Str, :string
+        rule %r(
+          (
+            ((\d+[.]\d*|[.]?\d+)e[+-]?\d+|\d*[.]\d+|\d+) 
+            (#{WS})[+-](#{WS})
+            ((\d+[.]\d*|[.]?\d+)e[+-]?\d+|\d*[.]\d+|\d+)i
+          )
+          |((\d+[.]\d*|[.]?\d+)e[+-]?\d+|\d*[.]\d+|\d+)i
+          |((\d+[.]\d*|[.]?\d+)e[+-]?\d+|\d*[.]\d+) 
+        )mx, Num::Float
+        rule %r/\d+/, Num::Integer
+        rule %r(\*/), Error
+        rule OP, Operator
+        rule %r([\[\],.;]), Punctuation
+        rule %r([|](?![|])), Punctuation
+        rule %r(T\b), Keyword::Reserved
+        rule %r((lower|upper)\b), Name::Attribute
+        rule ID do |m|
+          name = m[0]
+
+          if self.class.keywords.include? name
+            token Keyword
+          elsif self.class.types.include? name
+            token Keyword::Type
+          elsif self.class.reserved.include? name
+            token Keyword::Reserved
+          else
+            token Name::Variable
+          end
+        end
+      end
+
+      state :scope do
+        mixin :whitespace
+        rule %r(
+          (#{RT})         # Return type
+          (#{ID})         # Function name
+          (?=\([^;]*?\))  # Signature or arguments
+        )mx do |m|
+          recurse m[1]
+
+          name = m[2]
+          if self.class.builtin_functions.include? name
+            token Name::Builtin, name
+          elsif self.class.distributions.include? name
+            token Name::Builtin, name
+          elsif self.class.constants.include? name
+            token Keyword::Constant
+          else
+            token Name::Function, name
+          end
+        end
+        rule %r(\{), Punctuation, :bracket_scope
+        rule %r(\(), Punctuation, :parens_scope
+        mixin :statements
+      end
+
+      state :bracket_scope do
+        mixin :scope
+        rule %r(\}), Punctuation, :pop!
+      end
+
+      state :parens_scope do
+        mixin :scope
+        rule %r(\)), Punctuation, :pop!
+      end
+    end
+  end
+end

data/lib/rouge/lexers/stata.rb

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class Stata < RegexLexer
+      title "Stata"
+      desc "The Stata programming language (www.stata.com)"
+      tag 'stata'
+      filenames '*.do', '*.ado'
+      mimetypes 'application/x-stata', 'text/x-stata'
+
+      ###
+      # Stata reference manual is available online at: https://www.stata.com/features/documentation/
+      ###
+
+      # Partial list of common programming and estimation commands, as of Stata 16
+      # Note: not all abbreviations are included
+      KEYWORDS = %w(
+        do run include clear assert set mata log
+        by bys bysort cap capt capture char class classutil which cdir confirm new existence creturn
+        _datasignature discard di dis disp displ displa display ereturn error _estimates exit file open read write seek close query findfile fvexpand
+        gettoken java home heapmax java_heapmax icd9 icd9p icd10 icd10cm icd10pcs initialize javacall levelsof
+        tempvar tempname tempfile macro shift uniq dups retokenize clean sizeof posof
+        makecns matcproc marksample mark markout markin svymarkout matlist
+        accum define dissimilarity eigenvalues get rowjoinbyname rownames score svd symeigen dir list ren rename
+        more pause plugin call postfile _predict preserve restore program define drop end python qui quietly noi noisily _return return _rmcoll rmsg _robust
+        serset locale_functions locale_ui signestimationsample checkestimationsample sleep syntax sysdir adopath adosize
+        tabdisp timer tokenize trace unab unabcmd varabbrev version viewsource
+        window fopen fsave manage menu push stopbox
+        net from cd link search install sj stb ado update uninstall pwd ssc ls
+        using insheet outsheet mkmat svmat sum summ summarize
+        graph gr_edit twoway histogram kdensity spikeplot
+        mi miss missing var varname order compress append
+        gen gene gener genera generat generate egen replace duplicates
+        estimates nlcom lincom test testnl predict suest
+        _regress reg regr regre regres regress probit logit ivregress logistic svy gmm ivprobit ivtobit
+        bsample assert codebook collapse compare contract copy count cross datasignature d ds desc describe destring tostring
+        drawnorm edit encode decode erase expand export filefilter fillin format frame frget frlink gsort
+        import dbase delimited excel fred haver sas sasxport5 sasxport8 spss infile infix input insobs inspect ipolate isid
+        joinby label language labelbook lookfor memory mem merge mkdir mvencode notes obs odbc order outfile
+        pctile xtile _pctile putmata range recast recode rename group reshape rm rmdir sample save saveold separate shell snapshot sort split splitsample stack statsby sysuse
+        type unicode use varmanage vl webuse xpose zipfile
+        number keep tab table tabulate stset stcox tsset xtset
+      )
+
+      # Complete list of functions by name, as of Stata 16
+      PRIMITIVE_FUNCTIONS = %w(
+        abbrev abs acos acosh age age_frac asin asinh atan atan2 atanh autocode
+        betaden binomial binomialp binomialtail binormal birthday bofd byteorder
+        c _caller cauchy cauchyden cauchytail Cdhms ceil char chi2 chi2den chi2tail Chms
+        chop cholesky clip Clock clock clockdiff cloglog Cmdyhms Cofc cofC Cofd cofd coleqnumb
+        collatorlocale collatorversion colnfreeparms colnumb colsof comb cond corr cos cosh
+        daily date datediff datediff_frac day det dgammapda dgammapdada dgammapdadx dgammapdxdx dhms
+        diag diag0cnt digamma dofb dofC dofc dofh dofm dofq dofw dofy dow doy dunnettprob e el epsdouble
+        epsfloat exp expm1 exponential exponentialden exponentialtail
+        F Fden fileexists fileread filereaderror filewrite float floor fmtwidth frval _frval Ftail
+        fammaden gammap gammaptail get hadamard halfyear halfyearly has_eprop hh hhC hms hofd hours
+        hypergeometric hypergeometricp
+        I ibeta ibetatail igaussian igaussianden igaussiantail indexnot inlist inrange int inv invbinomial invbinomialtail
+        invcauchy invcauchytail invchi2 invchi2tail invcloglog invdunnettprob invexponential invexponentialtail invF
+        invFtail invgammap invgammaptail invibeta invibetatail invigaussian invigaussiantail invlaplace invlaplacetail
+        invlogistic invlogistictail invlogit invnbinomial invnbinomialtail invnchi2 invnchi2tail invnF invnFtail invnibeta invnormal invnt invnttail
+        invpoisson invpoissontail invsym invt invttail invtukeyprob invweibull invweibullph invweibullphtail invweibulltail irecode islepyear issymmetric
+        J laplace laplaceden laplacetail ln ln1m ln1p lncauchyden lnfactorial lngamma lnigammaden lnigaussianden lniwishartden lnlaplaceden lnmvnormalden
+        lnnormal lnnormalden lnnormalden lnnormalden lnwishartden log log10 log1m log1p logistic logisticden logistictail logit
+        matmissing matrix matuniform max maxbyte maxdouble maxfloat maxint maxlong mdy mdyhms mi min minbyte mindouble minfloat minint minlong minutes
+        missing mm mmC mod mofd month monthly mreldif msofhours msofminutes msofseconds
+        nbetaden nbinomial nbinomialp nbinomialtail nchi2 nchi2den nchi2tail nextbirthday nextleapyear nF nFden nFtail nibeta
+        normal normalden npnchi2 npnF npnt nt ntden nttail nullmat
+        plural poisson poissonp poissontail previousbirthday previousleapyear qofd quarter quarterly r rbeta rbinomial rcauchy rchi2 recode
+        real regexm regexr regexs reldif replay return rexponential rgamma rhypergeometric rigaussian rlaplace rlogistic rnormal
+        round roweqnumb rownfreeparms rownumb rowsof rpoisson rt runiform runiformint rweibull rweibullph
+        s scalar seconds sign sin sinh smallestdouble soundex soundex_nara sqrt ss ssC strcat strdup string stritrim strlen strlower
+        strltrim strmatch strofreal strpos strproper strreverse strrpos strrtrim strtoname strtrim strupper subinstr subinword substr sum sweep
+        t tan tanh tC tc td tden th tin tm tobytes tq trace trigamma trunc ttail tukeyprob tw twithin
+        uchar udstrlen udsubstr uisdigit uisletter uniform ustrcompare ustrcompareex ustrfix ustrfrom ustrinvalidcnt ustrleft ustrlen ustrlower
+        ustrltrim ustrnormalize ustrpos ustrregexm ustrregexra ustrregexrf ustrregexs ustrreverse ustrright ustrrpos ustrrtrim ustrsortkey
+        ustrsortkeyex ustrtitle ustrto ustrtohex ustrtoname ustrtrim ustrunescape ustrupper ustrword ustrwordcount usubinstr usubstr
+        vec vecdiag week weekly weibull weibullden weibullph weibullphden weibullphtail weibulltail wofd word wordbreaklocale wordcount
+        year yearly yh ym yofd yq yw
+      )
+
+      # Note: types `str1-str2045` handled separately below
+      def self.type_keywords
+        @type_keywords ||= Set.new %w(byte int long float double str strL numeric string integer scalar matrix local global numlist varlist newlist)
+      end
+
+      # Stata commands used with braces. Includes all valid abbreviations for 'forvalues'.
+      def self.reserved_keywords
+        @reserved_keywords ||= Set.new %w(if else foreach forv forva forval forvalu forvalue forvalues to while in of continue break nobreak)
+      end
+
+      ###
+      # Lexer state and rules
+      ###
+      state :root do
+
+        # Pre-processor commands: #
+        rule %r/^\s*#.*$/, Comment::Preproc
+
+        # Hashbang comments: *!
+        rule %r/^\*!.*$/, Comment::Hashbang
+
+        # Single-line comment: *
+        rule %r/^\s*\*.*$/, Comment::Single
+
+        # Keywords: recognize only when they are the first word
+        rule %r/^\s*(#{KEYWORDS.join('|')})\b/, Keyword
+
+        # Whitespace. Classify `\n` as `Text` to avoid interference with `Comment` and `Keyword` above
+        rule(/[ \t]+/, Text::Whitespace)
+        rule(/[\n\r]+/, Text)
+
+        # In-line comment: //
+        rule %r/\/\/.*?$/, Comment::Single
+
+        # Multi-line comment: /* and */
+        rule %r(/(\\\n)?[*].*?[*](\\\n)?/)m, Comment::Multiline
+
+        # Strings indicated by compound double-quotes (`""') and double-quotes ("")
+        rule %r/`"(\\.|.)*?"'/, Str::Double
+        rule %r/"(\\.|.)*?"/, Str::Double
+
+        # Format locals (`') and globals ($) as strings
+        rule %r/`(\\.|.)*?'/, Str::Double
+        rule %r/(?<!\w)\$\w+/, Str::Double
+
+        # Display formats
+        rule %r/\%\S+/, Name::Property
+
+        # Additional string types: str1-str2045
+        rule %r/\bstr(204[0-5]|20[0-3][0-9]|[01][0-9][0-9][0-9]|[0-9][0-9][0-9]|[0-9][0-9]|[1-9])\b/, Keyword::Type
+
+        # Only recognize primitive functions when they are actually used as a function call, i.e. followed by an opening parenthesis
+        # `Name::Builtin` would be more logical, but is not usually highlighted, so use `Name::Function` instead
+        rule %r/\b(#{PRIMITIVE_FUNCTIONS.join('|')})(?=\()/, Name::Function
+
+        # Matrix operator `..` (declare here instead of with other operators, in order to avoid conflict with numbers below)
+        rule %r/\.\.(?=.*\])/, Operator
+
+        # Numbers
+        rule %r/[+-]?(\d+([.]\d+)?|[.]\d+)([eE][+-]?\d+)?/, Num
+
+        # Factor variable and time series operators
+        rule %r/\b[ICOicoLFDSlfds]\w*\./, Operator
+        rule %r/\b[ICOicoLFDSlfds]\w*(?=\(.*\)\.)/, Operator
+
+        rule %r/\w+/ do |m|
+          if self.class.reserved_keywords.include? m[0]
+            token Keyword::Reserved
+          elsif self.class.type_keywords.include? m[0]
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        rule %r/[\[\]{}();,]/, Punctuation
+
+        rule %r([-<>?*+'^/\\!#.=~:&|]), Operator
+      end
+    end
+  end
+end

data/lib/rouge/lexers/supercollider.rb

@@ -113,4 +113,3 @@ module Rouge
     end
   end
 end
-