Merged in gerph/pygments-main (pull request #806)

Create a Lexer class for BBC Basic files.

23 files changed, 2095 insertions, 68 deletions

diff --git a/AUTHORS b/AUTHORS
index ed9c547c..e6f90fea 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -221,5 +221,6 @@ Other contributors, listed alphabetically, are:
 * Rob Zimmerman -- Kal lexer
 * Vincent Zurczak -- Roboconf lexer
 * Rostyslav Golda -- FloScript lexer
+* GitHub, Inc -- DASM16, Augeas, TOML, and Slash lexers
 
 Many thanks for all contributions!
diff --git a/CHANGES b/CHANGES
index 9a7426a3..2b1ebb0b 100644
--- a/CHANGES
+++ b/CHANGES
@@ -12,11 +12,16 @@ Version 2.4.0
 
 - Added lexers:
 
+  * Augeas (PR#807)
   * Charm++ CI (PR#788)
+  * DASM16 (PR#807)
   * FloScript (PR#750)
   * Hspec (PR#790)
   * SGF (PR#780)
+  * Slash (PR#807)
   * Slurm (PR#760)
+  * TOML (PR#807)
+  * Unicon (PR#731)
   * VBScript (PR#673)
 
 - Updated lexers:
@@ -26,15 +31,18 @@ Version 2.4.0
   * PHP (#1482)
   * SQL (PR#672)
   * Stan (PR#774)
+  * Stata (PR#800)
   * Terraform (PR#787)
 
 - Add solarized style (PR#708)
+- Add support for Markdown reference-style links (PR#753)
 - Change ANSI color names (PR#777)
-- Fix rare unicode errors on Python 2.7 (PR#798, #1492)
-- Updated Trove classifiers and ``pip`` requirements (PR#799)
-- TypoScript uses ``.typoscript`` now (#1498)
 - Fix catastrophic backtracking in the bash lexer (#1494)
+- Fix documentation failing to build using Sphinx 2.0 (#1501)
 - Fix incorrect links in the Lisp and R lexer documentation (PR#775)
+- Fix rare unicode errors on Python 2.7 (PR#798, #1492)
+- TypoScript uses ``.typoscript`` now (#1498)
+- Updated Trove classifiers and ``pip`` requirements (PR#799)
 
 Version 2.3.1
 -------------
diff --git a/doc/conf.py b/doc/conf.py
index 51a91617..00db7d9b 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -125,8 +125,8 @@ html_static_path = ['_static']
 #html_use_smartypants = True
 
 # Custom sidebar templates, maps document names to template names.
-html_sidebars = {'index': 'indexsidebar.html',
-                 'docs/*': 'docssidebar.html'}
+html_sidebars = {'index': ['indexsidebar.html'],
+                 'docs/*': ['docssidebar.html']}
 
 # Additional templates that should be rendered to pages, maps page names to
 # template names.
diff --git a/doc/languages.rst b/doc/languages.rst
index 47e3363f..d2508b07 100644
--- a/doc/languages.rst
+++ b/doc/languages.rst
@@ -14,6 +14,7 @@ Programming languages
 * AppleScript
 * Assembly (various)
 * Asymptote
+* `Augeas <http://augeas.net>`_
 * Awk
 * Befunge
 * Boo
@@ -31,6 +32,7 @@ Programming languages
 * `Cython <http://cython.org>`_
 * `D <http://dlang.org>`_
 * Dart
+* DCPU-16
 * Delphi
 * Dylan
 * `Elm <http://elm-lang.org/>`_
@@ -85,10 +87,12 @@ Programming languages
 * Scheme
 * Scilab
 * `SGF <https://www.red-bean.com/sgf/>`_
+* `Slash <https://github.com/arturadib/Slash-A>`_
 * `Slurm <https://slurm.schedmd.com/overview.html>`_
 * Smalltalk
 * SNOBOL
 * Tcl
+* `TOML <https://github.com/toml-lang/toml>`_
 * Vala
 * Verilog
 * VHDL
diff --git a/pygments/lexers/_mapping.py b/pygments/lexers/_mapping.py
index e57124db..3fbb1df8 100644
--- a/pygments/lexers/_mapping.py
+++ b/pygments/lexers/_mapping.py
@@ -44,6 +44,7 @@ LEXERS = {
     'ArduinoLexer': ('pygments.lexers.c_like', 'Arduino', ('arduino',), ('*.ino',), ('text/x-arduino',)),
     'AspectJLexer': ('pygments.lexers.jvm', 'AspectJ', ('aspectj',), ('*.aj',), ('text/x-aspectj',)),
     'AsymptoteLexer': ('pygments.lexers.graphics', 'Asymptote', ('asy', 'asymptote'), ('*.asy',), ('text/x-asymptote',)),
+    'AugeasLexer': ('pygments.lexers.configs', 'Augeas', ('augeas',), ('*.aug',), ()),
     'AutoItLexer': ('pygments.lexers.automation', 'AutoIt', ('autoit',), ('*.au3',), ('text/x-autoit',)),
     'AutohotkeyLexer': ('pygments.lexers.automation', 'autohotkey', ('ahk', 'autohotkey'), ('*.ahk', '*.ahkl'), ('text/x-autohotkey',)),
     'AwkLexer': ('pygments.lexers.textedit', 'Awk', ('awk', 'gawk', 'mawk', 'nawk'), ('*.awk',), ('application/x-awk',)),
@@ -122,6 +123,7 @@ LEXERS = {
     'DObjdumpLexer': ('pygments.lexers.asm', 'd-objdump', ('d-objdump',), ('*.d-objdump',), ('text/x-d-objdump',)),
     'DarcsPatchLexer': ('pygments.lexers.diff', 'Darcs Patch', ('dpatch',), ('*.dpatch', '*.darcspatch'), ()),
     'DartLexer': ('pygments.lexers.javascript', 'Dart', ('dart',), ('*.dart',), ('text/x-dart',)),
+    'Dasm16Lexer': ('pygments.lexers.asm', 'DASM16', ('dasm16',), ('*.dasm16', '*.dasm'), ('text/x-dasm16',)),
     'DebianControlLexer': ('pygments.lexers.installers', 'Debian Control file', ('control', 'debcontrol'), ('control',), ()),
     'DelphiLexer': ('pygments.lexers.pascal', 'Delphi', ('delphi', 'pas', 'pascal', 'objectpascal'), ('*.pas', '*.dpr'), ('text/x-pascal',)),
     'DgLexer': ('pygments.lexers.python', 'dg', ('dg',), ('*.dg',), ('text/x-dg',)),
@@ -197,6 +199,7 @@ LEXERS = {
     'HyLexer': ('pygments.lexers.lisp', 'Hy', ('hylang',), ('*.hy',), ('text/x-hy', 'application/x-hy')),
     'HybrisLexer': ('pygments.lexers.scripting', 'Hybris', ('hybris', 'hy'), ('*.hy', '*.hyb'), ('text/x-hybris', 'application/x-hybris')),
     'IDLLexer': ('pygments.lexers.idl', 'IDL', ('idl',), ('*.pro',), ('text/idl',)),
+    'IconLexer': ('pygments.lexers.unicon', 'Icon', ('icon',), ('*.icon', '*.ICON'), ()),
     'IdrisLexer': ('pygments.lexers.haskell', 'Idris', ('idris', 'idr'), ('*.idr',), ('text/x-idris',)),
     'IgorLexer': ('pygments.lexers.igor', 'Igor', ('igor', 'igorpro'), ('*.ipf',), ('text/ipf',)),
     'Inform6Lexer': ('pygments.lexers.int_fiction', 'Inform 6', ('inform6', 'i6'), ('*.inf',), ()),
@@ -386,6 +389,7 @@ LEXERS = {
     'ScssLexer': ('pygments.lexers.css', 'SCSS', ('scss',), ('*.scss',), ('text/x-scss',)),
     'ShenLexer': ('pygments.lexers.lisp', 'Shen', ('shen',), ('*.shen',), ('text/x-shen', 'application/x-shen')),
     'SilverLexer': ('pygments.lexers.verification', 'Silver', ('silver',), ('*.sil', '*.vpr'), ()),
+    'SlashLexer': ('pygments.lexers.slash', 'Slash', ('slash',), ('*.sl',), ()),
     'SlimLexer': ('pygments.lexers.webmisc', 'Slim', ('slim',), ('*.slim',), ('text/x-slim',)),
     'SlurmBashLexer': ('pygments.lexers.shell', 'Slurm', ('slurm', 'sbatch'), ('*.sl',), ()),
     'SmaliLexer': ('pygments.lexers.dalvik', 'Smali', ('smali',), ('*.smali',), ('text/smali',)),
@@ -408,6 +412,7 @@ LEXERS = {
     'SwigLexer': ('pygments.lexers.c_like', 'SWIG', ('swig',), ('*.swg', '*.i'), ('text/swig',)),
     'SystemVerilogLexer': ('pygments.lexers.hdl', 'systemverilog', ('systemverilog', 'sv'), ('*.sv', '*.svh'), ('text/x-systemverilog',)),
     'TAPLexer': ('pygments.lexers.testing', 'TAP', ('tap',), ('*.tap',), ()),
+    'TOMLLexer': ('pygments.lexers.configs', 'TOML', ('toml',), ('*.toml',), ()),
     'Tads3Lexer': ('pygments.lexers.int_fiction', 'TADS 3', ('tads3',), ('*.t',), ()),
     'TasmLexer': ('pygments.lexers.asm', 'TASM', ('tasm',), ('*.asm', '*.ASM', '*.tasm'), ('text/x-tasm',)),
     'TclLexer': ('pygments.lexers.tcl', 'Tcl', ('tcl',), ('*.tcl', '*.rvt'), ('text/x-tcl', 'text/x-script.tcl', 'application/x-tcl')),
@@ -430,6 +435,8 @@ LEXERS = {
     'TypoScriptCssDataLexer': ('pygments.lexers.typoscript', 'TypoScriptCssData', ('typoscriptcssdata',), (), ()),
     'TypoScriptHtmlDataLexer': ('pygments.lexers.typoscript', 'TypoScriptHtmlData', ('typoscripthtmldata',), (), ()),
     'TypoScriptLexer': ('pygments.lexers.typoscript', 'TypoScript', ('typoscript',), ('*.typoscript',), ('text/x-typoscript',)),
+    'UcodeLexer': ('pygments.lexers.unicon', 'ucode', ('ucode',), ('*.u', '*.u1', '*.u2'), ()),
+    'UniconLexer': ('pygments.lexers.unicon', 'Unicon', ('unicon',), ('*.icn',), ('text/unicon',)),
     'UrbiscriptLexer': ('pygments.lexers.urbi', 'UrbiScript', ('urbiscript',), ('*.u',), ('application/x-urbiscript',)),
     'VBScriptLexer': ('pygments.lexers.basic', 'VBScript', (), ('*.vbs', '*.VBS'), ()),
     'VCLLexer': ('pygments.lexers.varnish', 'VCL', ('vcl',), ('*.vcl',), ('text/x-vclsrc',)),
diff --git a/pygments/lexers/_stata_builtins.py b/pygments/lexers/_stata_builtins.py
index 5f5f72a9..3e5e75b2 100644
--- a/pygments/lexers/_stata_builtins.py
+++ b/pygments/lexers/_stata_builtins.py
@@ -10,6 +10,10 @@
 """
 
 
+builtins_special = (
+    "if", "in", "using", "replace", "by", "gen", "generate"
+)
+
 builtins_base = (
     "if", "else", "in", "foreach", "for", "forv", "forva",
     "forval", "forvalu", "forvalue", "forvalues", "by", "bys",
@@ -66,7 +70,7 @@ builtins_base = (
     "doedit", "dotplot", "dotplot_7", "dprobit", "drawnorm",
     "drop", "ds", "ds_util", "dstdize", "duplicates", "durbina",
     "dwstat", "dydx", "e", "ed", "edi", "edit", "egen",
-    "eivreg", "emdef", "en", "enc", "enco", "encod", "encode",
+    "eivreg", "emdef", "end", "en", "enc", "enco", "encod", "encode",
     "eq", "erase", "ereg", "ereg_lf", "ereg_p", "ereg_sw",
     "ereghet", "ereghet_glf", "ereghet_glf_sh", "ereghet_gp",
     "ereghet_ilf", "ereghet_ilf_sh", "ereghet_ip", "eret",
@@ -415,5 +419,3 @@ builtins_functions = (
     "weekly", "wofd", "word", "wordcount", "year", "yearly",
     "yh", "ym", "yofd", "yq", "yw"
 )
-
-
diff --git a/pygments/lexers/asm.py b/pygments/lexers/asm.py
index 2f08d510..7100868c 100644
--- a/pygments/lexers/asm.py
+++ b/pygments/lexers/asm.py
@@ -20,7 +20,7 @@ from pygments.token import Text, Name, Number, String, Comment, Punctuation, \
 
 __all__ = ['GasLexer', 'ObjdumpLexer', 'DObjdumpLexer', 'CppObjdumpLexer',
            'CObjdumpLexer', 'HsailLexer', 'LlvmLexer', 'NasmLexer',
-           'NasmObjdumpLexer', 'TasmLexer', 'Ca65Lexer']
+           'NasmObjdumpLexer', 'TasmLexer', 'Ca65Lexer', 'Dasm16Lexer']
 
 
 class GasLexer(RegexLexer):
@@ -650,3 +650,109 @@ class Ca65Lexer(RegexLexer):
         # comments in GAS start with "#"
         if re.match(r'^\s*;', text, re.MULTILINE):
             return 0.9
+
+
+class Dasm16Lexer(RegexLexer):
+    """
+    Simple lexer for DCPU-16 Assembly
+
+    Check http://0x10c.com/doc/dcpu-16.txt
+
+    .. versionadded:: 2.4
+    """
+    name = 'DASM16'
+    aliases = ['dasm16']
+    filenames = ['*.dasm16', '*.dasm']
+    mimetypes = ['text/x-dasm16']
+
+    INSTRUCTIONS = [
+        'SET',
+        'ADD', 'SUB',
+        'MUL', 'MLI',
+        'DIV', 'DVI',
+        'MOD', 'MDI',
+        'AND', 'BOR', 'XOR',
+        'SHR', 'ASR', 'SHL',
+        'IFB', 'IFC', 'IFE', 'IFN', 'IFG', 'IFA', 'IFL', 'IFU',
+        'ADX', 'SBX',
+        'STI', 'STD',
+        'JSR',
+        'INT', 'IAG', 'IAS', 'RFI', 'IAQ', 'HWN', 'HWQ', 'HWI',
+    ]
+
+    REGISTERS = [
+        'A', 'B', 'C',
+        'X', 'Y', 'Z',
+        'I', 'J',
+        'SP', 'PC', 'EX',
+        'POP', 'PEEK', 'PUSH'
+    ]
+
+    # Regexes yo
+    char = r'[a-zA-Z$._0-9@]'
+    identifier = r'(?:[a-zA-Z$_]' + char + '*|\.' + char + '+)'
+    number = r'[+-]?(?:0[xX][a-zA-Z0-9]+|\d+)'
+    binary_number = r'0b[01_]+'
+    instruction = r'(?i)(' + '|'.join(INSTRUCTIONS) + ')'
+    single_char = r"'\\?" + char + "'"
+    string = r'"(\\"|[^"])*"'
+
+    def guess_identifier(lexer, match):
+        ident = match.group(0)
+        klass = Name.Variable if ident.upper() in lexer.REGISTERS else Name.Label
+        yield match.start(), klass, ident
+
+    tokens = {
+        'root': [
+            include('whitespace'),
+            (':' + identifier, Name.Label),
+            (identifier + ':', Name.Label),
+            (instruction, Name.Function, 'instruction-args'),
+            (r'\.' + identifier, Name.Function, 'data-args'),
+            (r'[\r\n]+', Text)
+        ],
+
+        'numeric' : [
+            (binary_number, Number.Integer),
+            (number, Number.Integer),
+            (single_char, String),
+        ],
+
+        'arg' : [
+            (identifier, guess_identifier),
+            include('numeric')
+        ],
+
+        'deref' : [
+            (r'\+', Punctuation),
+            (r'\]', Punctuation, '#pop'),
+            include('arg'),
+            include('whitespace')
+        ],
+
+        'instruction-line' : [
+            (r'[\r\n]+', Text, '#pop'),
+            (r';.*?$', Comment, '#pop'),
+            include('whitespace')
+        ],
+
+        'instruction-args': [
+            (r',', Punctuation),
+            (r'\[', Punctuation, 'deref'),
+            include('arg'),
+            include('instruction-line')
+        ],
+
+        'data-args' : [
+            (r',', Punctuation),
+            include('numeric'),
+            (string, String),
+            include('instruction-line')
+        ],
+
+        'whitespace': [
+            (r'\n', Text),
+            (r'\s+', Text),
+            (r';.*?\n', Comment)
+        ],
+    }
diff --git a/pygments/lexers/configs.py b/pygments/lexers/configs.py
index 206ec360..6f2c7c76 100644
--- a/pygments/lexers/configs.py
+++ b/pygments/lexers/configs.py
@@ -21,7 +21,7 @@ __all__ = ['IniLexer', 'RegeditLexer', 'PropertiesLexer', 'KconfigLexer',
            'Cfengine3Lexer', 'ApacheConfLexer', 'SquidConfLexer',
            'NginxConfLexer', 'LighttpdConfLexer', 'DockerLexer',
            'TerraformLexer', 'TermcapLexer', 'TerminfoLexer',
-           'PkgConfigLexer', 'PacmanConfLexer']
+           'PkgConfigLexer', 'PacmanConfLexer', 'AugeasLexer', 'TOMLLexer']
 
 
 class IniLexer(RegexLexer):
@@ -838,3 +838,97 @@ class PacmanConfLexer(RegexLexer):
             (r'.', Text),
         ],
     }
+
+
+class AugeasLexer(RegexLexer):
+    """
+    Lexer for `Augeas <http://augeas.net>`_.
+
+    .. versionadded:: 2.4
+    """
+    name = 'Augeas'
+    aliases = ['augeas']
+    filenames = ['*.aug']
+
+    tokens = {
+        'root': [
+            (r'(module)(\s*)([^\s=]+)', bygroups(Keyword.Namespace, Text, Name.Namespace)),
+            (r'(let)(\s*)([^\s=]+)', bygroups(Keyword.Declaration, Text, Name.Variable)),
+            (r'(del|store|value|counter|seq|key|label|autoload|incl|excl|transform|test|get|put)(\s+)', bygroups(Name.Builtin, Text)),
+            (r'(\()([^:]+)(\:)(unit|string|regexp|lens|tree|filter)(\))', bygroups(Punctuation, Name.Variable, Punctuation, Keyword.Type, Punctuation)),
+            (r'\(\*', Comment.Multiline, 'comment'),
+            (r'[*+\-.;=?|]', Operator),
+            (r'[()\[\]{}]', Operator),
+            (r'"', String.Double, 'string'),
+            (r'\/', String.Regex, 'regex'),
+            (r'([A-Z]\w*)(\.)(\w+)', bygroups(Name.Namespace, Punctuation, Name.Variable)),
+            (r'.', Name.Variable),
+            (r'\s', Text),
+        ],
+        'string': [
+            (r'\\.', String.Escape),
+            (r'[^"]', String.Double),
+            (r'"', String.Double, '#pop'),
+        ],
+        'regex': [
+            (r'\\.', String.Escape),
+            (r'[^/]', String.Regex),
+            (r'\/', String.Regex, '#pop'),
+        ],
+        'comment': [
+            (r'[^*)]', Comment.Multiline),
+            (r'\(\*', Comment.Multiline, '#push'),
+            (r'\*\)', Comment.Multiline, '#pop'),
+            (r'[)*]', Comment.Multiline)
+        ],
+    }
+
+
+class TOMLLexer(RegexLexer):
+    """
+    Lexer for `TOML <https://github.com/toml-lang/toml>`_, a simple language
+    for config files.
+
+    .. versionadded:: 2.4
+    """
+
+    name = 'TOML'
+    aliases = ['toml']
+    filenames = ['*.toml']
+
+    tokens = {
+        'root': [
+
+            # Basics, comments, strings
+            (r'\s+', Text),
+            (r'#.*?$', Comment.Single),
+            # Basic string
+            (r'"(\\\\|\\"|[^"])*"', String),
+            # Literal string
+            (r'\'\'\'(.*)\'\'\'', String),
+            (r'\'[^\']*\'', String),
+            (r'(true|false)$', Keyword.Constant),
+            (r'[a-zA-Z_][\w\-]*', Name),
+
+            (r'\[.*?\]$', Keyword),
+            # Datetime
+            # TODO this needs to be expanded, as TOML is rather flexible:
+            # https://github.com/toml-lang/toml#offset-date-time
+            (r'\d{4}-\d{2}-\d{2}(?:T| )\d{2}:\d{2}:\d{2}(?:Z|[-+]\d{2}:\d{2})', Number.Integer),
+
+            # Numbers
+            (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?', Number.Float),
+            (r'\d+[eE][+-]?[0-9]+j?', Number.Float),
+            # Handle +-inf, +-infinity, +-nan
+            (r'[+-]?(?:(inf(?:inity)?)|nan)', Number.Float),
+            (r'[+-]?\d+', Number.Integer),
+
+            # Punctuation
+            (r'[]{}:(),;[]', Punctuation),
+            (r'\.', Punctuation),
+
+            # Operators
+            (r'=', Operator)
+
+        ]
+    }
diff --git a/pygments/lexers/jvm.py b/pygments/lexers/jvm.py
index 5a9a74a9..8de6e9f2 100644
--- a/pygments/lexers/jvm.py
+++ b/pygments/lexers/jvm.py
@@ -1006,7 +1006,7 @@ class KotlinLexer(RegexLexer):
 
     .. versionadded:: 1.5
     """
-
+    
     name = 'Kotlin'
     aliases = ['kotlin']
     filenames = ['*.kt']
@@ -1017,15 +1017,22 @@ class KotlinLexer(RegexLexer):
     kt_name = ('@?[_' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Nl') + ']' +
                '[' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Nl', 'Nd', 'Pc', 'Cf',
                                  'Mn', 'Mc') + ']*')
-    kt_id = '(' + kt_name + '|`' + kt_name + '`)'
+    
+    kt_space_name = ('@?[_' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Nl') + ']' +
+               '[' + uni.combine('Lu', 'Ll', 'Lt', 'Lm', 'Nl', 'Nd', 'Pc', 'Cf',
+                                 'Mn', 'Mc', 'Zs') + ',-]*')
+
+    kt_id = '(' + kt_name + '|`' + kt_space_name + '`)'
 
     tokens = {
         'root': [
             (r'^\s*\[.*?\]', Name.Attribute),
             (r'[^\S\n]+', Text),
+            (r'\s+', Text),
             (r'\\\n', Text),  # line continuation
             (r'//.*?\n', Comment.Single),
             (r'/[*].*?[*]/', Comment.Multiline),
+            (r'""".*?"""', String),
             (r'\n', Text),
             (r'::|!!|\?[:.]', Operator),
             (r'[~!%^&*()+=|\[\]:;,.<>/?-]', Punctuation),
@@ -1035,11 +1042,14 @@ class KotlinLexer(RegexLexer):
             (r"'\\.'|'[^\\]'", String.Char),
             (r"[0-9](\.[0-9]*)?([eE][+-][0-9]+)?[flFL]?|"
              r"0[xX][0-9a-fA-F]+[Ll]?", Number),
-            (r'(class)(\s+)(object)', bygroups(Keyword, Text, Keyword)),
+            (r'(object)(\s+)(:)(\s+)', bygroups(Keyword, Text, Punctuation, Text), 'class'),
+            (r'(companion)(\s+)(object)', bygroups(Keyword, Text, Keyword)),
             (r'(class|interface|object)(\s+)', bygroups(Keyword, Text), 'class'),
             (r'(package|import)(\s+)', bygroups(Keyword, Text), 'package'),
+            (r'(val|var)(\s+)([(])', bygroups(Keyword, Text, Punctuation), 'property_dec'),
             (r'(val|var)(\s+)', bygroups(Keyword, Text), 'property'),
             (r'(fun)(\s+)', bygroups(Keyword, Text), 'function'),
+            (r'(inline fun)(\s+)', bygroups(Keyword, Text), 'function'),
             (r'(abstract|annotation|as|break|by|catch|class|companion|const|'
              r'constructor|continue|crossinline|data|do|dynamic|else|enum|'
              r'external|false|final|finally|for|fun|get|if|import|in|infix|'
@@ -1058,9 +1068,26 @@ class KotlinLexer(RegexLexer):
         'property': [
             (kt_id, Name.Property, '#pop')
         ],
+        'property_dec': [
+            (r'(,)(\s*)', bygroups(Punctuation, Text)),
+            (r'(:)(\s*)', bygroups(Punctuation, Text)),
+            (r'<', Punctuation, 'generic'),
+            (r'([)])', Punctuation, '#pop'),
+            (kt_id, Name.Property)
+        ],
         'function': [
+            (r'<', Punctuation, 'generic'),
+            (r''+kt_id+'([.])'+kt_id, bygroups(Name.Class, Punctuation, Name.Function), '#pop'),
             (kt_id, Name.Function, '#pop')
         ],
+        'generic': [
+            (r'(>)(\s*)', bygroups(Punctuation, Text), '#pop'),
+            (r':',Punctuation),
+            (r'(reified|out|in)\b', Keyword),
+            (r',',Text),
+            (r'\s+',Text),
+            (kt_id,Name)
+        ]
     }
 
 
diff --git a/pygments/lexers/markup.py b/pygments/lexers/markup.py
index e6265f40..6eb55fc4 100644
--- a/pygments/lexers/markup.py
+++ b/pygments/lexers/markup.py
@@ -582,6 +582,11 @@ class MarkdownLexer(RegexLexer):
             (r'[@#][\w/:]+', Name.Entity),
             # (image?) links eg: ![Image of Yaktocat](https://octodex.github.com/images/yaktocat.png)
             (r'(!?\[)([^]]+)(\])(\()([^)]+)(\))', bygroups(Text, Name.Tag, Text, Text, Name.Attribute, Text)),
+            # reference-style links, e.g.:
+            #   [an example][id]
+            #   [id]: http://example.com/
+            (r'(\[)([^]]+)(\])(\[)([^]]*)(\])', bygroups(Text, Name.Tag, Text, Text, Name.Label, Text)),
+            (r'^(\s*\[)([^]]*)(\]:\s*)(.+)', bygroups(Text, Name.Label, Text, Name.Attribute)),
 
             # general text, must come last!
             (r'[^\\\s]+', Text),
diff --git a/pygments/lexers/slash.py b/pygments/lexers/slash.py
new file mode 100644
index 00000000..bd73d463
--- /dev/null
+++ b/pygments/lexers/slash.py
@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.slash
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the `Slash <https://github.com/arturadib/Slash-A>`_ programming
+    language.
+
+    :copyright: Copyright 2012 by GitHub, Inc
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import ExtendedRegexLexer, bygroups, DelegatingLexer
+from pygments.token import Name, Number, String, Comment, Punctuation, \
+     Other, Keyword, Operator, Whitespace
+
+__all__ = ['SlashLexer']
+
+
+class SlashLanguageLexer(ExtendedRegexLexer):
+    _nkw = r'(?=[^a-zA-Z_0-9])'
+
+    def move_state(new_state):
+        return ("#pop", new_state)
+
+    def right_angle_bracket(lexer, match, ctx):
+        if len(ctx.stack) > 1 and ctx.stack[-2] == "string":
+            ctx.stack.pop()
+        yield match.start(), String.Interpol, "}"
+        ctx.pos = match.end()
+        pass
+
+    tokens = {
+        "root": [
+            (r"<%=",        Comment.Preproc,    move_state("slash")),
+            (r"<%!!",       Comment.Preproc,    move_state("slash")),
+            (r"<%#.*?%>",   Comment.Multiline),
+            (r"<%",         Comment.Preproc,    move_state("slash")),
+            (r".|\n",       Other),
+        ],
+        "string": [
+            (r"\\",         String.Escape,      move_state("string_e")),
+            (r"\"",         String,             move_state("slash")),
+            (r"#\{",        String.Interpol,    "slash"),
+            (r'.|\n',       String),
+        ],
+        "string_e": [
+            (r'n',                  String.Escape,      move_state("string")),
+            (r't',                  String.Escape,      move_state("string")),
+            (r'r',                  String.Escape,      move_state("string")),
+            (r'e',                  String.Escape,      move_state("string")),
+            (r'x[a-fA-F0-9]{2}',    String.Escape,      move_state("string")),
+            (r'.',                  String.Escape,      move_state("string")),
+        ],
+        "regexp": [
+            (r'}[a-z]*',            String.Regex,       move_state("slash")),
+            (r'\\(.|\n)',           String.Regex),
+            (r'{',                  String.Regex,       "regexp_r"),
+            (r'.|\n',               String.Regex),
+        ],
+        "regexp_r": [
+            (r'}[a-z]*',            String.Regex,       "#pop"),
+            (r'\\(.|\n)',           String.Regex),
+            (r'{',                  String.Regex,       "regexp_r"),
+        ],
+        "slash": [
+            (r"%>",                     Comment.Preproc,    move_state("root")),
+            (r"\"",                     String,             move_state("string")),
+            (r"'[a-zA-Z0-9_]+",         String),
+            (r'%r{',                    String.Regex,       move_state("regexp")),
+            (r'/\*.*?\*/',              Comment.Multiline),
+            (r"(#|//).*?\n",            Comment.Single),
+            (r'-?[0-9]+e[+-]?[0-9]+',   Number.Float),
+            (r'-?[0-9]+\.[0-9]+(e[+-]?[0-9]+)?', Number.Float),
+            (r'-?[0-9]+',               Number.Integer),
+            (r'nil'+_nkw,               Name.Builtin),
+            (r'true'+_nkw,              Name.Builtin),
+            (r'false'+_nkw,             Name.Builtin),
+            (r'self'+_nkw,              Name.Builtin),
+            (r'(class)(\s+)([A-Z][a-zA-Z0-9_\']*)',
+                bygroups(Keyword, Whitespace, Name.Class)),
+            (r'class'+_nkw,             Keyword),
+            (r'extends'+_nkw,           Keyword),
+            (r'(def)(\s+)(self)(\s*)(\.)(\s*)([a-z_][a-zA-Z0-9_\']*=?|<<|>>|==|<=>|<=|<|>=|>|\+|-(self)?|~(self)?|\*|/|%|^|&&|&|\||\[\]=?)',
+                bygroups(Keyword, Whitespace, Name.Builtin, Whitespace, Punctuation, Whitespace, Name.Function)),
+            (r'(def)(\s+)([a-z_][a-zA-Z0-9_\']*=?|<<|>>|==|<=>|<=|<|>=|>|\+|-(self)?|~(self)?|\*|/|%|^|&&|&|\||\[\]=?)',
+                bygroups(Keyword, Whitespace, Name.Function)),
+            (r'def'+_nkw,               Keyword),
+            (r'if'+_nkw,                Keyword),
+            (r'elsif'+_nkw,             Keyword),
+            (r'else'+_nkw,              Keyword),
+            (r'unless'+_nkw,            Keyword),
+            (r'for'+_nkw,               Keyword),
+            (r'in'+_nkw,                Keyword),
+            (r'while'+_nkw,             Keyword),
+            (r'until'+_nkw,             Keyword),
+            (r'and'+_nkw,               Keyword),
+            (r'or'+_nkw,                Keyword),
+            (r'not'+_nkw,               Keyword),
+            (r'lambda'+_nkw,            Keyword),
+            (r'try'+_nkw,               Keyword),
+            (r'catch'+_nkw,             Keyword),
+            (r'return'+_nkw,            Keyword),
+            (r'next'+_nkw,              Keyword),
+            (r'last'+_nkw,              Keyword),
+            (r'throw'+_nkw,             Keyword),
+            (r'use'+_nkw,               Keyword),
+            (r'switch'+_nkw,            Keyword),
+            (r'\\',                     Keyword),
+            (r'λ',                      Keyword),
+            (r'__FILE__'+_nkw,          Name.Builtin.Pseudo),
+            (r'__LINE__'+_nkw,          Name.Builtin.Pseudo),
+            (r'[A-Z][a-zA-Z0-9_\']*'+_nkw, Name.Constant),
+            (r'[a-z_][a-zA-Z0-9_\']*'+_nkw, Name),
+            (r'@[a-z_][a-zA-Z0-9_\']*'+_nkw, Name.Variable.Instance),
+            (r'@@[a-z_][a-zA-Z0-9_\']*'+_nkw, Name.Variable.Class),
+            (r'\(',                     Punctuation),
+            (r'\)',                     Punctuation),
+            (r'\[',                     Punctuation),
+            (r'\]',                     Punctuation),
+            (r'\{',                     Punctuation),
+            (r'\}',                     right_angle_bracket),
+            (r';',                      Punctuation),
+            (r',',                      Punctuation),
+            (r'<<=',                    Operator),
+            (r'>>=',                    Operator),
+            (r'<<',                     Operator),
+            (r'>>',                     Operator),
+            (r'==',                     Operator),
+            (r'!=',                     Operator),
+            (r'=>',                     Operator),
+            (r'=',                      Operator),
+            (r'<=>',                    Operator),
+            (r'<=',                     Operator),
+            (r'>=',                     Operator),
+            (r'<',                      Operator),
+            (r'>',                      Operator),
+            (r'\+\+',                   Operator),
+            (r'\+=',                    Operator),
+            (r'-=',                     Operator),
+            (r'\*\*=',                  Operator),
+            (r'\*=',                    Operator),
+            (r'\*\*',                   Operator),
+            (r'\*',                     Operator),
+            (r'/=',                     Operator),
+            (r'\+',                     Operator),
+            (r'-',                      Operator),
+            (r'/',                      Operator),
+            (r'%=',                     Operator),
+            (r'%',                      Operator),
+            (r'^=',                     Operator),
+            (r'&&=',                    Operator),
+            (r'&=',                     Operator),
+            (r'&&',                     Operator),
+            (r'&',                      Operator),
+            (r'\|\|=',                  Operator),
+            (r'\|=',                    Operator),
+            (r'\|\|',                   Operator),
+            (r'\|',                     Operator),
+            (r'!',                      Operator),
+            (r'\.\.\.',                 Operator),
+            (r'\.\.',                   Operator),
+            (r'\.',                     Operator),
+            (r'::',                     Operator),
+            (r':',                      Operator),
+            (r'(\s|\n)+',               Whitespace),
+            (r'[a-z_][a-zA-Z0-9_\']*',  Name.Variable),
+        ],
+    }
+
+
+class SlashLexer(DelegatingLexer):
+    """
+    Lexer for the Slash programming language.
+
+    .. versionadded:: 2.4
+    """
+
+    name = 'Slash'
+    aliases = ['slash']
+    filenames = ['*.sl']
+
+    def __init__(self, **options):
+        from pygments.lexers.web import HtmlLexer
+        super(SlashLexer, self).__init__(HtmlLexer, SlashLanguageLexer, **options)
diff --git a/pygments/lexers/stata.py b/pygments/lexers/stata.py
index a015a23e..9566d12a 100644
--- a/pygments/lexers/stata.py
+++ b/pygments/lexers/stata.py
@@ -9,6 +9,7 @@
     :license: BSD, see LICENSE for details.
 """
 
+import re
 from pygments.lexer import RegexLexer, include, words
 from pygments.token import Comment, Keyword, Name, Number, \
     String, Text, Operator
@@ -33,56 +34,118 @@ class StataLexer(RegexLexer):
     aliases   = ['stata', 'do']
     filenames = ['*.do', '*.ado']
     mimetypes = ['text/x-stata', 'text/stata', 'application/x-stata']
+    flags     = re.MULTILINE | re.DOTALL
 
     tokens = {
         'root': [
             include('comments'),
-            include('vars-strings'),
+            include('strings'),
+            include('macros'),
             include('numbers'),
             include('keywords'),
+            include('operators'),
+            include('format'),
             (r'.', Text),
         ],
-        # Global and local macros; regular and special strings
-        'vars-strings': [
-            (r'\$[\w{]', Name.Variable.Global, 'var_validglobal'),
-            (r'`\w{0,31}\'', Name.Variable),
-            (r'"', String, 'string_dquote'),
-            (r'`"', String, 'string_mquote'),
-        ],
-        # For either string type, highlight macros as macros
-        'string_dquote': [
-            (r'"', String, '#pop'),
-            (r'\\\\|\\"|\\\n', String.Escape),
-            (r'\$', Name.Variable.Global, 'var_validglobal'),
-            (r'`', Name.Variable, 'var_validlocal'),
-            (r'[^$`"\\]+', String),
-            (r'[$"\\]', String),
-        ],
-        'string_mquote': [
+        # Comments are a complicated beast in Stata because they can be
+        # nested and there are a few corner cases with that. See:
+        # - github.com/kylebarron/language-stata/issues/90
+        # - statalist.org/forums/forum/general-stata-discussion/general/1448244
+        'comments': [
+            (r'(^//|(?<=\s)//)(?!/)', Comment.Single, 'comments-double-slash'),
+            (r'^\s*\*', Comment.Single, 'comments-star'),
+            (r'/\*', Comment.Multiline, 'comments-block'),
+            (r'(^///|(?<=\s)///)', Comment.Special, 'comments-triple-slash')
+        ],
+        'comments-block': [
+            (r'/\*', Comment.Multiline, '#push'),
+            # this ends and restarts a comment block. but need to catch this so
+            # that it doesn\'t start _another_ level of comment blocks
+            (r'\*/\*', Comment.Multiline),
+            (r'(\*/\s+\*(?!/)[^\n]*)|(\*/)', Comment.Multiline, '#pop'),
+            # Match anything else as a character inside the comment
+            (r'.', Comment.Multiline),
+        ],
+        'comments-star': [
+            (r'///.*?\n', Comment.Single,
+                ('#pop', 'comments-triple-slash')),
+            (r'(^//|(?<=\s)//)(?!/)', Comment.Single,
+                ('#pop', 'comments-double-slash')),
+            (r'/\*', Comment.Multiline, 'comments-block'),
+            (r'.(?=\n)', Comment.Single, '#pop'),
+            (r'.', Comment.Single),
+        ],
+        'comments-triple-slash': [
+            (r'\n', Comment.Special, '#pop'),
+            # A // breaks out of a comment for the rest of the line
+            (r'//.*?(?=\n)', Comment.Single, '#pop'),
+            (r'.', Comment.Special),
+        ],
+        'comments-double-slash': [
+            (r'\n', Text, '#pop'),
+            (r'.', Comment.Single),
+        ],
+        # `"compound string"' and regular "string"; note the former are
+        # nested.
+        'strings': [
+            (r'`"', String, 'string-compound'),
+            (r'(?<!`)"', String, 'string-regular'),
+        ],
+        'string-compound': [
+            (r'`"', String, '#push'),
             (r'"\'', String, '#pop'),
-            (r'\\\\|\\"|\\\n', String.Escape),
-            (r'\$', Name.Variable.Global, 'var_validglobal'),
-            (r'`', Name.Variable, 'var_validlocal'),
-            (r'[^$`"\\]+', String),
-            (r'[$"\\]', String),
-        ],
-        'var_validglobal': [
-            (r'\{\w{0,32}\}', Name.Variable.Global, '#pop'),
-            (r'\w{1,32}', Name.Variable.Global, '#pop'),
+            (r'\\\\|\\"|\\\$|\\`|\\\n', String.Escape),
+            include('macros'),
+            (r'.', String)
         ],
-        'var_validlocal': [
-            (r'\w{0,31}\'', Name.Variable, '#pop'),
+        'string-regular': [
+            (r'(")(?!\')|(?=\n)', String, '#pop'),
+            (r'\\\\|\\"|\\\$|\\`|\\\n', String.Escape),
+            include('macros'),
+            (r'.', String)
         ],
-        # * only OK at line start, // OK anywhere
-        'comments': [
-            (r'^\s*\*.*$', Comment),
-            (r'//.*', Comment.Single),
-            (r'/\*.*?\*/', Comment.Multiline),
-            (r'/[*](.|\n)*?[*]/', Comment.Multiline),
+        # A local is usually
+        #     `\w{0,31}'
+        #     `:extended macro'
+        #     `=expression'
+        #     `[rsen](results)'
+        #     `(++--)scalar(++--)'
+        #
+        # However, there are all sorts of weird rules wrt edge
+        # cases. Instead of writing 27 exceptions, anything inside
+        # `' is a local.
+        #
+        # A global is more restricted, so we do follow rules. Note only
+        # locals explicitly enclosed ${} can be nested.
+        'macros': [
+            (r'\$(\{|(?=[\$`]))', Name.Variable.Global, 'macro-global-nested'),
+            (r'\$', Name.Variable.Global,  'macro-global-name'),
+            (r'`', Name.Variable, 'macro-local'),
+        ],
+        'macro-local': [
+            (r'`', Name.Variable, '#push'),
+            (r"'", Name.Variable, '#pop'),
+            (r'\$(\{|(?=[\$`]))', Name.Variable.Global, 'macro-global-nested'),
+            (r'\$', Name.Variable.Global, 'macro-global-name'),
+            (r'.', Name.Variable),  # fallback
+        ],
+        'macro-global-nested': [
+            (r'\$(\{|(?=[\$`]))', Name.Variable.Global, '#push'),
+            (r'\}', Name.Variable.Global, '#pop'),
+            (r'\$', Name.Variable.Global, 'macro-global-name'),
+            (r'`', Name.Variable, 'macro-local'),
+            (r'\w', Name.Variable.Global),  # fallback
+            (r'(?!\w)', Name.Variable.Global, '#pop'),
+        ],
+        'macro-global-name': [
+            (r'\$(\{|(?=[\$`]))', Name.Variable.Global, 'macro-global-nested', '#pop'),
+            (r'\$', Name.Variable.Global, 'macro-global-name', '#pop'),
+            (r'`', Name.Variable, 'macro-local', '#pop'),
+            (r'\w{1,32}', Name.Variable.Global, '#pop'),
         ],
         # Built in functions and statements
         'keywords': [
-            (words(builtins_functions, prefix = r'\b', suffix = r'\('),
+            (words(builtins_functions, prefix = r'\b', suffix = r'(?=\()'),
              Name.Function),
             (words(builtins_base, prefix = r'(^\s*|\s)', suffix = r'\b'),
              Keyword),
@@ -100,9 +163,9 @@ class StataLexer(RegexLexer):
         ],
         # Stata formats
         'format': [
-            (r'%-?\d{1,2}(\.\d{1,2})?[gfe]c?', Name.Variable),
-            (r'%(21x|16H|16L|8H|8L)', Name.Variable),
-            (r'%-?(tc|tC|td|tw|tm|tq|th|ty|tg).{0,32}', Name.Variable),
-            (r'%[-~]?\d{1,4}s', Name.Variable),
+            (r'%-?\d{1,2}(\.\d{1,2})?[gfe]c?', Name.Other),
+            (r'%(21x|16H|16L|8H|8L)', Name.Other),
+            (r'%-?(tc|tC|td|tw|tm|tq|th|ty|tg)\S{0,32}', Name.Other),
+            (r'%[-~]?\d{1,4}s', Name.Other),
         ]
     }
diff --git a/pygments/lexers/unicon.py b/pygments/lexers/unicon.py
new file mode 100644
index 00000000..6301a88b
--- /dev/null
+++ b/pygments/lexers/unicon.py
@@ -0,0 +1,390 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.icon
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the Icon and Unicon languages, including ucode VM.
+
+    :copyright: Copyright 2006-2016 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import Lexer, RegexLexer, include, bygroups, words, \
+    using, this, default
+from pygments.util import get_bool_opt, get_list_opt
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Error
+from pygments.scanner import Scanner
+
+__all__ = ['IconLexer', 'UcodeLexer', 'UniconLexer']
+
+class UniconLexer(RegexLexer):
+    """
+    For Unicon source code.
+
+    .. versionadded:: 2.4
+    """
+
+    name = 'Unicon'
+    aliases = ['unicon']
+    filenames = ['*.icn']
+    mimetypes = ['text/unicon']
+
+    flags = re.MULTILINE
+
+    tokens = {
+        'root': [
+            (r'[^\S\n]+', Text),
+            (r'#.*?\n', Comment.Single),
+            (r'[^\S\n]+', Text),
+            (r'class|method|procedure', Keyword.Declaration, 'subprogram'),
+            (r'(record)(\s+)(\w+)',
+             bygroups(Keyword.Declaration, Text, Keyword.Type), 'type_def'),
+            (r'(#line|\$C|\$Cend|\$define|\$else|\$endif|\$error|\$ifdef|'
+             r'\$ifndef|\$include|\$line|\$undef)\b', Keyword.PreProc),
+            (r'(&null|&fail)\b', Keyword.Constant),
+            (r'&allocated|&ascii|&clock|&collections|&column|&col|&control|'
+             r'&cset|&current|&dateline|&date|&digits|&dump|'
+             r'&errno|&errornumber|&errortext|&errorvalue|&error|&errout|'
+             r'&eventcode|&eventvalue|&eventsource|&e|'
+             r'&features|&file|&host|&input|&interval|&lcase|&letters|'
+             r'&level|&line|&ldrag|&lpress|&lrelease|'
+             r'&main|&mdrag|&meta|&mpress|&mrelease|&now|&output|'
+             r'&phi|&pick|&pi|&pos|&progname|'
+             r'&random|&rdrag|&regions|&resize|&row|&rpress|&rrelease|'
+             r'&shift|&source|&storage|&subject|'
+             r'&time|&trace|&ucase|&version|'
+             r'&window|&x|&y', Keyword.Reserved),
+            (r'(by|of|not|to)\b', Keyword.Reserved),
+            (r'(global|local|static|abstract)\b', Keyword.Reserved),
+            (r'package|link|import', Keyword.Declaration),
+            (words((
+                'break', 'case', 'create', 'critical', 'default', 'end', 'all',
+                'do', 'else', 'every', 'fail', 'if', 'import', 'initial',
+                'initially', 'invocable', 'next',
+                'repeat', 'return', 'suspend',
+                'then', 'thread', 'until', 'while'), prefix=r'\b', suffix=r'\b'),
+             Keyword.Reserved),
+            (words((
+                'Abort', 'abs', 'acos', 'Active', 'Alert', 'any', 'Any', 'Arb',
+                'Arbno', 'args', 'array', 'asin', 'atan', 'atanh', 'Attrib', 
+                'Bal', 'bal', 'Bg', 'Break', 'Breakx', 
+                'callout', 'center', 'char', 'chdir', 'chmod', 'chown', 'chroot',
+                'classname', 'Clip', 'Clone', 'close', 'cofail', 'collect',
+                'Color', 'ColorValue', 'condvar', 'constructor', 'copy', 
+                'CopyArea', 'cos', 'Couple', 'crypt', 'cset', 'ctime', 
+                'dbcolumns', 'dbdriver', 'dbkeys', 'dblimits', 'dbproduct',
+                'dbtables', 'delay', 'delete', 'detab', 'display', 'DrawArc',
+                'DrawCircle', 'DrawCube', 'DrawCurve', 'DrawCylinder',
+                'DrawDisk', 'DrawImage', 'DrawLine', 'DrawPoint', 'DrawPolygon',
+                'DrawRectangle', 'DrawSegment', 'DrawSphere', 'DrawString',
+                'DrawTorus', 'dtor', 
+                'entab', 'EraseArea', 'errorclear', 'Event', 'eventmask',
+                'EvGet', 'EvSend', 'exec', 'exit', 'exp', 'Eye', 
+                'Fail', 'fcntl', 'fdup', 'Fence', 'fetch', 'Fg', 'fieldnames',
+                'filepair', 'FillArc', 'FillCircle', 'FillPolygon',
+                'FillRectangle', 'find', 'flock', 'flush', 'Font', 'fork', 
+                'FreeColor', 'FreeSpace', 'function', 
+                'get', 'getch', 'getche', 'getegid', 'getenv', 'geteuid',
+                'getgid', 'getgr', 'gethost', 'getpgrp', 'getpid', 'getppid',
+                'getpw', 'getrusage', 'getserv', 'GetSpace', 'gettimeofday',
+                'getuid', 'globalnames', 'GotoRC', 'GotoXY', 'gtime', 'hardlink', 
+                'iand', 'icom', 'IdentityMatrix', 'image', 'InPort', 'insert', 
+                'Int86', 'integer', 'ioctl', 'ior', 'ishift', 'istate', 'ixor', 
+                'kbhit', 'key', 'keyword', 'kill', 
+                'left', 'Len', 'list', 'load', 'loadfunc', 'localnames',
+                'lock', 'log', 'Lower', 'lstat', 
+                'many', 'map', 'match', 'MatrixMode', 'max', 'member',
+                'membernames', 'methodnames', 'methods', 'min', 'mkdir', 'move', 
+                'MultMatrix', 'mutex',
+                'name', 'NewColor', 'Normals', 'NotAny', 'numeric', 
+                'open', 'opencl', 'oprec', 'ord', 'OutPort', 
+                'PaletteChars', 'PaletteColor', 'PaletteKey', 'paramnames',
+                'parent', 'Pattern', 'Peek', 'Pending', 'pipe', 'Pixel',
+                'PlayAudio', 'Poke', 'pop', 'PopMatrix', 'Pos', 'pos',
+                'proc', 'pull', 'push', 'PushMatrix', 'PushRotate', 'PushScale',
+                'PushTranslate', 'put', 
+                'QueryPointer', 
+                'Raise', 'read', 'ReadImage', 'readlink', 'reads', 'ready',
+                'real', 'receive', 'Refresh', 'Rem', 'remove', 'rename',
+                'repl', 'reverse', 'right', 'rmdir', 'Rotate', 'Rpos',
+                'Rtab', 'rtod', 'runerr',
+                'save', 'Scale', 'seek', 'select', 'send', 'seq',
+                'serial', 'set', 'setenv', 'setgid', 'setgrent',
+                'sethostent', 'setpgrp', 'setpwent', 'setservent',
+                 'setuid', 'signal', 'sin', 'sort', 'sortf', 'Span',
+                'spawn', 'sql', 'sqrt', 'stat', 'staticnames', 'stop',
+                'StopAudio', 'string', 'structure', 'Succeed', 'Swi',
+                'symlink', 'sys_errstr', 'system', 'syswrite',
+                'Tab', 'tab', 'table', 'tan',
+                'Texcoord', 'Texture', 'TextWidth', 'Translate',
+                'trap', 'trim', 'truncate', 'trylock', 'type',
+                'umask', 'Uncouple', 'unlock', 'upto', 'utime',
+                'variable', 'VAttrib',
+                'wait', 'WAttrib', 'WDefault', 'WFlush', 'where',
+                'WinAssociate', 'WinButton', 'WinColorDialog', 'WindowContents',
+                'WinEditRegion', 'WinFontDialog', 'WinMenuBar', 'WinOpenDialog',
+                'WinPlayMedia', 'WinSaveDialog', 'WinScrollBar', 'WinSelectDialog',
+                'write', 'WriteImage', 'writes', 'WSection',
+                'WSync'), prefix=r'\b', suffix=r'\b'), 
+             Name.Function),
+            include('numbers'),
+            (r'<@|<<@|>@|>>@|\.>|\->', Operator),
+            (r'\*\*|\+\+|\-\-|\.|\=|\~\=|<\=|>\=|\=\=|\~\=\=|<<|<<\=|>>|>>\=', Operator),
+            (r':\=|:\=:|\->|<\->|\+:\=|\|', Operator),
+            (r'\=\=\=|\~\=\=\=', Operator),
+            (r'"(?:[^\\"]|\\.)*"', String),
+            (r"'(?:[^\\']|\\.)*'", String.Character),
+            (r'[*<>+=/&!?@~\\-]', Operator),
+            (r'\^', Operator),
+            (r'(\w+)(\s*|[(,])', bygroups(Name, using(this))),
+            (r"([\[\]])", Punctuation),
+            (r"(<>|=>|[()|:;,.'`]|[{}]|[%]|[&?])", Punctuation),
+            (r'\n+', Text),
+        ],
+        'numbers': [
+            (r'\b([+-]?([2-9]|[12][0-9]|3[0-6])[rR][0-9a-zA-Z]+)\b', Number.Hex),
+            (r'[+-]?[0-9]*\.([0-9]*)([Ee][+-]?[0-9]*)?', Number.Float),
+            (r'\b([+-]?[0-9]+[KMGTPkmgtp]?)\b', Number.Integer),
+        ],
+        'subprogram': [
+            (r'\(', Punctuation, ('#pop', 'formal_part')),
+            (r';', Punctuation, '#pop'),
+            (r'"[^"]+"|\w+', Name.Function),
+            include('root'),
+        ],
+        'type_def': [
+            (r'\(', Punctuation, 'formal_part'),
+        ],
+        'formal_part': [
+            (r'\)', Punctuation, '#pop'),
+            (r'\w+', Name.Variable),
+            (r',', Punctuation),
+            (r'(:string|:integer|:real)\b', Keyword.Reserved),
+            include('root'),
+        ],
+    }
+
+class IconLexer(RegexLexer):
+    """
+    Lexer for Icon
+
+    .. versionadded:: 1.6
+    """
+    name = 'Icon'
+    aliases = ['icon']
+    filenames = ['*.icon', '*.ICON']
+    mimetypes = []
+    flags = re.MULTILINE
+
+    tokens = {
+        'root': [
+            (r'[^\S\n]+', Text),
+            (r'#.*?\n', Comment.Single),
+            (r'[^\S\n]+', Text),
+            (r'class|method|procedure', Keyword.Declaration, 'subprogram'),
+            (r'(record)(\s+)(\w+)',
+             bygroups(Keyword.Declaration, Text, Keyword.Type), 'type_def'),
+            (r'(#line|\$C|\$Cend|\$define|\$else|\$endif|\$error|\$ifdef|'
+             r'\$ifndef|\$include|\$line|\$undef)\b', Keyword.PreProc),
+            (r'(&null|&fail)\b', Keyword.Constant),
+            (r'&allocated|&ascii|&clock|&collections|&column|&col|&control|'
+             r'&cset|&current|&dateline|&date|&digits|&dump|'
+             r'&errno|&errornumber|&errortext|&errorvalue|&error|&errout|'
+             r'&eventcode|&eventvalue|&eventsource|&e|'
+             r'&features|&file|&host|&input|&interval|&lcase|&letters|'
+             r'&level|&line|&ldrag|&lpress|&lrelease|'
+             r'&main|&mdrag|&meta|&mpress|&mrelease|&now|&output|'
+             r'&phi|&pick|&pi|&pos|&progname|'
+             r'&random|&rdrag|&regions|&resize|&row|&rpress|&rrelease|'
+             r'&shift|&source|&storage|&subject|'
+             r'&time|&trace|&ucase|&version|'
+             r'&window|&x|&y', Keyword.Reserved),
+            (r'(by|of|not|to)\b', Keyword.Reserved),
+            (r'(global|local|static)\b', Keyword.Reserved),
+            (r'link', Keyword.Declaration),
+            (words((
+                'break', 'case', 'create', 'default', 'end', 'all',
+                'do', 'else', 'every', 'fail', 'if', 'initial',
+                'invocable', 'next',
+                'repeat', 'return', 'suspend',
+                'then', 'until', 'while'), prefix=r'\b', suffix=r'\b'),
+             Keyword.Reserved),
+            (words((
+                'abs', 'acos', 'Active', 'Alert', 'any',
+                'args', 'array', 'asin', 'atan', 'atanh', 'Attrib', 
+                'bal', 'Bg',
+                'callout', 'center', 'char', 'chdir', 'chmod', 'chown', 'chroot',
+                'Clip', 'Clone', 'close', 'cofail', 'collect',
+                'Color', 'ColorValue', 'condvar', 'copy', 
+                'CopyArea', 'cos', 'Couple', 'crypt', 'cset', 'ctime', 
+                'delay', 'delete', 'detab', 'display', 'DrawArc',
+                'DrawCircle', 'DrawCube', 'DrawCurve', 'DrawCylinder',
+                'DrawDisk', 'DrawImage', 'DrawLine', 'DrawPoint', 'DrawPolygon',
+                'DrawRectangle', 'DrawSegment', 'DrawSphere', 'DrawString',
+                'DrawTorus', 'dtor', 
+                'entab', 'EraseArea', 'errorclear', 'Event', 'eventmask',
+                'EvGet', 'EvSend', 'exec', 'exit', 'exp', 'Eye', 
+                'fcntl', 'fdup', 'fetch', 'Fg', 'fieldnames',
+                'FillArc', 'FillCircle', 'FillPolygon',
+                'FillRectangle', 'find', 'flock', 'flush', 'Font',
+                'FreeColor', 'FreeSpace', 'function', 
+                'get', 'getch', 'getche', 'getenv',
+                'GetSpace', 'gettimeofday',
+                'getuid', 'globalnames', 'GotoRC', 'GotoXY', 'gtime', 'hardlink', 
+                'iand', 'icom', 'IdentityMatrix', 'image', 'InPort', 'insert', 
+                'Int86', 'integer', 'ioctl', 'ior', 'ishift', 'istate', 'ixor', 
+                'kbhit', 'key', 'keyword', 'kill', 
+                'left', 'Len', 'list', 'load', 'loadfunc', 'localnames',
+                'lock', 'log', 'Lower', 'lstat', 
+                'many', 'map', 'match', 'MatrixMode', 'max', 'member',
+                'membernames', 'methodnames', 'methods', 'min', 'mkdir', 'move', 
+                'MultMatrix', 'mutex',
+                'name', 'NewColor', 'Normals', 'numeric', 
+                'open', 'opencl', 'oprec', 'ord', 'OutPort', 
+                'PaletteChars', 'PaletteColor', 'PaletteKey', 'paramnames',
+                'parent', 'Pattern', 'Peek', 'Pending', 'pipe', 'Pixel',
+                'Poke', 'pop', 'PopMatrix', 'Pos', 'pos',
+                'proc', 'pull', 'push', 'PushMatrix', 'PushRotate', 'PushScale',
+                'PushTranslate', 'put', 
+                'QueryPointer', 
+                'Raise', 'read', 'ReadImage', 'readlink', 'reads', 'ready',
+                'real', 'receive', 'Refresh', 'Rem', 'remove', 'rename',
+                'repl', 'reverse', 'right', 'rmdir', 'Rotate', 'Rpos',
+                'rtod', 'runerr',
+                'save', 'Scale', 'seek', 'select', 'send', 'seq',
+                'serial', 'set', 'setenv',
+                'setuid', 'signal', 'sin', 'sort', 'sortf',
+                'spawn', 'sql', 'sqrt', 'stat', 'staticnames', 'stop',
+                'string', 'structure', 'Swi',
+                'symlink', 'sys_errstr', 'system', 'syswrite',
+                'tab', 'table', 'tan',
+                'Texcoord', 'Texture', 'TextWidth', 'Translate',
+                'trap', 'trim', 'truncate', 'trylock', 'type',
+                'umask', 'Uncouple', 'unlock', 'upto', 'utime',
+                'variable',
+                'wait', 'WAttrib', 'WDefault', 'WFlush', 'where',
+                'WinAssociate', 'WinButton', 'WinColorDialog', 'WindowContents',
+                'WinEditRegion', 'WinFontDialog', 'WinMenuBar', 'WinOpenDialog',
+                'WinPlayMedia', 'WinSaveDialog', 'WinScrollBar', 'WinSelectDialog',
+                'write', 'WriteImage', 'writes', 'WSection',
+                'WSync'), prefix=r'\b', suffix=r'\b'), 
+             Name.Function),
+            include('numbers'),
+            (r'\*\*|\+\+|\-\-|\.|\=|\~\=|<\=|>\=|\=\=|\~\=\=|<<|<<\=|>>|>>\=', Operator),
+            (r':\=|:\=:|<\-|<\->|\+:\=|\||\|\|', Operator),
+            (r'\=\=\=|\~\=\=\=', Operator),
+            (r'"(?:[^\\"]|\\.)*"', String),
+            (r"'(?:[^\\']|\\.)*'", String.Character),
+            (r'[*<>+=/&!?@~\\-]', Operator),
+            (r'(\w+)(\s*|[(,])', bygroups(Name, using(this))),
+            (r"([\[\]])", Punctuation),
+            (r"(<>|=>|[()|:;,.'`]|[{}]|[%^]|[&?])", Punctuation),
+            (r'\n+', Text),
+        ],
+        'numbers': [
+            (r'\b([+-]?([2-9]|[12][0-9]|3[0-6])[rR][0-9a-zA-Z]+)\b', Number.Hex),
+            (r'[+-]?[0-9]*\.([0-9]*)([Ee][+-]?[0-9]*)?', Number.Float),
+            (r'\b([+-]?[0-9]+[KMGTPkmgtp]?)\b', Number.Integer),
+        ],
+        'subprogram': [
+            (r'\(', Punctuation, ('#pop', 'formal_part')),
+            (r';', Punctuation, '#pop'),
+            (r'"[^"]+"|\w+', Name.Function),
+            include('root'),
+        ],
+        'type_def': [
+            (r'\(', Punctuation, 'formal_part'),
+        ],
+        'formal_part': [
+            (r'\)', Punctuation, '#pop'),
+            (r'\w+', Name.Variable),
+            (r',', Punctuation),
+            (r'(:string|:integer|:real)\b', Keyword.Reserved),
+            include('root'),
+        ],
+    }
+
+class UcodeLexer(RegexLexer):
+    """
+    Lexer for Icon ucode files
+
+    .. versionadded:: 2.4
+    """
+    name = 'ucode'
+    aliases = ['ucode']
+    filenames = ['*.u', '*.u1', '*.u2']
+    mimetypes = []
+    flags = re.MULTILINE
+
+    tokens = {
+        'root': [
+            (r'(#.*\n)', Comment),
+            (words((
+                'con', 'declend', 'end',
+                'global',
+                'impl', 'invocable',
+                'lab', 'link', 'local',
+                'record',
+                'uid', 'unions',
+                'version'),
+                prefix=r'\b', suffix=r'\b'),
+             Name.Function),
+            (words((
+                'colm', 'filen', 'line', 'synt'),
+                prefix=r'\b', suffix=r'\b'),
+             Comment),
+            (words((
+                'asgn',
+                'bang', 'bscan',
+                'cat', 'ccase', 'chfail',
+                'coact', 'cofail', 'compl',
+                'coret', 'create', 'cset',
+                'diff', 'div', 'dup',
+                'efail', 'einit', 'end', 'eqv', 'eret',
+                'error', 'escan', 'esusp',
+                'field',
+                'goto',
+                'init', 'int', 'inter',
+                'invoke',
+                'keywd',
+                'lconcat', 'lexeq', 'lexge',
+                'lexgt', 'lexle', 'lexlt', 'lexne',
+                'limit', 'llist', 'lsusp',
+                'mark', 'mark0', 'minus', 'mod', 'mult',
+                'neg', 'neqv', 'nonnull', 'noop', 'null',
+                'number', 'numeq', 'numge', 'numgt',
+                'numle', 'numlt', 'numne',
+                'pfail', 'plus', 'pnull', 'pop', 'power',
+                'pret', 'proc', 'psusp', 'push1', 'pushn1',
+                'random', 'rasgn', 'rcv', 'rcvbk', 'real',
+                'refresh', 'rswap',
+                'sdup', 'sect', 'size', 'snd', 'sndbk',
+                'str', 'subsc', 'swap',
+                'tabmat', 'tally', 'toby', 'trace',
+                'unmark',
+                'value', 'var'), prefix=r'\b', suffix=r'\b'),
+             Keyword.Declaration),
+            (words((
+                'any',
+                'case',
+                'endcase', 'endevery', 'endif',
+                'endifelse', 'endrepeat', 'endsuspend',
+                'enduntil', 'endwhile', 'every',
+                'if', 'ifelse',
+                'repeat',
+                'suspend',
+                'until',
+                'while'),
+             prefix=r'\b', suffix=r'\b'),
+             Name.Constant),
+            (r'\d+(\s*|\.$|$)', Number.Integer),
+            (r'[+-]?\d*\.\d+(E[-+]?\d+)?', Number.Float),
+            (r'[+-]?\d+\.\d*(E[-+]?\d+)?', Number.Float),
+            (r"(<>|=>|[()|:;,.'`]|[{}]|[%^]|[&?])", Punctuation),
+            (r'\s+\b', Text),
+            (r'[\w-]+', Text),
+        ],
+}
diff --git a/pygments/styles/__init__.py b/pygments/styles/__init__.py
index 1f39c692..c7050a18 100644
--- a/pygments/styles/__init__.py
+++ b/pygments/styles/__init__.py
@@ -46,6 +46,10 @@ STYLE_MAP = {
     'abap':     'abap::AbapStyle',
     'solarized-dark': 'solarized::SolarizedDarkStyle',
     'solarized-light': 'solarized::SolarizedLightStyle',
+    'sas':         'sas::SasStyle',
+    'stata':       'stata_light::StataLightStyle',
+    'stata-light': 'stata_light::StataLightStyle',
+    'stata-dark':  'stata_dark::StataDarkStyle',
 }
 
 
diff --git a/pygments/styles/stata_dark.py b/pygments/styles/stata_dark.py
new file mode 100644
index 00000000..851a9a8d
--- /dev/null
+++ b/pygments/styles/stata_dark.py
@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.styles.stata_dark
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Dark style inspired by Stata's do-file editor. Note this is not
+    meant to be a complete style, just for Stata's file formats.
+
+
+    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import Keyword, Name, Comment, String, Error, \
+    Number, Operator, Whitespace, Generic, Text
+
+
+class StataDarkStyle(Style):
+
+    default_style = ''
+
+    background_color = "#232629"
+    highlight_color = "#49483e"
+
+    styles = {
+        Whitespace:            '#bbbbbb',
+        Error:                 'bg:#e3d2d2 #a61717',
+        Text:                  '#cccccc',
+        String:                '#51cc99',
+        Number:                '#4FB8CC',
+        Operator:              '',
+        Name.Function:         '#6a6aff',
+        Name.Other:            '#e2828e',
+        Keyword:               'bold #7686bb',
+        Keyword.Constant:      '',
+        Comment:               'italic #777777',
+        Name.Variable:         'bold #7AB4DB',
+        Name.Variable.Global:  'bold #BE646C',
+        Generic.Prompt:        '#ffffff',
+    }
diff --git a/pygments/styles/stata.py b/pygments/styles/stata_light.py
index 2b5f5edd..fcca85e5 100644
--- a/pygments/styles/stata.py
+++ b/pygments/styles/stata_light.py
@@ -1,11 +1,10 @@
 # -*- coding: utf-8 -*-
 """
-    pygments.styles.stata
-    ~~~~~~~~~~~~~~~~~~~~~
+    pygments.styles.stata_light
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    Style inspired by Stata's do-file editor. Note this is not meant
-    to be a complete style. It's merely meant to mimic Stata's do file
-    editor syntax highlighting.
+    Light Style inspired by Stata's do-file editor. Note this is not
+    meant to be a complete style, just for Stata's file formats.
 
     :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
@@ -13,28 +12,28 @@
 
 from pygments.style import Style
 from pygments.token import Keyword, Name, Comment, String, Error, \
-    Number, Operator, Whitespace
+    Number, Operator, Whitespace, Text
 
 
-class StataStyle(Style):
+class StataLightStyle(Style):
     """
-    Style inspired by Stata's do-file editor. Note this is not meant
-    to be a complete style. It's merely meant to mimic Stata's do file
-    editor syntax highlighting.
+    Light mode style inspired by Stata's do-file editor. This is not
+    meant to be a complete style, just for use with Stata.
     """
 
     default_style = ''
-
     styles = {
+        Text:                  '#111111',
         Whitespace:            '#bbbbbb',
-        Comment:               'italic #008800',
+        Error:                 'bg:#e3d2d2 #a61717',
         String:                '#7a2424',
         Number:                '#2c2cff',
         Operator:              '',
+        Name.Function:         '#2c2cff',
+        Name.Other:            '#be646c',
         Keyword:               'bold #353580',
         Keyword.Constant:      '',
-        Name.Function:         '#2c2cff',
+        Comment:               'italic #008800',
         Name.Variable:         'bold #35baba',
         Name.Variable.Global:  'bold #b5565e',
-        Error:                 'bg:#e3d2d2 #a61717'
     }
diff --git a/tests/examplefiles/example.icn b/tests/examplefiles/example.icn
new file mode 100644
index 00000000..c8fcf335
--- /dev/null
+++ b/tests/examplefiles/example.icn
@@ -0,0 +1,283 @@
+#
+# $Id: button.icn,v 1.7 2006-07-09 23:43:07 rparlett Exp $
+#
+# This file is in the public domain.
+#
+# Author: Robert Parlett (parlett@dial.pipex.com)
+#
+
+package gui
+link graphics
+
+$include "guih.icn"
+
+
+#
+# This is the parent class of the button classes, including
+# checkboxes.
+#
+# A {Button} produces a BUTTON_PRESS_EVENT when the button is
+# depressed, and code BUTTON_RELEASE_EVENT when it is released,
+# as well as an ACTION_EVENT.
+# 
+# By default, when a button holds the keyboard focus a dashed
+# line appears just within the button.  Then, when return is
+# pressed an ACTION_EVENT is generated.  The method
+# {Dialog.set_initial_focus()} can be used to have the button
+# have the focus when the dialog is first displayed.
+#
+# Buttons also repeatedly produce a BUTTON_HELD_EVENT whilst they
+# are held down, rather like a repeating keyboard press.  The
+# delay between the initial repeat event and subsequent repeat
+# events is set in the parent dialog (see above).
+#
+class Button : Toggle : Component(
+   is_down,                 #               
+   is_held,                 #               
+   is_checked_flag,         #                       
+   label,
+   img_up,                  #              
+   img_down,                #                
+   img_w,                   #             
+   img_h,                   #             
+   parent_check_box_group,  #
+   parent_button_group,     #                           
+   repeat_delay,
+   no_keyboard_flag,        #
+   toggles_flag
+   )
+
+   method set_parent_button_group(x)
+      return self.parent_button_group := x
+   end
+
+   #
+   # Invoking this method disables the keyboard control over the
+   # button described above.  No dashed line will ever appear in
+   # the button display and return will have no effect on the
+   # button even if it has the focus.
+   #
+   method set_no_keyboard()
+      self.no_keyboard_flag := 1
+      self.accepts_focus_flag := &null
+   end
+   
+   #
+   # Clear the no keyboard behaviour (the default)
+   #
+   method clear_no_keyboard()
+      self.no_keyboard_flag := &null
+      self.accepts_focus_flag := 1
+   end
+
+   method tick()
+      if dispatcher.curr_time_of_day() > self.repeat_delay then
+         fire(BUTTON_HELD_EVENT)
+   end
+
+   method go_down()
+      self.is_down := 1
+      set_ticker(self.parent_dialog.repeat_rate)
+   end
+
+   method go_up()
+      self.is_down := &null
+      stop_ticker()
+   end
+
+   method handle_press(e)
+      local b
+      if self.in_region() then {
+         go_down()
+         self.repeat_delay := dispatcher.curr_time_of_day() + self.parent_dialog.repeat_delay
+         self.is_held := 1
+         every b := !(\self.parent_button_group).buttons do {
+            if b.is_unhidden() then {
+               b.is_held := 1
+               b.repeat_delay := self.repeat_delay
+            }
+         }
+         self.invalidate()
+         fire(BUTTON_PRESS_EVENT, e)
+      }
+   end
+
+   method handle_drag(e)
+      if \self.is_held then {
+         #
+         # Button held down; toggle on/off as it goes over the button 
+         #
+         if self.in_region() then {
+            if /self.is_down then {
+               go_down()
+               invalidate()
+            }
+         } else {
+            if \self.is_down then {
+               go_up()
+               invalidate()
+            }
+         }
+      }
+   end
+
+   method handle_release(e)
+      if \self.is_held then {
+         self.is_held := &null
+         if \self.is_down then {
+            go_up()
+            fire(BUTTON_RELEASE_EVENT, e)
+            on_action(e)
+         }
+      }
+   end
+
+   method on_action(e)
+      if \self.toggles_flag then {
+         if \self.parent_check_box_group then
+            self.parent_check_box_group.set_which_one(self)
+         else
+            self.toggle_is_checked()
+      }
+      self.invalidate()
+      fire(ACTION_EVENT, e)
+   end
+
+   method handle_accel(e)
+      self.Component.handle_accel(e)
+      on_action(e)
+   end
+
+   method handle_default(e)
+      if \self.has_focus then {
+         if /self.no_keyboard_flag & e == ("\r" | "\l" | " ") then {
+            on_action(e)
+         }
+      }
+   end
+
+   method handle_event(e)
+      if e === (&lpress | &rpress | &mpress) then {
+         handle_press(e)
+      } else if e === (&ldrag | &rdrag | &mdrag) then {
+         handle_drag(e)
+      } else if e === (&lrelease | &rrelease | &mrelease) then {
+         handle_release(e)
+      } else 
+         handle_default(e)
+   end
+
+   #
+   # Set the up/down images (if any) to the strings provided,
+   # which should be in Icon image format.
+   # The two images must have the same dimensions.
+   # @param x   The up image
+   # @param y   The down image
+   #
+   method set_imgs(x, y)
+      self.img_up := x
+      self.img_w := img_width(x) = img_width(y) | fatal("Image widths differ")
+      self.img_h := img_height(x) = img_height(y) | fatal("Image heights differ")
+
+      self.img_down := y
+
+      return
+   end
+
+   #
+   # Set the image (if any) to the given string, which should be in Icon image
+   # format.
+   # @param x   The image
+   #
+   method set_img(x)
+      self.img_up := self.img_down := x
+      self.img_w := img_width(x)
+      self.img_h := img_height(x)
+      return x
+   end
+
+   #
+   # Toggle the checked status of the button.  This method, and
+   # the following two methods, may be
+   # inappropriate for non-toggle styles of button.
+   #
+   method toggle_is_checked()
+      self.Toggle.toggle_is_checked()
+      self.invalidate()
+   end
+
+   #
+   # Set the status to checked.
+   #
+   method set_is_checked()
+      self.Toggle.set_is_checked()
+      self.invalidate()
+   end
+
+   #
+   # Set the status to unchecked.
+   #
+   method clear_is_checked()
+      self.Toggle.clear_is_checked()
+      self.invalidate()
+   end
+
+   #
+   # Set the button so that when it is pressed, it toggles
+   # between two states, as indicated by the is_checked
+   # flag.
+   #
+   # Instances of Checkbox have this flag on by default, but 
+   # TextButton and IconButton do not.  When the flag is on,
+   # the latter classes indicate their checked status by
+   # showing the button as being "down".
+   #
+   method set_toggles()
+      self.toggles_flag := 1
+      self.invalidate()
+   end
+
+   #
+   # Clear the toggles flag.
+   #
+   method clear_toggles()
+      self.toggles_flag := &null
+      self.invalidate()
+   end
+
+   #
+   # Set the label of the button, if any.
+   # @param x   The label
+   #
+   method set_label(x)
+      self.label := x
+      self.invalidate()
+      return x
+   end
+
+   method set_one(attr, val)
+      case attr of {
+         "label" : set_label(string_val(attr, val))
+         "is_checked" :
+            if test_flag(attr, val) then
+               set_is_checked()
+            else
+               clear_is_checked()
+         "toggles" :
+            if test_flag(attr, val) then
+               set_toggles()
+            else
+               clear_toggles()
+         "no_keyboard" :
+            if test_flag(attr, val) then
+               set_no_keyboard()
+            else
+               clear_no_keyboard()
+         default: self.Component.set_one(attr, val)
+      }
+   end
+
+   initially()
+      self.Component.initially()
+      self.accepts_focus_flag := 1
+end
\ No newline at end of file
diff --git a/tests/examplefiles/example.icon b/tests/examplefiles/example.icon
new file mode 100644
index 00000000..29bc548b
--- /dev/null
+++ b/tests/examplefiles/example.icon
@@ -0,0 +1,381 @@
+############################################################################
+#
+#       File:     kaleid.icn
+#
+#       Subject:  Program to produce kaleidoscope
+#
+#       Author:   Stephen B. Wampler
+#
+#       Date:     May 2, 2001
+#
+############################################################################
+#
+#   This file is in the public domain.
+#
+############################################################################
+#
+#    Lots of options, most easily set by with the interface after
+#    startup.  The only one that isn't set that way is -wn where 'n' is
+#    the size of the kaleidoscope window (default is 600 square).
+#
+#    Terminology (and options):
+#
+#       Window_size (-wN): How big of a display window to use.
+#           At the current time, this can only be set via a
+#           command line argument.
+#
+#       Density (-dN): How many circles per octant to keep on display
+#           at any one time.  There is NO LIMIT to the density.
+#
+#       Duration (-lN): How long to keep drawing circles (measured in
+#           in circles) once the density is reached.  There is NO LIMIT
+#           to the duration.
+#
+#       MaxRadius (-MN): Maximum radius of any circle.
+#
+#       MinRadius (-mN): Preferred minimum radius.  Circles with centers
+#           near the edge have their radii forced down to fit entirely
+#           on the display
+#
+#       MaxOffset (-XN): Maximum offset from center of display (may wrap).
+#
+#       MinOffset (-xN): Minimum offset
+#
+#       Skew (-sN): Shift probability of placing a circle at a 'typical'
+#           offset.
+#
+#       Fill (-F): Turns off filling the circles.
+#
+#       Clear (-C): After the duration, reduces density back to 0 before
+#           quitting.
+#
+#       Random Seed: (-rN): Sets the random number seed.
+#
+# Thanks to Jon Lipp for help on using vidgets, and to Mary Camaron
+#   for her Interface Builder.
+#
+############################################################################
+#
+#  Requires:  Version 9 graphics
+#
+############################################################################
+#
+#  Links:  vidgets, vslider, vtext, vbuttons, vradio, wopen, xcompat
+#
+############################################################################
+
+link vidgets
+link vslider
+link vtext
+link vbuttons
+link vradio
+link wopen
+link xcompat
+
+global Clear, fill, duration, density, maxoff, minoff
+global maxradius, minradius, r_seed, skew, win_size, mid_win
+global root, check1, mainwin, use_dialog
+global draw_circle
+
+global du_v, de_v, rs_v, sk_v
+
+procedure main (args)
+
+   draw_circle := DrawCircle
+
+   init_globs()
+   process_args(args)
+
+   if \use_dialog then {        # have vidgets, so use them for args.
+      mainwin := WOpen("label=Kaleidoscope", "width=404", "height=313", 
+                       "font=6x12") |
+                 stop ("bad mainwin")
+      root := ui (mainwin)
+      GetEvents (root, quit)
+      }
+   else {                       # just rely on command line arguments
+      kaleidoscope(r_seed)
+      }
+
+end
+
+procedure init_globs()
+
+   duration := 500                    # set default characteristics
+   density := 30
+   win_size := 600
+   minoff := 1
+   maxradius := 150
+   minradius := 1
+   skew := 1
+   fill := "On"
+   draw_circle := FillCircle
+   Clear := "Off"
+   r_seed := map("HhMmYy", "Hh:Mm:Yy", &clock)
+   # See if the Vidget library is available or not
+   if \VSet then use_dialog := "yes"
+            else use_dialog := &null
+
+end
+
+procedure process_args(args)
+   local arg
+
+   # really only needed if you don't use the dialog box
+   every arg := !args do case arg[1+:2] of {
+      "-w" : win_size := integer(arg[3:0])       # window size
+      "-d" : density := integer(arg[3:0])        # density of circles
+      "-l" : duration := integer(arg[3:0])       # duration
+      "-M" : maxradius := integer(arg[3:0])      # maximum radius
+      "-m" : minradius := integer(arg[3:0])      # minimum radius
+      "-X" : maxoff := integer(arg[3:0])         # maximum offset
+      "-x" : minoff := integer(arg[3:0])         # minimum offset
+      "-s" : skew := numeric(arg[3:0])           # set skewedness
+      "-F" : fill := &null                       # turn off fill
+      "-C" : Clear := "yes"                      # turn on clear mode
+      "-r" : r_seed := integer(arg[3:0])         # random seed
+      "-h" : stop("usage: kal [-wn] [-dn] [-ln] [-Mn] [-mn] [-Xn] [-xn] _
+                     [-sn] [-F] [-C] [-rn]")
+      }
+   # adjust parameters that depend on the window size...
+   mid_win := win_size/2
+   maxoff := win_size-1
+end
+
+# Lorraine Callahan's kaleidoscope program, translated into icon.
+#  (some of the things she did were too sophisticated for me
+#   to spend time to figure out, so the output is square instead of
+#   round), and I use 'xor' to draw instead of writing to separate
+#   bit planes.
+
+global putcircle, clrcircle
+
+procedure kaleidoscope(r)
+   local colors
+
+   # What colors to use?  This can be changed to whatever!
+   colors := ["red","green","blue","cyan","magenta","yellow"]
+
+   &window := WOpen("label=Kaleidoscope: 'q' quits", "width="||win_size,
+                                  "height="||win_size, "bg=black")
+   WAttrib("drawop=xor")
+
+   # Create two *indentical* sequences of circles, one to use when
+   #   when drawing, one for erasing.  (Since 'xor' is used to
+   #   place them, these both just draw the circles!)
+
+   putcircle := create {                # draws sequence of circles
+      &random :=: r
+      |{
+       Fg(?colors)
+       outcircle()
+       &random <-> r
+       }
+      }
+
+   clrcircle := create {                # erases sequence of circles
+      &random :=: r
+      |{
+       Fg(?colors)
+       outcircle()
+       &random <-> r
+       }
+      }
+
+   every 1 to density do @putcircle     # fill screen to density
+
+   every 1 to duration do {             # maintain steady state
+      @putcircle
+      @clrcircle
+      if *Pending(&window) > 0 then break
+      }
+
+   every (Clear == "On") & 1 to density do @clrcircle
+
+   close(&window)
+end
+
+
+procedure outcircle()                   # select a circle at random,
+local radius, xoff, yoff                #  draw it in kaleidoscopic form
+
+        # get a random center point and radius
+   xoff := (?(maxoff - minoff) + minoff) % mid_win
+   yoff := (?(maxoff - minoff) + minoff) % mid_win
+   radius := ?0 ^ skew
+        # force radius to 'fit'
+   radius := ((maxradius-minradius) * radius + minradius) %
+             (mid_win - ((xoff < yoff)|xoff))
+
+        # put into all 8 octants
+   draw_circle(mid_win+xoff, mid_win+yoff, radius)
+   draw_circle(mid_win+xoff, mid_win-yoff, radius)
+   draw_circle(mid_win-xoff, mid_win+yoff, radius)
+   draw_circle(mid_win-xoff, mid_win-yoff, radius)
+
+   draw_circle(mid_win+yoff, mid_win+xoff, radius)
+   draw_circle(mid_win+yoff, mid_win-xoff, radius)
+   draw_circle(mid_win-yoff, mid_win+xoff, radius)
+   draw_circle(mid_win-yoff, mid_win-xoff, radius)
+
+   return
+end
+
+
+############################################################################
+#
+#   Vidget-based user interface -- developed originally using Mary
+#       Camaron's XIB program.  Don't expect this to be very readable -
+#       you should have to play with it!
+#
+############################################################################
+procedure ui (win)
+   local cv1, cv2, cv3, cv4
+   local 
+         radio_button2, 
+         radio_button1, 
+         text_input6, 
+         text_input5, 
+         slider4, 
+         slider3, 
+         text_input4, 
+         text_input3, 
+         slider2, 
+         slider1 
+
+   /win := WOpen("label=ui", "width=404", "height=313", "font=6x12") | 
+           stop ("bad win")
+   root := Vroot_frame (win)
+
+   VInsert (root, Vmessage(win, win_size/2), 168, 98)
+   VInsert (root, Vmessage(win, "1"), 108, 97)
+
+   VInsert (root, sk_v := Vtext(win,"Skew:\\=1",get_skew,,6), 280, 39)
+
+   VInsert (root, du_v := Vtext(win, "Duration:\\="||duration, get_duration,,9),
+                237, 15)
+
+   VInsert (root, Vmessage(win, "Clear at end?"), 232, 145)
+   VInsert (root, Vmessage(win, "Fill?"), 105, 142)
+   VInsert (root, Vmessage(win,"Quit?"), 267, 259)
+   VInsert (root, Vmessage(win,"Display it?"), 26, 260)
+
+   VInsert (root, Vcheckbox(win, do_quit, "check2",20), 305, 255, 20, 20)
+
+   VInsert (root, check1:=Vcheckbox(win, do_display, "check1",20),
+                106, 258, 20, 20)
+
+   radio_button2 := Vradio_buttons (win, ["On", "Off"], get_clear, , V_CIRCLE)
+   VSet(radio_button2,Clear)
+   VInsert (root, radio_button2, 253, 165)
+
+   radio_button1 := Vradio_buttons (win, ["On", "Off"], get_fill, , V_CIRCLE)
+   VSet(radio_button1,fill)
+   VInsert (root, radio_button1, 99, 165)
+
+   cv1 := Vcoupler()
+   VAddClient(cv1, get_max_offset)
+   text_input6 := Vtext (win, "Max Offset:\\="||(win_size-1), cv1, , 3)
+   VAddClient(cv1, text_input6)
+   slider4 := Vhoriz_slider (win, cv1, "slider4", 70, 12, 0,
+                         win_size-1, win_size-1, )
+   VAddClient(cv1, slider4)
+   VInsert (root, text_input6, 196, 103)
+   VInsert (root, slider4, 306, 106)
+
+   cv2 := Vcoupler()
+   VAddClient(cv2, get_min_offset)
+   text_input5 := Vtext (win, "Min Offset\\=1", cv2, , 3)
+   VAddClient(cv2, text_input5)
+   slider3 := Vhoriz_slider (win, cv2, "slider3", 70, 12, 1, win_size-1, 1, )
+   VAddClient(cv2, slider3)
+   VInsert (root, text_input5, 201, 80)
+   VInsert (root, slider3, 307, 82)
+
+   cv3 := Vcoupler()
+   VAddClient(cv3, get_max_radius)
+   text_input4 := Vtext (win, "Max Radius\\="||(win_size/4), cv3, , 3)
+   VAddClient(cv3, text_input4)
+   slider2 := Vhoriz_slider (win, cv3, "slider2", 70, 12, 1, win_size/2,
+         win_size/4, )
+   VAddClient(cv3, slider2)
+   VInsert (root, text_input4, 10, 104)
+   VInsert (root, slider2, 110, 108)
+
+   cv4 := Vcoupler()
+   VAddClient(cv4, get_min_radius)
+   text_input3 := Vtext (win, "Min Radius\\=1", cv4, , 3)
+   VAddClient(cv4, text_input3)
+   slider1 := Vhoriz_slider (win, cv4, "slider1", 70, 12, 1, win_size/2, 1, )
+   VAddClient(cv4, slider1)
+   VInsert (root, text_input3, 10, 81)
+   VInsert (root, slider1, 110, 84)
+
+   VInsert (root, rs_v := Vtext(win,"Random Seed:\\="||r_seed, get_random,, 11),
+              30, 41)
+   VInsert (root, de_v := Vtext(win,"Density:\\="||density, get_density,,8),
+              71, 16)
+
+   VResize (root)
+   return root
+end
+
+procedure get_skew (wit, value)
+   skew := value
+end
+
+procedure get_duration (wit, value)
+   duration := value
+end
+
+procedure do_quit (wit, value)
+   stop()
+end
+
+procedure do_display (wit, value)
+   r_seed   := numeric(rs_v.data)
+   duration := integer(du_v.data)
+   density  := integer(de_v.data)
+   skew     := integer(sk_v.data)
+   kaleidoscope(r_seed)
+   wit.callback.value := &null
+   VDraw(check1)
+end
+
+procedure get_clear (wit, value)
+   Clear := value
+end
+
+procedure get_fill (wit, value)
+   fill := value
+   if fill == "Off" then draw_circle := DrawCircle
+   else draw_circle := FillCircle
+end
+
+procedure get_max_offset (wit, value)
+   maxoff := value
+end
+
+procedure get_min_offset (wit, value)
+   minoff := value
+end
+
+procedure get_max_radius (wit, value)
+   maxradius := value
+end
+
+procedure get_min_radius (wit, value)
+   minradius := value
+end
+
+procedure get_random (wit, value)
+   r_seed := integer(value)
+end
+
+procedure get_density (wit, value)
+   density := integer(value)
+end
+
+procedure quit(e)
+   if e === "q" then stop ("Exiting Kaleidoscope")
+end
diff --git a/tests/examplefiles/example.md b/tests/examplefiles/example.md
index 2befb107..e2bbacf1 100644
--- a/tests/examplefiles/example.md
+++ b/tests/examplefiles/example.md
@@ -46,6 +46,9 @@ this sentence @tweets a person about a #topic.
 [google](https://google.com/some/path.html)
 ![Image of Yaktocat](https://octodex.github.com/images/yaktocat.png)
 
+[reference link][id]
+[id]: http://example.com/
+
 ```
   * this is just unformated
       __text__
diff --git a/tests/examplefiles/example.toml b/tests/examplefiles/example.toml
new file mode 100644
index 00000000..9c60c79f
--- /dev/null
+++ b/tests/examplefiles/example.toml
@@ -0,0 +1,181 @@
+# This is a TOML document comment
+
+title = "TOML example file" # This is an inline comment
+
+[examples]
+# Examples taken from https://github.com/toml-lang/toml/blob/master/README.md
+key = "value"
+bare_key = "value"
+bare-key = "value"
+1234 = "value"
+"127.0.0.1" = "value"
+"character encoding" = "value"
+"ʎǝʞ" = "value"
+'key2' = "value"
+'quoted "value"' = "value"
+name = "Orange"
+physical.color = "orange"
+physical.shape = "round"
+site."google.com" = true
+a.b.c = 1
+a.d = 2
+
+[strings]
+str = "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF."
+str1 = """
+Roses are red
+Violets are blue"""
+str2 = "Roses are red\nViolets are blue"
+str3 = "Roses are red\r\nViolets are blue"
+
+  [strings.equivalents]
+  str1 = "The quick brown fox jumps over the lazy dog."
+  str2 = """
+The quick brown \
+
+
+    fox jumps over \
+      the lazy dog."""
+  str3 = """\
+         The quick brown \
+         fox jumps over \
+         the lazy dog.\
+         """
+
+  [strings.literal]
+  winpath  = 'C:\Users\nodejs\templates'
+  winpath2 = '\\ServerX\admin$\system32\'
+  quoted   = 'Tom "Dubs" Preston-Werner'
+  regex    = '<\i\c*\s*>'
+
+  [strings.multiline]
+  regex2 = '''I [dw]on't need \d{2} apples'''
+  lines  = '''
+The first newline is
+trimmed in raw strings.
+   All other whitespace
+   is preserved.
+'''
+
+[integers]
+int1 = +99
+int2 = 42
+int3 = 0
+int4 = -17
+int5 = 1_000
+int6 = 5_349_221
+int7 = 1_2_3_4_5 # discouraged format
+# hexadecimal with prefix `0x`
+hex1 = 0xDEADBEEF
+hex2 = 0xdeadbeef
+hex3 = 0xdead_beef
+# octal with prefix `0o`
+oct1 = 0o01234567
+oct2 = 0o755 # useful for Unix file permissions
+# binary with prefix `0b`
+bin1 = 0b11010110
+
+[floats]
+# fractional
+flt1 = +1.0
+flt2 = 3.1415
+flt3 = -0.01
+# exponent
+flt4 = 5e+22
+flt5 = 1e6
+flt6 = -2E-2
+# both
+flt7 = 6.626e-34
+# with underscores, for readability
+flt8 = 224_617.445_991_228
+# infinity
+sf1 = inf  # positive infinity
+sf2 = +inf # positive infinity
+sf3 = -inf # negative infinity
+# not a number
+sf4 = nan  # actual sNaN/qNaN encoding is implementation specific
+sf5 = +nan # same as `nan`
+sf6 = -nan # valid, actual encoding is implementation specific
+# plus/minus zero
+sf0_1 = +0.0
+sf0_2 = -0.0
+
+[booleans]
+bool1 = true
+bool2 = false
+
+[datetime.offset]
+odt1 = 1979-05-27T07:32:00Z
+odt2 = 1979-05-27T00:32:00-07:00
+odt3 = 1979-05-27T00:32:00.999999-07:00
+odt4 = 1979-05-27 07:32:00Z
+
+[datetime.local]
+ldt1 = 1979-05-27T07:32:00
+ldt2 = 1979-05-27T00:32:00.999999
+
+[date.local]
+ld1 = 1979-05-27
+
+[time.local]
+lt1 = 07:32:00
+lt2 = 00:32:00.999999
+
+[arrays]
+arr1 = [ 1, 2, 3 ]
+arr2 = [ "red", "yellow", "green" ]
+arr3 = [ [ 1, 2 ], [3, 4, 5] ]
+arr4 = [ "all", 'strings', """are the same""", '''type''']
+arr5 = [ [ 1, 2 ], ["a", "b", "c"] ]
+arr6 = [ 1, 2.0 ] # INVALID
+arr7 = [
+  1, 2, 3
+]
+arr8 = [
+  1,
+  2, # this is ok
+]
+
+["inline tables"]
+name = { first = "Tom", last = "Preston-Werner" }
+point = { x = 1, y = 2 }
+animal = { type.name = "pug" }
+
+["arrays of tables"]
+points = [ { x = 1, y = 2, z = 3 },
+           { x = 7, y = 8, z = 9 },
+           { x = 2, y = 4, z = 8 } ]
+
+  [products]
+
+    [[products]]
+    name = "Hammer"
+    sku = 738594937
+
+    [[products]]
+
+    [[products]]
+    name = "Nail"
+    sku = 284758393
+    color = "gray"
+
+  [fruits]
+
+    [[fruit]]
+      name = "apple"
+
+      [fruit.physical]
+        color = "red"
+        shape = "round"
+
+      [[fruit.variety]]
+        name = "red delicious"
+
+      [[fruit.variety]]
+        name = "granny smith"
+
+    [[fruit]]
+      name = "banana"
+
+      [[fruit.variety]]
+        name = "plantain"
diff --git a/tests/examplefiles/example.u b/tests/examplefiles/example.u
index 42c85902..8c6686eb 100644
--- a/tests/examplefiles/example.u
+++ b/tests/examplefiles/example.u
@@ -545,4 +545,3 @@ var y = 0;
 
        
  
-
diff --git a/tests/examplefiles/example.u1 b/tests/examplefiles/example.u1
new file mode 100644
index 00000000..92c45365
--- /dev/null
+++ b/tests/examplefiles/example.u1
@@ -0,0 +1,111 @@
+version U12.1.00
+uid     version.u1-1494453463-0
+impl    local
+global  1
+        0,000005,version,0
+
+
+proc version
+        local   0,000000,tab
+        local   1,000000,find
+        local   2,000000,many
+        con     0,010000,8,126,145,162,163,151,157,156,040
+        con     1,002000,1,8
+        con     2,020000,11,060,061,062,063,064,065,066,067,070,071,056
+        con     3,002000,1,1
+        declend
+        filen   version.icn
+        line    23
+        colm    11
+        synt    any
+        mark    L1
+        line    25
+        colm    4
+        synt    any
+        keywd   version
+        line    25
+        colm    13
+        synt    any
+        bscan
+        mark    L2
+        mark    L3
+        var     0
+        pnull
+        var     1
+        str     0
+        line    26
+        colm    15
+        synt    any
+        invoke  1
+        int     1
+        line    26
+        colm    28
+        synt    any
+        plus
+        line    26
+        colm    10
+        synt    any
+        invoke  1
+        line    26
+        colm    33
+        synt    any
+        esusp
+        goto    L4
+lab L3
+        line    26
+        colm    35
+        synt    any
+        pfail
+lab L4
+        unmark
+lab L2
+        var     0
+        var     2
+        cset    2
+        line    27
+        colm    15
+        synt    any
+        invoke  1
+        line    27
+        colm    10
+        synt    any
+        invoke  1
+        line    27
+        colm    32
+        synt    any
+        bscan
+        mark    L5
+        var     0
+        pnull
+        int     3
+        line    27
+        colm    45
+        synt    any
+        neg
+        line    27
+        colm    44
+        synt    any
+        invoke  1
+        line    27
+        colm    34
+        synt    any
+        pret
+lab L5
+        synt    any
+        pfail
+        line    27
+        colm    32
+        synt    any
+        escan
+        line    25
+        colm    13
+        synt    any
+        escan
+        unmark
+lab L1
+        pnull
+        line    30
+        colm    1
+        synt    any
+        pfail
+        end
\ No newline at end of file
diff --git a/tests/test_kotlin.py b/tests/test_kotlin.py
new file mode 100644
index 00000000..7c733ad9
--- /dev/null
+++ b/tests/test_kotlin.py
@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+"""
+    Basic JavaLexer Test
+    ~~~~~~~~~~~~~~~~~~~~
+
+    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import unittest
+
+from pygments.token import Text, Name, Operator, Keyword, Number, Punctuation, String
+from pygments.lexers import KotlinLexer
+
+class KotlinTest(unittest.TestCase):
+
+    def setUp(self):
+        self.lexer = KotlinLexer()
+        self.maxDiff = None
+    
+    def testCanCopeWithBackTickNamesInFunctions(self):
+        fragment = u'fun `wo bble`'
+        tokens = [
+            (Keyword, u'fun'),
+            (Text, u' '),
+            (Name.Function, u'`wo bble`'),
+            (Text, u'\n')
+        ]
+        self.assertEqual(tokens, list(self.lexer.get_tokens(fragment)))
+
+    def testCanCopeWithCommasAndDashesInBackTickNames(self):
+        fragment = u'fun `wo,-bble`'
+        tokens = [
+            (Keyword, u'fun'),
+            (Text, u' '),
+            (Name.Function, u'`wo,-bble`'),
+            (Text, u'\n')
+        ]
+        self.assertEqual(tokens, list(self.lexer.get_tokens(fragment)))
+    
+    def testCanCopeWithDestructuring(self):
+        fragment = u'val (a, b) = '
+        tokens = [
+            (Keyword, u'val'),
+            (Text, u' '),
+            (Punctuation, u'('),
+            (Name.Property, u'a'),
+            (Punctuation, u','),
+            (Text, u' '),
+            (Name.Property, u'b'),
+            (Punctuation, u')'),
+            (Text, u' '),
+            (Punctuation, u'='),
+            (Text, u' '),
+            (Text, u'\n')
+        ]
+        self.assertEqual(tokens, list(self.lexer.get_tokens(fragment)))
+    
+    def testCanCopeGenericsInDestructuring(self):
+        fragment = u'val (a: List<Something>, b: Set<Wobble>) ='
+        tokens = [
+            (Keyword, u'val'),
+            (Text, u' '),
+            (Punctuation, u'('),
+            (Name.Property, u'a'),
+            (Punctuation, u':'),
+            (Text, u' '),
+            (Name.Property, u'List'),
+            (Punctuation, u'<'),
+            (Name, u'Something'),
+            (Punctuation, u'>'),
+            (Punctuation, u','),
+            (Text, u' '),
+            (Name.Property, u'b'),
+            (Punctuation, u':'),
+            (Text, u' '),
+            (Name.Property, u'Set'),
+            (Punctuation, u'<'),
+            (Name, u'Wobble'),
+            (Punctuation, u'>'),
+            (Punctuation, u')'),
+            (Text, u' '),
+            (Punctuation, u'='),
+            (Text, u'\n')
+        ]
+        self.assertEqual(tokens, list(self.lexer.get_tokens(fragment)))
+
+    def testCanCopeWithGenerics(self):
+        fragment = u'inline fun <reified T : ContractState> VaultService.queryBy(): Vault.Page<T> {'
+        tokens = [
+            (Keyword, u'inline fun'),
+            (Text, u' '),
+            (Punctuation, u'<'),
+            (Keyword, u'reified'),
+            (Text, u' '),
+            (Name, u'T'),
+            (Text, u' '),
+            (Punctuation, u':'),
+            (Text, u' '),
+            (Name, u'ContractState'),
+            (Punctuation, u'>'),
+            (Text, u' '),
+            (Name.Class, u'VaultService'),
+            (Punctuation, u'.'),
+            (Name.Function, u'queryBy'),
+            (Punctuation, u'('),
+            (Punctuation, u')'),
+            (Punctuation, u':'),
+            (Text, u' '),
+            (Name, u'Vault'),
+            (Punctuation, u'.'),
+            (Name, u'Page'),
+            (Punctuation, u'<'),
+            (Name, u'T'),
+            (Punctuation, u'>'),
+            (Text, u' '),
+            (Punctuation, u'{'),
+            (Text, u'\n')
+        ]
+        self.assertEqual(tokens, list(self.lexer.get_tokens(fragment)))
+
+    def testShouldCopeWithMultilineComments(self):
+        fragment = u'"""\nthis\nis\na\ncomment"""'
+        tokens = [
+            (String, u'"""\nthis\nis\na\ncomment"""'), 
+            (Text, u'\n')
+        ]
+        self.assertEqual(tokens, list(self.lexer.get_tokens(fragment)))
+
+if __name__ == '__main__':
+    unittest.main()