pygments.rb 1.1.1 → 2.0.0.rc3

data/vendor/pygments-main/pygments/lexers/qvt.py

@@ -5,7 +5,7 @@
 
     Lexer for QVT Operational language.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -126,7 +126,7 @@ class QVToLexer(RegexLexer):
             (r'[^\\\'"\n]+', String),
             # quotes, percents and backslashes must be parsed one at a time
             (r'[\'"\\]', String),
-            ],
+        ],
         'stringescape': [
             (r'\\([\\btnfr"\']|u[0-3][0-7]{2}|u[0-7]{1,2})', String.Escape)
         ],
@@ -134,15 +134,15 @@ class QVToLexer(RegexLexer):
             (r'"', String, '#pop'),
             (r'\\\\|\\"', String.Escape),
             include('strings')
-            ],
+        ],
         'sqs': [  # single-quoted string
             (r"'", String, '#pop'),
             (r"\\\\|\\'", String.Escape),
             include('strings')
-            ],
+        ],
         'name': [
-            ('[a-zA-Z_]\w*', Name),
-            ],
+            (r'[a-zA-Z_]\w*', Name),
+        ],
         # numbers: excerpt taken from the python lexer
         'numbers': [
             (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float),

data/vendor/pygments-main/pygments/lexers/r.py

@@ -5,13 +5,13 @@
 
     Lexers for the R/S languages.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 import re
 
-from pygments.lexer import Lexer, RegexLexer, include, words, do_insertions
+from pygments.lexer import Lexer, RegexLexer, include, do_insertions, bygroups
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
     Number, Punctuation, Generic
 
@@ -49,9 +49,8 @@ class RConsoleLexer(Lexer):
                 # If we have stored prompt lines, need to process them first.
                 if current_code_block:
                     # Weave together the prompts and highlight code.
-                    for item in do_insertions(
-                            insertions, slexer.get_tokens_unprocessed(current_code_block)):
-                        yield item
+                    yield from do_insertions(
+                        insertions, slexer.get_tokens_unprocessed(current_code_block))
                     # Reset vars for next code block.
                     current_code_block = ''
                     insertions = []
@@ -62,9 +61,8 @@ class RConsoleLexer(Lexer):
         # process the last code block. This is neither elegant nor DRY so
         # should be changed.
         if current_code_block:
-            for item in do_insertions(
-                    insertions, slexer.get_tokens_unprocessed(current_code_block)):
-                yield item
+            yield from do_insertions(
+                insertions, slexer.get_tokens_unprocessed(current_code_block))
 
 
 class SLexer(RegexLexer):
@@ -80,286 +78,25 @@ class SLexer(RegexLexer):
     mimetypes = ['text/S-plus', 'text/S', 'text/x-r-source', 'text/x-r',
                  'text/x-R', 'text/x-r-history', 'text/x-r-profile']
 
-    builtins_base = (
-        'Arg', 'Conj', 'Cstack_info', 'Encoding', 'FALSE',
-        'Filter', 'Find', 'I', 'ISOdate', 'ISOdatetime', 'Im', 'Inf',
-        'La.svd', 'Map', 'Math.Date', 'Math.POSIXt', 'Math.data.frame',
-        'Math.difftime', 'Math.factor', 'Mod', 'NA_character_',
-        'NA_complex_', 'NA_real_', 'NCOL', 'NROW', 'NULLNA_integer_', 'NaN',
-        'Negate', 'NextMethod', 'Ops.Date', 'Ops.POSIXt', 'Ops.data.frame',
-        'Ops.difftime', 'Ops.factor', 'Ops.numeric_version', 'Ops.ordered',
-        'Position', 'R.Version', 'R.home', 'R.version', 'R.version.string',
-        'RNGkind', 'RNGversion', 'R_system_version', 'Re', 'Recall',
-        'Reduce', 'Summary.Date', 'Summary.POSIXct', 'Summary.POSIXlt',
-        'Summary.data.frame', 'Summary.difftime', 'Summary.factor',
-        'Summary.numeric_version', 'Summary.ordered', 'Sys.Date',
-        'Sys.chmod', 'Sys.getenv', 'Sys.getlocale', 'Sys.getpid',
-        'Sys.glob', 'Sys.info', 'Sys.localeconv', 'Sys.readlink',
-        'Sys.setFileTime', 'Sys.setenv', 'Sys.setlocale', 'Sys.sleep',
-        'Sys.time', 'Sys.timezone', 'Sys.umask', 'Sys.unsetenv',
-        'Sys.which', 'TRUE', 'UseMethod', 'Vectorize', 'abbreviate', 'abs',
-        'acos', 'acosh', 'addNA', 'addTaskCallback', 'agrep', 'alist',
-        'all', 'all.equal', 'all.equal.POSIXct', 'all.equal.character',
-        'all.equal.default', 'all.equal.factor', 'all.equal.formula',
-        'all.equal.language', 'all.equal.list', 'all.equal.numeric',
-        'all.equal.raw', 'all.names', 'all.vars', 'any', 'anyDuplicated',
-        'anyDuplicated.array', 'anyDuplicated.data.frame',
-        'anyDuplicated.default', 'anyDuplicated.matrix', 'aperm',
-        'aperm.default', 'aperm.table', 'append', 'apply', 'args',
-        'arrayInd', 'as.Date', 'as.Date.POSIXct', 'as.Date.POSIXlt',
-        'as.Date.character', 'as.Date.date', 'as.Date.dates',
-        'as.Date.default', 'as.Date.factor', 'as.Date.numeric',
-        'as.POSIXct', 'as.POSIXct.Date', 'as.POSIXct.POSIXlt',
-        'as.POSIXct.date', 'as.POSIXct.dates', 'as.POSIXct.default',
-        'as.POSIXct.numeric', 'as.POSIXlt', 'as.POSIXlt.Date',
-        'as.POSIXlt.POSIXct', 'as.POSIXlt.character', 'as.POSIXlt.date',
-        'as.POSIXlt.dates', 'as.POSIXlt.default', 'as.POSIXlt.factor',
-        'as.POSIXlt.numeric', 'as.array', 'as.array.default', 'as.call',
-        'as.character', 'as.character.Date', 'as.character.POSIXt',
-        'as.character.condition', 'as.character.default',
-        'as.character.error', 'as.character.factor', 'as.character.hexmode',
-        'as.character.numeric_version', 'as.character.octmode',
-        'as.character.srcref', 'as.complex', 'as.data.frame',
-        'as.data.frame.AsIs', 'as.data.frame.Date', 'as.data.frame.POSIXct',
-        'as.data.frame.POSIXlt', 'as.data.frame.array',
-        'as.data.frame.character', 'as.data.frame.complex',
-        'as.data.frame.data.frame', 'as.data.frame.default',
-        'as.data.frame.difftime', 'as.data.frame.factor',
-        'as.data.frame.integer', 'as.data.frame.list',
-        'as.data.frame.logical', 'as.data.frame.matrix',
-        'as.data.frame.model.matrix', 'as.data.frame.numeric',
-        'as.data.frame.numeric_version', 'as.data.frame.ordered',
-        'as.data.frame.raw', 'as.data.frame.table', 'as.data.frame.ts',
-        'as.data.frame.vector', 'as.difftime', 'as.double',
-        'as.double.POSIXlt', 'as.double.difftime', 'as.environment',
-        'as.expression', 'as.expression.default', 'as.factor',
-        'as.function', 'as.function.default', 'as.hexmode', 'as.integer',
-        'as.list', 'as.list.Date', 'as.list.POSIXct', 'as.list.data.frame',
-        'as.list.default', 'as.list.environment', 'as.list.factor',
-        'as.list.function', 'as.list.numeric_version', 'as.logical',
-        'as.logical.factor', 'as.matrix', 'as.matrix.POSIXlt',
-        'as.matrix.data.frame', 'as.matrix.default', 'as.matrix.noquote',
-        'as.name', 'as.null', 'as.null.default', 'as.numeric',
-        'as.numeric_version', 'as.octmode', 'as.ordered',
-        'as.package_version', 'as.pairlist', 'as.qr', 'as.raw', 'as.single',
-        'as.single.default', 'as.symbol', 'as.table', 'as.table.default',
-        'as.vector', 'as.vector.factor', 'asNamespace', 'asS3', 'asS4',
-        'asin', 'asinh', 'assign', 'atan', 'atan2', 'atanh',
-        'attachNamespace', 'attr', 'attr.all.equal', 'attributes',
-        'autoload', 'autoloader', 'backsolve', 'baseenv', 'basename',
-        'besselI', 'besselJ', 'besselK', 'besselY', 'beta',
-        'bindingIsActive', 'bindingIsLocked', 'bindtextdomain', 'bitwAnd',
-        'bitwNot', 'bitwOr', 'bitwShiftL', 'bitwShiftR', 'bitwXor', 'body',
-        'bquote', 'browser', 'browserCondition', 'browserSetDebug',
-        'browserText', 'builtins', 'by', 'by.data.frame', 'by.default',
-        'bzfile', 'c.Date', 'c.POSIXct', 'c.POSIXlt', 'c.noquote',
-        'c.numeric_version', 'call', 'callCC', 'capabilities', 'casefold',
-        'cat', 'category', 'cbind', 'cbind.data.frame', 'ceiling',
-        'char.expand', 'charToRaw', 'charmatch', 'chartr', 'check_tzones',
-        'chol', 'chol.default', 'chol2inv', 'choose', 'class',
-        'clearPushBack', 'close', 'close.connection', 'close.srcfile',
-        'close.srcfilealias', 'closeAllConnections', 'col', 'colMeans',
-        'colSums', 'colnames', 'commandArgs', 'comment', 'computeRestarts',
-        'conditionCall', 'conditionCall.condition', 'conditionMessage',
-        'conditionMessage.condition', 'conflicts', 'contributors', 'cos',
-        'cosh', 'crossprod', 'cummax', 'cummin', 'cumprod', 'cumsum', 'cut',
-        'cut.Date', 'cut.POSIXt', 'cut.default', 'dQuote', 'data.class',
-        'data.matrix', 'date', 'debug', 'debugonce',
-        'default.stringsAsFactors', 'delayedAssign', 'deparse', 'det',
-        'determinant', 'determinant.matrix', 'dget', 'diag', 'diff',
-        'diff.Date', 'diff.POSIXt', 'diff.default', 'difftime', 'digamma',
-        'dim', 'dim.data.frame', 'dimnames', 'dimnames.data.frame', 'dir',
-        'dir.create', 'dirname', 'do.call', 'dput', 'drop', 'droplevels',
-        'droplevels.data.frame', 'droplevels.factor', 'dump', 'duplicated',
-        'duplicated.POSIXlt', 'duplicated.array', 'duplicated.data.frame',
-        'duplicated.default', 'duplicated.matrix',
-        'duplicated.numeric_version', 'dyn.load', 'dyn.unload', 'eapply',
-        'eigen', 'else', 'emptyenv', 'enc2native', 'enc2utf8',
-        'encodeString', 'enquote', 'env.profile', 'environment',
-        'environmentIsLocked', 'environmentName', 'eval', 'eval.parent',
-        'evalq', 'exists', 'exp', 'expand.grid', 'expm1', 'expression',
-        'factor', 'factorial', 'fifo', 'file', 'file.access', 'file.append',
-        'file.choose', 'file.copy', 'file.create', 'file.exists',
-        'file.info', 'file.link', 'file.path', 'file.remove', 'file.rename',
-        'file.show', 'file.symlink', 'find.package', 'findInterval',
-        'findPackageEnv', 'findRestart', 'floor', 'flush',
-        'flush.connection', 'force', 'formals', 'format',
-        'format.AsIs', 'format.Date', 'format.POSIXct', 'format.POSIXlt',
-        'format.data.frame', 'format.default', 'format.difftime',
-        'format.factor', 'format.hexmode', 'format.info',
-        'format.libraryIQR', 'format.numeric_version', 'format.octmode',
-        'format.packageInfo', 'format.pval', 'format.summaryDefault',
-        'formatC', 'formatDL', 'forwardsolve', 'gamma', 'gc', 'gc.time',
-        'gcinfo', 'gctorture', 'gctorture2', 'get', 'getAllConnections',
-        'getCallingDLL', 'getCallingDLLe', 'getConnection',
-        'getDLLRegisteredRoutines', 'getDLLRegisteredRoutines.DLLInfo',
-        'getDLLRegisteredRoutines.character', 'getElement',
-        'getExportedValue', 'getHook', 'getLoadedDLLs', 'getNamespace',
-        'getNamespaceExports', 'getNamespaceImports', 'getNamespaceInfo',
-        'getNamespaceName', 'getNamespaceUsers', 'getNamespaceVersion',
-        'getNativeSymbolInfo', 'getOption', 'getRversion', 'getSrcLines',
-        'getTaskCallbackNames', 'geterrmessage', 'gettext', 'gettextf',
-        'getwd', 'gl', 'globalenv', 'gregexpr', 'grep', 'grepRaw', 'grepl',
-        'gsub', 'gzcon', 'gzfile', 'head', 'iconv', 'iconvlist',
-        'icuSetCollate', 'identical', 'identity', 'ifelse', 'importIntoEnv',
-        'in', 'inherits', 'intToBits', 'intToUtf8', 'interaction', 'interactive',
-        'intersect', 'inverse.rle', 'invisible', 'invokeRestart',
-        'invokeRestartInteractively', 'is.R', 'is.array', 'is.atomic',
-        'is.call', 'is.character', 'is.complex', 'is.data.frame',
-        'is.double', 'is.element', 'is.environment', 'is.expression',
-        'is.factor', 'is.finite', 'is.function', 'is.infinite',
-        'is.integer', 'is.language', 'is.list', 'is.loaded', 'is.logical',
-        'is.matrix', 'is.na', 'is.na.POSIXlt', 'is.na.data.frame',
-        'is.na.numeric_version', 'is.name', 'is.nan', 'is.null',
-        'is.numeric', 'is.numeric.Date', 'is.numeric.POSIXt',
-        'is.numeric.difftime', 'is.numeric_version', 'is.object',
-        'is.ordered', 'is.package_version', 'is.pairlist', 'is.primitive',
-        'is.qr', 'is.raw', 'is.recursive', 'is.single', 'is.symbol',
-        'is.table', 'is.unsorted', 'is.vector', 'isBaseNamespace',
-        'isIncomplete', 'isNamespace', 'isOpen', 'isRestart', 'isS4',
-        'isSeekable', 'isSymmetric', 'isSymmetric.matrix', 'isTRUE',
-        'isatty', 'isdebugged', 'jitter', 'julian', 'julian.Date',
-        'julian.POSIXt', 'kappa', 'kappa.default', 'kappa.lm', 'kappa.qr',
-        'kronecker', 'l10n_info', 'labels', 'labels.default', 'lapply',
-        'lazyLoad', 'lazyLoadDBexec', 'lazyLoadDBfetch', 'lbeta', 'lchoose',
-        'length', 'length.POSIXlt', 'letters', 'levels', 'levels.default',
-        'lfactorial', 'lgamma', 'library.dynam', 'library.dynam.unload',
-        'licence', 'license', 'list.dirs', 'list.files', 'list2env', 'load',
-        'loadNamespace', 'loadedNamespaces', 'loadingNamespaceInfo',
-        'local', 'lockBinding', 'lockEnvironment', 'log', 'log10', 'log1p',
-        'log2', 'logb', 'lower.tri', 'ls', 'make.names', 'make.unique',
-        'makeActiveBinding', 'mapply', 'margin.table', 'mat.or.vec',
-        'match', 'match.arg', 'match.call', 'match.fun', 'max', 'max.col',
-        'mean', 'mean.Date', 'mean.POSIXct', 'mean.POSIXlt', 'mean.default',
-        'mean.difftime', 'mem.limits', 'memCompress', 'memDecompress',
-        'memory.profile', 'merge', 'merge.data.frame', 'merge.default',
-        'message', 'mget', 'min', 'missing', 'mode', 'month.abb',
-        'month.name', 'months', 'months.Date', 'months.POSIXt',
-        'months.abb', 'months.nameletters', 'names', 'names.POSIXlt',
-        'namespaceExport', 'namespaceImport', 'namespaceImportClasses',
-        'namespaceImportFrom', 'namespaceImportMethods', 'nargs', 'nchar',
-        'ncol', 'new.env', 'ngettext', 'nlevels', 'noquote', 'norm',
-        'normalizePath', 'nrow', 'numeric_version', 'nzchar', 'objects',
-        'oldClass', 'on.exit', 'open', 'open.connection', 'open.srcfile',
-        'open.srcfilealias', 'open.srcfilecopy', 'options', 'order',
-        'ordered', 'outer', 'packBits', 'packageEvent',
-        'packageHasNamespace', 'packageStartupMessage', 'package_version',
-        'pairlist', 'parent.env', 'parent.frame', 'parse',
-        'parseNamespaceFile', 'paste', 'paste0', 'path.expand',
-        'path.package', 'pipe', 'pmatch', 'pmax', 'pmax.int', 'pmin',
-        'pmin.int', 'polyroot', 'pos.to.env', 'pretty', 'pretty.default',
-        'prettyNum', 'print', 'print.AsIs', 'print.DLLInfo',
-        'print.DLLInfoList', 'print.DLLRegisteredRoutines', 'print.Date',
-        'print.NativeRoutineList', 'print.POSIXct', 'print.POSIXlt',
-        'print.by', 'print.condition', 'print.connection',
-        'print.data.frame', 'print.default', 'print.difftime',
-        'print.factor', 'print.function', 'print.hexmode',
-        'print.libraryIQR', 'print.listof', 'print.noquote',
-        'print.numeric_version', 'print.octmode', 'print.packageInfo',
-        'print.proc_time', 'print.restart', 'print.rle',
-        'print.simple.list', 'print.srcfile', 'print.srcref',
-        'print.summary.table', 'print.summaryDefault', 'print.table',
-        'print.warnings', 'prmatrix', 'proc.time', 'prod', 'prop.table',
-        'provideDimnames', 'psigamma', 'pushBack', 'pushBackLength', 'q',
-        'qr', 'qr.Q', 'qr.R', 'qr.X', 'qr.coef', 'qr.default', 'qr.fitted',
-        'qr.qty', 'qr.qy', 'qr.resid', 'qr.solve', 'quarters',
-        'quarters.Date', 'quarters.POSIXt', 'quit', 'quote', 'range',
-        'range.default', 'rank', 'rapply', 'raw', 'rawConnection',
-        'rawConnectionValue', 'rawShift', 'rawToBits', 'rawToChar', 'rbind',
-        'rbind.data.frame', 'rcond', 'read.dcf', 'readBin', 'readChar',
-        'readLines', 'readRDS', 'readRenviron', 'readline', 'reg.finalizer',
-        'regexec', 'regexpr', 'registerS3method', 'registerS3methods',
-        'regmatches', 'remove', 'removeTaskCallback', 'rep', 'rep.Date',
-        'rep.POSIXct', 'rep.POSIXlt', 'rep.factor', 'rep.int',
-        'rep.numeric_version', 'rep_len', 'replace', 'replicate',
-        'requireNamespace', 'restartDescription', 'restartFormals',
-        'retracemem', 'rev', 'rev.default', 'rle', 'rm', 'round',
-        'round.Date', 'round.POSIXt', 'row', 'row.names',
-        'row.names.data.frame', 'row.names.default', 'rowMeans', 'rowSums',
-        'rownames', 'rowsum', 'rowsum.data.frame', 'rowsum.default',
-        'sQuote', 'sample', 'sample.int', 'sapply', 'save', 'save.image',
-        'saveRDS', 'scale', 'scale.default', 'scan', 'search',
-        'searchpaths', 'seek', 'seek.connection', 'seq', 'seq.Date',
-        'seq.POSIXt', 'seq.default', 'seq.int', 'seq_along', 'seq_len',
-        'sequence', 'serialize', 'set.seed', 'setHook', 'setNamespaceInfo',
-        'setSessionTimeLimit', 'setTimeLimit', 'setdiff', 'setequal',
-        'setwd', 'shQuote', 'showConnections', 'sign', 'signalCondition',
-        'signif', 'simpleCondition', 'simpleError', 'simpleMessage',
-        'simpleWarning', 'simplify2array', 'sin', 'single',
-        'sinh', 'sink', 'sink.number', 'slice.index', 'socketConnection',
-        'socketSelect', 'solve', 'solve.default', 'solve.qr', 'sort',
-        'sort.POSIXlt', 'sort.default', 'sort.int', 'sort.list', 'split',
-        'split.Date', 'split.POSIXct', 'split.data.frame', 'split.default',
-        'sprintf', 'sqrt', 'srcfile', 'srcfilealias', 'srcfilecopy',
-        'srcref', 'standardGeneric', 'stderr', 'stdin', 'stdout', 'stop',
-        'stopifnot', 'storage.mode', 'strftime', 'strptime', 'strsplit',
-        'strtoi', 'strtrim', 'structure', 'strwrap', 'sub', 'subset',
-        'subset.data.frame', 'subset.default', 'subset.matrix',
-        'substitute', 'substr', 'substring', 'sum', 'summary',
-        'summary.Date', 'summary.POSIXct', 'summary.POSIXlt',
-        'summary.connection', 'summary.data.frame', 'summary.default',
-        'summary.factor', 'summary.matrix', 'summary.proc_time',
-        'summary.srcfile', 'summary.srcref', 'summary.table',
-        'suppressMessages', 'suppressPackageStartupMessages',
-        'suppressWarnings', 'svd', 'sweep', 'sys.call', 'sys.calls',
-        'sys.frame', 'sys.frames', 'sys.function', 'sys.load.image',
-        'sys.nframe', 'sys.on.exit', 'sys.parent', 'sys.parents',
-        'sys.save.image', 'sys.source', 'sys.status', 'system',
-        'system.file', 'system.time', 'system2', 't', 't.data.frame',
-        't.default', 'table', 'tabulate', 'tail', 'tan', 'tanh', 'tapply',
-        'taskCallbackManager', 'tcrossprod', 'tempdir', 'tempfile',
-        'testPlatformEquivalence', 'textConnection', 'textConnectionValue',
-        'toString', 'toString.default', 'tolower', 'topenv', 'toupper',
-        'trace', 'traceback', 'tracemem', 'tracingState', 'transform',
-        'transform.data.frame', 'transform.default', 'trigamma', 'trunc',
-        'trunc.Date', 'trunc.POSIXt', 'truncate', 'truncate.connection',
-        'try', 'tryCatch', 'typeof', 'unclass', 'undebug', 'union',
-        'unique', 'unique.POSIXlt', 'unique.array', 'unique.data.frame',
-        'unique.default', 'unique.matrix', 'unique.numeric_version',
-        'units', 'units.difftime', 'unix.time', 'unlink', 'unlist',
-        'unloadNamespace', 'unlockBinding', 'unname', 'unserialize',
-        'unsplit', 'untrace', 'untracemem', 'unz', 'upper.tri', 'url',
-        'utf8ToInt', 'vapply', 'version', 'warning', 'warnings', 'weekdays',
-        'weekdays.Date', 'weekdays.POSIXt', 'which', 'which.max',
-        'which.min', 'with', 'with.default', 'withCallingHandlers',
-        'withRestarts', 'withVisible', 'within', 'within.data.frame',
-        'within.list', 'write', 'write.dcf', 'writeBin', 'writeChar',
-        'writeLines', 'xor', 'xor.hexmode', 'xor.octmode',
-        'xpdrows.data.frame', 'xtfrm', 'xtfrm.AsIs', 'xtfrm.Date',
-        'xtfrm.POSIXct', 'xtfrm.POSIXlt', 'xtfrm.Surv', 'xtfrm.default',
-        'xtfrm.difftime', 'xtfrm.factor', 'xtfrm.numeric_version', 'xzfile',
-        'zapsmall'
-    )
-
+    valid_name = r'`[^`\\]*(?:\\.[^`\\]*)*`|(?:[a-zA-Z]|\.[A-Za-z_.])[\w.]*|\.'
     tokens = {
         'comments': [
             (r'#.*$', Comment.Single),
         ],
         'valid_name': [
-            (r'[a-zA-Z][\w.]*', Text),
-            # can begin with ., but not if that is followed by a digit
-            (r'\.[a-zA-Z_][\w.]*', Text),
+            (valid_name, Name),
         ],
         'punctuation': [
             (r'\[{1,2}|\]{1,2}|\(|\)|;|,', Punctuation),
         ],
         'keywords': [
-            (words(builtins_base, suffix=r'(?![\w. =])'),
-             Keyword.Pseudo),
             (r'(if|else|for|while|repeat|in|next|break|return|switch|function)'
              r'(?![\w.])',
              Keyword.Reserved),
-            (r'(array|category|character|complex|double|function|integer|list|'
-             r'logical|matrix|numeric|vector|data.frame|c)'
-             r'(?![\w.])',
-             Keyword.Type),
-            (r'(library|require|attach|detach|source)'
-             r'(?![\w.])',
-             Keyword.Namespace)
         ],
         'operators': [
             (r'<<?-|->>?|-|==|<=|>=|<|>|&&?|!=|\|\|?|\?', Operator),
-            (r'\*|\+|\^|/|!|%[^%]*%|=|~|\$|@|:{1,3}', Operator)
+            (r'\*|\+|\^|/|!|%[^%]*%|=|~|\$|@|:{1,3}', Operator),
         ],
         'builtin_symbols': [
             (r'(NULL|NA(_(integer|real|complex|character)_)?|'
@@ -379,17 +116,18 @@ class SLexer(RegexLexer):
             include('comments'),
             # whitespaces
             (r'\s+', Text),
-            (r'`.*?`', String.Backtick),
             (r'\'', String, 'string_squote'),
             (r'\"', String, 'string_dquote'),
             include('builtin_symbols'),
+            include('valid_name'),
             include('numbers'),
             include('keywords'),
             include('punctuation'),
             include('operators'),
-            include('valid_name'),
         ],
         'root': [
+            # calls:
+            (r'(%s)\s*(?=\()' % valid_name, Name.Function),
             include('statements'),
             # blocks:
             (r'\{|\}', Punctuation),
@@ -421,7 +159,7 @@ class RdLexer(RegexLexer):
     This is a very minimal implementation, highlighting little more
     than the macros. A description of Rd syntax is found in `Writing R
     Extensions <http://cran.r-project.org/doc/manuals/R-exts.html>`_
-    and `Parsing Rd files <developer.r-project.org/parseRd.pdf>`_.
+    and `Parsing Rd files <http://developer.r-project.org/parseRd.pdf>`_.
 
     .. versionadded:: 1.6
     """

data/vendor/pygments-main/pygments/lexers/rdf.py

@@ -5,7 +5,7 @@
 
     Lexers for semantic web and RDF query languages and markup.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -15,12 +15,12 @@ from pygments.lexer import RegexLexer, bygroups, default
 from pygments.token import Keyword, Punctuation, String, Number, Operator, Generic, \
     Whitespace, Name, Literal, Comment, Text
 
-__all__ = ['SparqlLexer', 'TurtleLexer']
+__all__ = ['SparqlLexer', 'TurtleLexer', 'ShExCLexer']
 
 
 class SparqlLexer(RegexLexer):
     """
-    Lexer for `SPARQL <http://www.w3.org/TR/rdf-sparql-query/>`_ query language.
+    Lexer for `SPARQL <https://www.w3.org/TR/sparql11-query/>`_ query language.
 
     .. versionadded:: 2.0
     """
@@ -31,27 +31,27 @@ class SparqlLexer(RegexLexer):
 
     # character group definitions ::
 
-    PN_CHARS_BASE_GRP = (u'a-zA-Z'
-                         u'\u00c0-\u00d6'
-                         u'\u00d8-\u00f6'
-                         u'\u00f8-\u02ff'
-                         u'\u0370-\u037d'
-                         u'\u037f-\u1fff'
-                         u'\u200c-\u200d'
-                         u'\u2070-\u218f'
-                         u'\u2c00-\u2fef'
-                         u'\u3001-\ud7ff'
-                         u'\uf900-\ufdcf'
-                         u'\ufdf0-\ufffd')
+    PN_CHARS_BASE_GRP = ('a-zA-Z'
+                         '\u00c0-\u00d6'
+                         '\u00d8-\u00f6'
+                         '\u00f8-\u02ff'
+                         '\u0370-\u037d'
+                         '\u037f-\u1fff'
+                         '\u200c-\u200d'
+                         '\u2070-\u218f'
+                         '\u2c00-\u2fef'
+                         '\u3001-\ud7ff'
+                         '\uf900-\ufdcf'
+                         '\ufdf0-\ufffd')
 
     PN_CHARS_U_GRP = (PN_CHARS_BASE_GRP + '_')
 
     PN_CHARS_GRP = (PN_CHARS_U_GRP +
                     r'\-' +
                     r'0-9' +
-                    u'\u00b7' +
-                    u'\u0300-\u036f' +
-                    u'\u203f-\u2040')
+                    '\u00b7' +
+                    '\u0300-\u036f' +
+                    '\u203f-\u2040')
 
     HEX_GRP = '0-9A-Fa-f'
 
@@ -76,8 +76,8 @@ class SparqlLexer(RegexLexer):
 
     PN_PREFIX = PN_CHARS_BASE + '(?:[' + PN_CHARS_GRP + '.]*' + PN_CHARS + ')?'
 
-    VARNAME = u'[0-9' + PN_CHARS_U_GRP + '][' + PN_CHARS_U_GRP + \
-              u'0-9\u00b7\u0300-\u036f\u203f-\u2040]*'
+    VARNAME = '[0-9' + PN_CHARS_U_GRP + '][' + PN_CHARS_U_GRP + \
+              '0-9\u00b7\u0300-\u036f\u203f-\u2040]*'
 
     PERCENT = '%' + HEX + HEX
 
@@ -97,12 +97,12 @@ class SparqlLexer(RegexLexer):
         'root': [
             (r'\s+', Text),
             # keywords ::
-            (r'((?i)select|construct|describe|ask|where|filter|group\s+by|minus|'
+            (r'(?i)(select|construct|describe|ask|where|filter|group\s+by|minus|'
              r'distinct|reduced|from\s+named|from|order\s+by|desc|asc|limit|'
-             r'offset|bindings|load|clear|drop|create|add|move|copy|'
-             r'insert\s+data|delete\s+data|delete\s+where|delete|insert|'
+             r'offset|values|bindings|load|into|clear|drop|create|add|move|copy|'
+             r'insert\s+data|delete\s+data|delete\s+where|with|delete|insert|'
              r'using\s+named|using|graph|default|named|all|optional|service|'
-             r'silent|bind|union|not\s+in|in|as|having|to|prefix|base)\b', Keyword),
+             r'silent|bind|undef|union|not\s+in|in|as|having|to|prefix|base)\b', Keyword),
             (r'(a)\b', Keyword),
             # IRIs ::
             ('(' + IRIREF + ')', Name.Label),
@@ -111,13 +111,13 @@ class SparqlLexer(RegexLexer):
             #  # variables ::
             ('[?$]' + VARNAME, Name.Variable),
             # prefixed names ::
-            (r'(' + PN_PREFIX + ')?(\:)(' + PN_LOCAL + ')?',
+            (r'(' + PN_PREFIX + r')?(\:)(' + PN_LOCAL + r')?',
              bygroups(Name.Namespace, Punctuation, Name.Tag)),
             # function names ::
-            (r'((?i)str|lang|langmatches|datatype|bound|iri|uri|bnode|rand|abs|'
+            (r'(?i)(str|lang|langmatches|datatype|bound|iri|uri|bnode|rand|abs|'
              r'ceil|floor|round|concat|strlen|ucase|lcase|encode_for_uri|'
              r'contains|strstarts|strends|strbefore|strafter|year|month|day|'
-             r'hours|minutes|seconds|timezone|tz|now|md5|sha1|sha256|sha384|'
+             r'hours|minutes|seconds|timezone|tz|now|uuid|struuid|md5|sha1|sha256|sha384|'
              r'sha512|coalesce|if|strlang|strdt|sameterm|isiri|isuri|isblank|'
              r'isliteral|isnumeric|regex|substr|replace|exists|not\s+exists|'
              r'count|sum|min|max|avg|sample|group_concat|separator)\b',
@@ -125,7 +125,7 @@ class SparqlLexer(RegexLexer):
             # boolean literals ::
             (r'(true|false)', Keyword.Constant),
             # double literals ::
-            (r'[+\-]?(\d+\.\d*' + EXPONENT + '|\.?\d+' + EXPONENT + ')', Number.Float),
+            (r'[+\-]?(\d+\.\d*' + EXPONENT + r'|\.?\d+' + EXPONENT + ')', Number.Float),
             # decimal literals ::
             (r'[+\-]?(\d+\.\d*|\.\d+)', Number.Float),
             # integer literals ::
@@ -187,19 +187,61 @@ class TurtleLexer(RegexLexer):
     filenames = ['*.ttl']
     mimetypes = ['text/turtle', 'application/x-turtle']
 
-    flags = re.IGNORECASE
+    # character group definitions ::
+    PN_CHARS_BASE_GRP = ('a-zA-Z'
+                         '\u00c0-\u00d6'
+                         '\u00d8-\u00f6'
+                         '\u00f8-\u02ff'
+                         '\u0370-\u037d'
+                         '\u037f-\u1fff'
+                         '\u200c-\u200d'
+                         '\u2070-\u218f'
+                         '\u2c00-\u2fef'
+                         '\u3001-\ud7ff'
+                         '\uf900-\ufdcf'
+                         '\ufdf0-\ufffd')
+
+    PN_CHARS_U_GRP = (PN_CHARS_BASE_GRP + '_')
+
+    PN_CHARS_GRP = (PN_CHARS_U_GRP +
+                    r'\-' +
+                    r'0-9' +
+                    '\u00b7' +
+                    '\u0300-\u036f' +
+                    '\u203f-\u2040')
+
+    PN_CHARS = '[' + PN_CHARS_GRP + ']'
+
+    PN_CHARS_BASE = '[' + PN_CHARS_BASE_GRP + ']'
+
+    PN_PREFIX = PN_CHARS_BASE + '(?:[' + PN_CHARS_GRP + '.]*' + PN_CHARS + ')?'
+
+    HEX_GRP = '0-9A-Fa-f'
+
+    HEX = '[' + HEX_GRP + ']'
+
+    PERCENT = '%' + HEX + HEX
+
+    PN_LOCAL_ESC_CHARS_GRP = r' _~.\-!$&"()*+,;=/?#@%'
+
+    PN_LOCAL_ESC_CHARS = '[' + PN_LOCAL_ESC_CHARS_GRP + ']'
+
+    PN_LOCAL_ESC = r'\\' + PN_LOCAL_ESC_CHARS
+
+    PLX = '(?:' + PERCENT + ')|(?:' + PN_LOCAL_ESC + ')'
+
+    PN_LOCAL = ('(?:[' + PN_CHARS_U_GRP + ':0-9' + ']|' + PLX + ')' +
+                '(?:(?:[' + PN_CHARS_GRP + '.:]|' + PLX + ')*(?:[' +
+                PN_CHARS_GRP + ':]|' + PLX + '))?')
 
     patterns = {
-        'PNAME_NS': r'((?:[a-z][\w-]*)?\:)',  # Simplified character range
+        'PNAME_NS': r'((?:[a-zA-Z][\w-]*)?\:)',  # Simplified character range
         'IRIREF': r'(<[^<>"{}|^`\\\x00-\x20]*>)'
     }
 
-    # PNAME_NS PN_LOCAL (with simplified character range)
-    patterns['PrefixedName'] = r'%(PNAME_NS)s([a-z][\w-]*)' % patterns
-
     tokens = {
         'root': [
-            (r'\s+', Whitespace),
+            (r'\s+', Text),
 
             # Base / prefix
             (r'(@base|BASE)(\s+)%(IRIREF)s(\s*)(\.?)' % patterns,
@@ -216,8 +258,8 @@ class TurtleLexer(RegexLexer):
             (r'%(IRIREF)s' % patterns, Name.Variable),
 
             # PrefixedName
-            (r'%(PrefixedName)s' % patterns,
-             bygroups(Name.Namespace, Name.Tag)),
+            (r'(' + PN_PREFIX + r')?(\:)(' + PN_LOCAL + r')?',
+             bygroups(Name.Namespace, Punctuation, Name.Tag)),
 
             # Comment
             (r'#[^\n]+', Comment),
@@ -257,14 +299,165 @@ class TurtleLexer(RegexLexer):
             (r'.', String, '#pop'),
         ],
         'end-of-string': [
-            (r'(@)([a-z]+(:?-[a-z0-9]+)*)',
+            (r'(@)([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)',
              bygroups(Operator, Generic.Emph), '#pop:2'),
 
             (r'(\^\^)%(IRIREF)s' % patterns, bygroups(Operator, Generic.Emph), '#pop:2'),
-            (r'(\^\^)%(PrefixedName)s' % patterns,
-             bygroups(Operator, Generic.Emph, Generic.Emph), '#pop:2'),
 
             default('#pop:2'),
 
         ],
     }
+
+    # Turtle and Tera Term macro files share the same file extension
+    # but each has a recognizable and distinct syntax.
+    def analyse_text(text):
+        for t in ('@base ', 'BASE ', '@prefix ', 'PREFIX '):
+            if re.search(r'^\s*%s' % t, text):
+                return 0.80
+
+
+class ShExCLexer(RegexLexer):
+    """
+    Lexer for `ShExC <https://shex.io/shex-semantics/#shexc>`_ shape expressions language syntax.
+    """
+    name = 'ShExC'
+    aliases = ['shexc', 'shex']
+    filenames = ['*.shex']
+    mimetypes = ['text/shex']
+
+    # character group definitions ::
+
+    PN_CHARS_BASE_GRP = ('a-zA-Z'
+                         '\u00c0-\u00d6'
+                         '\u00d8-\u00f6'
+                         '\u00f8-\u02ff'
+                         '\u0370-\u037d'
+                         '\u037f-\u1fff'
+                         '\u200c-\u200d'
+                         '\u2070-\u218f'
+                         '\u2c00-\u2fef'
+                         '\u3001-\ud7ff'
+                         '\uf900-\ufdcf'
+                         '\ufdf0-\ufffd')
+
+    PN_CHARS_U_GRP = (PN_CHARS_BASE_GRP + '_')
+
+    PN_CHARS_GRP = (PN_CHARS_U_GRP +
+                    r'\-' +
+                    r'0-9' +
+                    '\u00b7' +
+                    '\u0300-\u036f' +
+                    '\u203f-\u2040')
+
+    HEX_GRP = '0-9A-Fa-f'
+
+    PN_LOCAL_ESC_CHARS_GRP = r"_~.\-!$&'()*+,;=/?#@%"
+
+    # terminal productions ::
+
+    PN_CHARS_BASE = '[' + PN_CHARS_BASE_GRP + ']'
+
+    PN_CHARS_U = '[' + PN_CHARS_U_GRP + ']'
+
+    PN_CHARS = '[' + PN_CHARS_GRP + ']'
+
+    HEX = '[' + HEX_GRP + ']'
+
+    PN_LOCAL_ESC_CHARS = '[' + PN_LOCAL_ESC_CHARS_GRP + ']'
+
+    UCHAR_NO_BACKSLASH = '(?:u' + HEX + '{4}|U' + HEX + '{8})'
+
+    UCHAR = r'\\' + UCHAR_NO_BACKSLASH
+
+    IRIREF = r'<(?:[^\x00-\x20<>"{}|^`\\]|' + UCHAR + ')*>'
+
+    BLANK_NODE_LABEL = '_:[0-9' + PN_CHARS_U_GRP + '](?:[' + PN_CHARS_GRP + \
+                       '.]*' + PN_CHARS + ')?'
+
+    PN_PREFIX = PN_CHARS_BASE + '(?:[' + PN_CHARS_GRP + '.]*' + PN_CHARS + ')?'
+
+    PERCENT = '%' + HEX + HEX
+
+    PN_LOCAL_ESC = r'\\' + PN_LOCAL_ESC_CHARS
+
+    PLX = '(?:' + PERCENT + ')|(?:' + PN_LOCAL_ESC + ')'
+
+    PN_LOCAL = ('(?:[' + PN_CHARS_U_GRP + ':0-9' + ']|' + PLX + ')' +
+                '(?:(?:[' + PN_CHARS_GRP + '.:]|' + PLX + ')*(?:[' +
+                PN_CHARS_GRP + ':]|' + PLX + '))?')
+
+    EXPONENT = r'[eE][+-]?\d+'
+
+    # Lexer token definitions ::
+
+    tokens = {
+        'root': [
+            (r'\s+', Text),
+            # keywords ::
+            (r'(?i)(base|prefix|start|external|'
+             r'literal|iri|bnode|nonliteral|length|minlength|maxlength|'
+             r'mininclusive|minexclusive|maxinclusive|maxexclusive|'
+             r'totaldigits|fractiondigits|'
+             r'closed|extra)\b', Keyword),
+            (r'(a)\b', Keyword),
+            # IRIs ::
+            ('(' + IRIREF + ')', Name.Label),
+            # blank nodes ::
+            ('(' + BLANK_NODE_LABEL + ')', Name.Label),
+            # prefixed names ::
+            (r'(' + PN_PREFIX + r')?(\:)(' + PN_LOCAL + ')?',
+             bygroups(Name.Namespace, Punctuation, Name.Tag)),
+            # boolean literals ::
+            (r'(true|false)', Keyword.Constant),
+            # double literals ::
+            (r'[+\-]?(\d+\.\d*' + EXPONENT + r'|\.?\d+' + EXPONENT + ')', Number.Float),
+            # decimal literals ::
+            (r'[+\-]?(\d+\.\d*|\.\d+)', Number.Float),
+            # integer literals ::
+            (r'[+\-]?\d+', Number.Integer),
+            # operators ::
+            (r'[@|$&=*+?^\-~]', Operator),
+            # operator keywords ::
+            (r'(?i)(and|or|not)\b', Operator.Word),
+            # punctuation characters ::
+            (r'[(){}.;,:^\[\]]', Punctuation),
+            # line comments ::
+            (r'#[^\n]*', Comment),
+            # strings ::
+            (r'"""', String, 'triple-double-quoted-string'),
+            (r'"', String, 'single-double-quoted-string'),
+            (r"'''", String, 'triple-single-quoted-string'),
+            (r"'", String, 'single-single-quoted-string'),
+        ],
+        'triple-double-quoted-string': [
+            (r'"""', String, 'end-of-string'),
+            (r'[^\\]+', String),
+            (r'\\', String, 'string-escape'),
+        ],
+        'single-double-quoted-string': [
+            (r'"', String, 'end-of-string'),
+            (r'[^"\\\n]+', String),
+            (r'\\', String, 'string-escape'),
+        ],
+        'triple-single-quoted-string': [
+            (r"'''", String, 'end-of-string'),
+            (r'[^\\]+', String),
+            (r'\\', String.Escape, 'string-escape'),
+        ],
+        'single-single-quoted-string': [
+            (r"'", String, 'end-of-string'),
+            (r"[^'\\\n]+", String),
+            (r'\\', String, 'string-escape'),
+        ],
+        'string-escape': [
+            (UCHAR_NO_BACKSLASH, String.Escape, '#pop'),
+            (r'.', String.Escape, '#pop'),
+        ],
+        'end-of-string': [
+            (r'(@)([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)',
+             bygroups(Operator, Name.Function), '#pop:2'),
+            (r'\^\^', Operator, '#pop:2'),
+            default('#pop:2'),
+        ],
+    }