20 files changed, 1964 insertions, 63 deletions
diff --git a/AUTHORS b/AUTHORS
index cfa1e532..ae77e7fb 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -27,6 +27,7 @@ Other contributors, listed alphabetically, are:
 * Pierre Bourdon -- bugfixes
 * Hiram Chirino -- Scaml and Jade lexers
 * Ian Cooper -- VGL lexer
+* David Corbett -- Inform lexers
 * Leaf Corcoran -- MoonScript lexer
 * Christopher Creutzig -- MuPAD lexer
 * Daniël W. Crompton - Pike lexer
@@ -70,6 +71,7 @@ Other contributors, listed alphabetically, are:
 * Brian R. Jackson -- Tea lexer
 * Christian Jann -- ShellSession lexer
 * Dennis Kaarsemaker -- sources.list lexer
+* Alexander Kit -- MaskJS lexer
 * Igor Kalnitsky -- vhdl lexer
 * Pekka Klärck -- Robot Framework lexer
 * Eric Knibbe -- Lasso lexer
@@ -115,6 +117,7 @@ Other contributors, listed alphabetically, are:
 * Benjamin Peterson -- Test suite refactoring
 * Dominik Picheta -- Nimrod lexer
 * Clément Prévost -- UrbiScript lexer
+* raichoo -- Idris lexer
 * Kashif Rasul -- CUDA lexer
 * Justin Reidy -- MXML lexer
 * Norman Richards -- JSON lexer
diff --git a/CHANGES b/CHANGES
index 028d3595..bc2d2afd 100644
--- a/CHANGES
+++ b/CHANGES
@@ -34,6 +34,12 @@ Version 2.0
   * Kal (PR#233)
   * Eiffel (PR#273)
   * Cirru (PR#275)
+  * ColdFusion CFC (PR#283)
+  * Idris (PR#210)
+  * Intel objdump (PR#279)
+  * MaskJS (PR#280)
+  * Inform 6/7 (PR#281)
+  * MQL (PR#285)
 
 - New styles: "xcode" and "igor", similar to the default highlighting of
   the respective IDEs.
diff --git a/pygments/lexers/__init__.py b/pygments/lexers/__init__.py
index d844ef0d..7bcf3bf0 100644
--- a/pygments/lexers/__init__.py
+++ b/pygments/lexers/__init__.py
@@ -98,7 +98,7 @@ def get_lexer_by_name(_alias, **options):
 def get_lexer_for_filename(_fn, code=None, **options):
     """
     Get a lexer for a filename.  If multiple lexers match the filename
-    pattern, use ``analyze_text()`` to figure out which one is more
+    pattern, use ``analyse_text()`` to figure out which one is more
     appropriate.
     """
     matches = []
diff --git a/pygments/lexers/_mapping.py b/pygments/lexers/_mapping.py
index e1426b6f..3258c865 100644
--- a/pygments/lexers/_mapping.py
+++ b/pygments/lexers/_mapping.py
@@ -69,7 +69,8 @@ LEXERS = {
     'CobolFreeformatLexer': ('pygments.lexers.compiled', 'COBOLFree', ('cobolfree',), ('*.cbl', '*.CBL'), ()),
     'CobolLexer': ('pygments.lexers.compiled', 'COBOL', ('cobol',), ('*.cob', '*.COB', '*.cpy', '*.CPY'), ('text/x-cobol',)),
     'CoffeeScriptLexer': ('pygments.lexers.web', 'CoffeeScript', ('coffee-script', 'coffeescript', 'coffee'), ('*.coffee',), ('text/coffeescript',)),
-    'ColdfusionHtmlLexer': ('pygments.lexers.templates', 'Coldfusion HTML', ('cfm',), ('*.cfm', '*.cfml', '*.cfc'), ('application/x-coldfusion',)),
+    'ColdfusionCFCLexer': ('pygments.lexers.templates', 'Coldfusion CFC', ('cfc',), ('*.cfc',), ()),
+    'ColdfusionHtmlLexer': ('pygments.lexers.templates', 'Coldfusion HTML', ('cfm',), ('*.cfm', '*.cfml'), ('application/x-coldfusion',)),
     'ColdfusionLexer': ('pygments.lexers.templates', 'cfstatement', ('cfs',), (), ()),
     'CommonLispLexer': ('pygments.lexers.functional', 'Common Lisp', ('common-lisp', 'cl', 'lisp'), ('*.cl', '*.lisp', '*.el'), ('text/x-common-lisp',)),
     'CoqLexer': ('pygments.lexers.functional', 'Coq', ('coq',), ('*.v',), ('text/x-coq',)),
@@ -143,7 +144,11 @@ LEXERS = {
     'HyLexer': ('pygments.lexers.agile', 'Hy', ('hylang',), ('*.hy',), ('text/x-hy', 'application/x-hy')),
     'HybrisLexer': ('pygments.lexers.other', 'Hybris', ('hybris', 'hy'), ('*.hy', '*.hyb'), ('text/x-hybris', 'application/x-hybris')),
     'IDLLexer': ('pygments.lexers.math', 'IDL', ('idl',), ('*.pro',), ('text/idl',)),
+    'IdrisLexer': ('pygments.lexers.functional', 'Idris', ('idris', 'idr'), ('*.idr',), ('text/x-idris',)),
     'IgorLexer': ('pygments.lexers.math', 'Igor', ('igor', 'igorpro'), ('*.ipf',), ('text/ipf',)),
+    'Inform6Lexer': ('pygments.lexers.compiled', 'Inform 6', ('inform6', 'i6'), ('*.inf',), ()),
+    'Inform6TemplateLexer': ('pygments.lexers.compiled', 'Inform 6 template', ('i6t',), ('*.i6t',), ()),
+    'Inform7Lexer': ('pygments.lexers.compiled', 'Inform 7', ('inform7', 'i7'), ('*.ni', '*.i7x'), ()),
     'IniLexer': ('pygments.lexers.text', 'INI', ('ini', 'cfg', 'dosini'), ('*.ini', '*.cfg'), ('text/x-ini',)),
     'IoLexer': ('pygments.lexers.agile', 'Io', ('io',), ('*.io',), ('text/x-iosrc',)),
     'IokeLexer': ('pygments.lexers.jvm', 'Ioke', ('ioke', 'ik'), ('*.ik',), ('text/x-iokesrc',)),
@@ -173,6 +178,7 @@ LEXERS = {
     'LighttpdConfLexer': ('pygments.lexers.text', 'Lighttpd configuration file', ('lighty', 'lighttpd'), (), ('text/x-lighttpd-conf',)),
     'LiterateAgdaLexer': ('pygments.lexers.functional', 'Literate Agda', ('lagda', 'literate-agda'), ('*.lagda',), ('text/x-literate-agda',)),
     'LiterateHaskellLexer': ('pygments.lexers.functional', 'Literate Haskell', ('lhs', 'literate-haskell', 'lhaskell'), ('*.lhs',), ('text/x-literate-haskell',)),
+    'LiterateIdrisLexer': ('pygments.lexers.functional', 'Literate Idris', ('lidr', 'literate-idris', 'lidris'), ('*.lidr',), ('text/x-literate-idris',)),
     'LiveScriptLexer': ('pygments.lexers.web', 'LiveScript', ('live-script', 'livescript'), ('*.ls',), ('text/livescript',)),
     'LlvmLexer': ('pygments.lexers.asm', 'LLVM', ('llvm',), ('*.ll',), ('text/x-llvm',)),
     'LogosLexer': ('pygments.lexers.compiled', 'Logos', ('logos',), ('*.x', '*.xi', '*.xm', '*.xmi'), ('text/x-logos',)),
@@ -186,6 +192,7 @@ LEXERS = {
     'MakoLexer': ('pygments.lexers.templates', 'Mako', ('mako',), ('*.mao',), ('application/x-mako',)),
     'MakoXmlLexer': ('pygments.lexers.templates', 'XML+Mako', ('xml+mako',), (), ('application/xml+mako',)),
     'MaqlLexer': ('pygments.lexers.other', 'MAQL', ('maql',), ('*.maql',), ('text/x-gooddata-maql', 'application/x-gooddata-maql')),
+    'MaskLexer': ('pygments.lexers.web', 'Mask', ('mask',), ('*.mask',), ('text/x-mask',)),
     'MasonLexer': ('pygments.lexers.templates', 'Mason', ('mason',), ('*.m', '*.mhtml', '*.mc', '*.mi', 'autohandler', 'dhandler'), ('application/x-mason',)),
     'MathematicaLexer': ('pygments.lexers.math', 'Mathematica', ('mathematica', 'mma', 'nb'), ('*.nb', '*.cdf', '*.nbp', '*.ma'), ('application/mathematica', 'application/vnd.wolfram.mathematica', 'application/vnd.wolfram.mathematica.package', 'application/vnd.wolfram.cdf')),
     'MatlabLexer': ('pygments.lexers.math', 'Matlab', ('matlab',), ('*.m',), ('text/matlab',)),
@@ -208,6 +215,7 @@ LEXERS = {
     'MyghtyXmlLexer': ('pygments.lexers.templates', 'XML+Myghty', ('xml+myghty',), (), ('application/xml+myghty',)),
     'NSISLexer': ('pygments.lexers.other', 'NSIS', ('nsis', 'nsi', 'nsh'), ('*.nsi', '*.nsh'), ('text/x-nsis',)),
     'NasmLexer': ('pygments.lexers.asm', 'NASM', ('nasm',), ('*.asm', '*.ASM'), ('text/x-nasm',)),
+    'NasmObjdumpLexer': ('pygments.lexers.asm', 'objdump-nasm', ('objdump-nasm',), ('*.objdump-intel',), ('text/x-nasm-objdump',)),
     'NemerleLexer': ('pygments.lexers.dotnet', 'Nemerle', ('nemerle',), ('*.n',), ('text/x-nemerle',)),
     'NesCLexer': ('pygments.lexers.compiled', 'nesC', ('nesc',), ('*.nc',), ('text/x-nescsrc',)),
     'NewLispLexer': ('pygments.lexers.functional', 'NewLisp', ('newlisp',), ('*.lsp', '*.nl'), ('text/x-newlisp', 'application/x-newlisp')),
diff --git a/pygments/lexers/asm.py b/pygments/lexers/asm.py
index 6cdb1134..2727a55d 100644
--- a/pygments/lexers/asm.py
+++ b/pygments/lexers/asm.py
@@ -17,7 +17,7 @@ from pygments.token import Text, Name, Number, String, Comment, Punctuation, \
      Other, Keyword, Operator
 
 __all__ = ['GasLexer', 'ObjdumpLexer','DObjdumpLexer', 'CppObjdumpLexer',
-           'CObjdumpLexer', 'LlvmLexer', 'NasmLexer', 'Ca65Lexer']
+           'CObjdumpLexer', 'LlvmLexer', 'NasmLexer', 'NasmObjdumpLexer', 'Ca65Lexer']
 
 
 class GasLexer(RegexLexer):
@@ -96,6 +96,55 @@ class GasLexer(RegexLexer):
             return 0.1
 
 
+def _objdump_lexer_tokens(asm_lexer):
+    """
+    Common objdump lexer tokens to wrap an ASM lexer.
+    """
+    hex_re = r'[0-9A-Za-z]'
+    return {
+	'root': [
+	    # File name & format:
+	    ('(.*?)(:)( +file format )(.*?)$',
+		bygroups(Name.Label, Punctuation, Text, String)),
+	    # Section header
+	    ('(Disassembly of section )(.*?)(:)$',
+		bygroups(Text, Name.Label, Punctuation)),
+	    # Function labels
+	    # (With offset)
+	    ('('+hex_re+'+)( )(<)(.*?)([-+])(0[xX][A-Za-z0-9]+)(>:)$',
+		bygroups(Number.Hex, Text, Punctuation, Name.Function,
+			 Punctuation, Number.Hex, Punctuation)),
+	    # (Without offset)
+	    ('('+hex_re+'+)( )(<)(.*?)(>:)$',
+		bygroups(Number.Hex, Text, Punctuation, Name.Function,
+			 Punctuation)),
+	    # Code line with disassembled instructions
+	    ('( *)('+hex_re+r'+:)(\t)((?:'+hex_re+hex_re+' )+)( *\t)([a-zA-Z].*?)$',
+		bygroups(Text, Name.Label, Text, Number.Hex, Text,
+			 using(asm_lexer))),
+	    # Code line with ascii
+	    ('( *)('+hex_re+r'+:)(\t)((?:'+hex_re+hex_re+' )+)( *)(.*?)$',
+		bygroups(Text, Name.Label, Text, Number.Hex, Text, String)),
+	    # Continued code line, only raw opcodes without disassembled
+	    # instruction
+	    ('( *)('+hex_re+r'+:)(\t)((?:'+hex_re+hex_re+' )+)$',
+		bygroups(Text, Name.Label, Text, Number.Hex)),
+	    # Skipped a few bytes
+	    (r'\t\.\.\.$', Text),
+	    # Relocation line
+	    # (With offset)
+	    (r'(\t\t\t)('+hex_re+r'+:)( )([^\t]+)(\t)(.*?)([-+])(0x'+hex_re+'+)$',
+		bygroups(Text, Name.Label, Text, Name.Property, Text,
+			 Name.Constant, Punctuation, Number.Hex)),
+	    # (Without offset)
+	    (r'(\t\t\t)('+hex_re+r'+:)( )([^\t]+)(\t)(.*?)$',
+		bygroups(Text, Name.Label, Text, Name.Property, Text,
+			 Name.Constant)),
+	    (r'[^\n]+\n', Other)
+	]
+    }
+
+
 class ObjdumpLexer(RegexLexer):
     """
     For the output of 'objdump -dr'
@@ -105,50 +154,9 @@ class ObjdumpLexer(RegexLexer):
     filenames = ['*.objdump']
     mimetypes = ['text/x-objdump']
 
-    hex = r'[0-9A-Za-z]'
 
-    tokens = {
-        'root': [
-            # File name & format:
-            ('(.*?)(:)( +file format )(.*?)$',
-                bygroups(Name.Label, Punctuation, Text, String)),
-            # Section header
-            ('(Disassembly of section )(.*?)(:)$',
-                bygroups(Text, Name.Label, Punctuation)),
-            # Function labels
-            # (With offset)
-            ('('+hex+'+)( )(<)(.*?)([-+])(0[xX][A-Za-z0-9]+)(>:)$',
-                bygroups(Number.Hex, Text, Punctuation, Name.Function,
-                         Punctuation, Number.Hex, Punctuation)),
-            # (Without offset)
-            ('('+hex+'+)( )(<)(.*?)(>:)$',
-                bygroups(Number.Hex, Text, Punctuation, Name.Function,
-                         Punctuation)),
-            # Code line with disassembled instructions
-            ('( *)('+hex+r'+:)(\t)((?:'+hex+hex+' )+)( *\t)([a-zA-Z].*?)$',
-                bygroups(Text, Name.Label, Text, Number.Hex, Text,
-                         using(GasLexer))),
-            # Code line with ascii
-            ('( *)('+hex+r'+:)(\t)((?:'+hex+hex+' )+)( *)(.*?)$',
-                bygroups(Text, Name.Label, Text, Number.Hex, Text, String)),
-            # Continued code line, only raw opcodes without disassembled
-            # instruction
-            ('( *)('+hex+r'+:)(\t)((?:'+hex+hex+' )+)$',
-                bygroups(Text, Name.Label, Text, Number.Hex)),
-            # Skipped a few bytes
-            (r'\t\.\.\.$', Text),
-            # Relocation line
-            # (With offset)
-            (r'(\t\t\t)('+hex+r'+:)( )([^\t]+)(\t)(.*?)([-+])(0x' + hex + '+)$',
-                bygroups(Text, Name.Label, Text, Name.Property, Text,
-                         Name.Constant, Punctuation, Number.Hex)),
-            # (Without offset)
-            (r'(\t\t\t)('+hex+r'+:)( )([^\t]+)(\t)(.*?)$',
-                bygroups(Text, Name.Label, Text, Name.Property, Text,
-                         Name.Constant)),
-            (r'[^\n]+\n', Other)
-        ]
-    }
+    tokens = _objdump_lexer_tokens(GasLexer)
+
 
 
 class DObjdumpLexer(DelegatingLexer):
@@ -374,6 +382,20 @@ class NasmLexer(RegexLexer):
     }
 
 
+class NasmObjdumpLexer(ObjdumpLexer):
+    """
+    For the output of 'objdump -d -M intel'.
+
+    .. versionadded:: 2.0
+    """
+    name = 'objdump-nasm'
+    aliases = ['objdump-nasm']
+    filenames = ['*.objdump-intel']
+    mimetypes = ['text/x-nasm-objdump']
+
+    tokens = _objdump_lexer_tokens(NasmLexer)
+
+
 class Ca65Lexer(RegexLexer):
     """
     For ca65 assembler sources.
diff --git a/pygments/lexers/compiled.py b/pygments/lexers/compiled.py
index 3a0245ad..735c5daa 100644
--- a/pygments/lexers/compiled.py
+++ b/pygments/lexers/compiled.py
@@ -31,7 +31,8 @@ __all__ = ['CLexer', 'CppLexer', 'DLexer', 'DelphiLexer', 'ECLexer',
            'FantomLexer', 'RustLexer', 'CudaLexer', 'MonkeyLexer', 'SwigLexer',
            'DylanLidLexer', 'DylanConsoleLexer', 'CobolLexer',
            'CobolFreeformatLexer', 'LogosLexer', 'ClayLexer', 'PikeLexer',
-           'ChapelLexer', 'EiffelLexer', 'MqlLexer']
+           'ChapelLexer', 'EiffelLexer', 'Inform6Lexer', 'Inform7Lexer',
+           'Inform6TemplateLexer', 'MqlLexer']
 
 
 class CFamilyLexer(RegexLexer):
@@ -3952,6 +3953,691 @@ class EiffelLexer(RegexLexer):
         ],
     }
 
+
+class Inform6Lexer(RegexLexer):
+    """
+    For `Inform 6 <http://inform-fiction.org/>`_ source code.
+
+    .. versionadded:: 2.0
+    """
+
+    name = 'Inform 6'
+    aliases = ['inform6', 'i6']
+    filenames = ['*.inf']
+
+    flags = re.MULTILINE | re.DOTALL | re.UNICODE
+
+    _name = r'[a-zA-Z_][a-zA-Z_0-9]*'
+
+    # Inform 7 maps these four character classes to their ASCII
+    # equivalents. To support Inform 6 inclusions within Inform 7,
+    # Inform6Lexer maps them too.
+    _dash = ur'\-\u2010-\u2014'
+    _dquote = ur'"\u201c\u201d'
+    _squote = ur"'\u2018\u2019"
+    _newline = ur'\n\u0085\u2028\u2029'
+
+    tokens = {
+        'root': [
+            (r'(\A(!%%[^%s]*[%s])+)?' % (_newline, _newline), Comment.Preproc,
+             'directive')
+        ],
+        '_whitespace': [
+            (r'\s+', Text),
+            (r'![^%s]*' % _newline, Comment.Single)
+        ],
+        'default': [
+            include('_whitespace'),
+            (r'\[', Punctuation, 'many-values'),  # Array initialization
+            (r':|(?=;)', Punctuation, '#pop'),
+            (r'<', Punctuation),  # Second angle bracket in an action statement
+            (r'', Text, ('expression', '_expression'))
+        ],
+
+        # Expressions
+        '_expression': [
+            include('_whitespace'),
+            (r'(?=sp\b)', Text, '#pop'),
+            (r'(?=[%s%s$0-9#a-zA-Z_])' % (_dquote, _squote), Text,
+             ('#pop', 'value')),
+            (r'\+\+|[%s]{1,2}(?!>)|~~?' % _dash, Operator),
+            (r'(?=[()\[%s,?@{:;])' % _dash, Text, '#pop')
+        ],
+        'expression': [
+            include('_whitespace'),
+            (r'\(', Punctuation, ('expression', '_expression')),
+            (r'\)', Punctuation, '#pop'),
+            (r'\[', Punctuation, ('#pop', 'statements', 'locals')),
+            (r'>(?=(\s+|(![^%s]*))*[>;])' % _newline, Punctuation),
+            (r'\+\+|[%s]{2}(?!>)' % _dash, Operator),
+            (r',', Punctuation, '_expression'),
+            (r'&&?|\|\|?|[=~><]?=|[%s]{1,2}>?|\.\.?[&#]?|::|[<>+*/%%]' % _dash,
+             Operator, '_expression'),
+            (r'(has|hasnt|in|notin|ofclass|or|provides)\b', Operator.Word,
+             '_expression'),
+            (r'(from|near|to)\b', Keyword, '_expression'),
+            (r'sp\b', Name),
+            (r'\?~?', Name.Label, 'label?'),
+            (r'[@{]', Error),
+            (r'', Text, '#pop')
+        ],
+        '_assembly-expression': [
+            (r'\(', Punctuation, ('#push', '_expression')),
+            (r'[\[\]]', Punctuation),
+            (r'[%s]>' % _dash, Punctuation, '_expression'),
+            (r'sp\b', Keyword.Pseudo),
+            (r';', Punctuation, '#pop:3'),
+            include('expression')
+        ],
+        '_for-expression': [
+            (r'\)', Punctuation, '#pop:2'),
+            (r':', Punctuation, '#pop'),
+            include('expression')
+        ],
+        '_list-expression': [
+            (r',', Punctuation, '#pop'),
+            include('expression')
+        ],
+        '_object-expression': [
+            (r'has\b', Keyword.Declaration, '#pop'),
+            include('_list-expression')
+        ],
+
+        # Values
+        'value': [
+            include('_whitespace'),
+            # Strings
+            (r'[%s][^@][%s]' % (_squote, _squote), String.Char, '#pop'),
+            (r'([%s])(@{[0-9a-fA-F]{1,4}})([%s])' % (_squote, _squote),
+             bygroups(String.Char, String.Escape, String.Char), '#pop'),
+            (r'([%s])(@..)([%s])' % (_squote, _squote),
+             bygroups(String.Char, String.Escape, String.Char), '#pop'),
+            (r'[%s]' % _squote, String.Single, ('#pop', 'dictionary-word')),
+            (r'[%s]' % _dquote, String.Double, ('#pop', 'string')),
+            # Numbers
+            (r'\$[+%s][0-9]*\.?[0-9]*([eE][+%s]?[0-9]+)?' % (_dash, _dash),
+             Number.Float, '#pop'),
+            (r'\$[0-9a-fA-F]+', Number.Hex, '#pop'),
+            (r'\$\$[01]+', Number, '#pop'),  # Binary
+            (r'[0-9]+', Number.Integer, '#pop'),
+            # Values prefixed by hashes
+            (r'(##|#a\$)(%s)' % _name, bygroups(Operator, Name), '#pop'),
+            (r'(#g\$)(%s)' % _name,
+             bygroups(Operator, Name.Variable.Global), '#pop'),
+            (r'#[nw]\$', Operator, ('#pop', 'obsolete-dictionary-word')),
+            (r'(#r\$)(%s)' % _name, bygroups(Operator, Name.Function), '#pop'),
+            (r'#', Name.Builtin, ('#pop', 'system-constant')),
+            # System functions
+            (r'(child|children|elder|eldest|glk|indirect|metaclass|parent|'
+             r'random|sibling|younger|youngest)\b', Name.Builtin, '#pop'),
+            # Metaclasses
+            (r'(?i)(Class|Object|Routine|String)\b', Name.Builtin, '#pop'),
+            # Veneer routines
+            (r'(?i)(Box__Routine|CA__Pr|CDefArt|CInDefArt|Cl__Ms|'
+             r'Copy__Primitive|CP__Tab|DA__Pr|DB__Pr|DefArt|Dynam__String|'
+             r'EnglishNumber|Glk__Wrap|IA__Pr|IB__Pr|InDefArt|Main__|'
+             r'Meta__class|OB__Move|OB__Remove|OC__Cl|OP__Pr|Print__Addr|'
+             r'Print__PName|PrintShortName|RA__Pr|RA__Sc|RL__Pr|R_Process|'
+             r'RT__ChG|RT__ChGt|RT__ChLDB|RT__ChLDW|RT__ChPR|RT__ChPrintA|'
+             r'RT__ChPrintC|RT__ChPrintO|RT__ChPrintS|RT__ChPS|RT__ChR|'
+             r'RT__ChSTB|RT__ChSTW|RT__ChT|RT__Err|RT__TrPS|RV__Pr|'
+             r'Symb__Tab|Unsigned__Compare|WV__Pr|Z__Region)\b', Name.Builtin,
+             '#pop'),
+            # Other built-in symbols
+            (r'(?i)(call|copy|create|DEBUG|destroy|DICT_CHAR_SIZE|'
+             r'DICT_ENTRY_BYTES|DICT_IS_UNICODE|DICT_WORD_SIZE|false|'
+             r'FLOAT_INFINITY|FLOAT_NAN|FLOAT_NINFINITY|Grammar__Version|'
+             r'INDIV_PROP_START|INFIX|infix__watching|MODULE_MODE|name|'
+             r'nothing|NUM_ATTR_BYTES|print|print_to_array|recreate|remaining|'
+             r'self|sender|STRICT_MODE|sw__var|sys__glob0|sys__glob1|'
+             r'sys__glob2|sys_statusline_flag|TARGET_GLULX|TARGET_ZCODE|'
+             r'temp__global2|temp__global3|temp__global4|temp_global|true|'
+             r'USE_MODULES|WORDSIZE)\b', Name.Builtin, '#pop'),
+            # Other values
+            (_name, Name, '#pop')
+        ],
+        # Strings
+        'dictionary-word': [
+            (r'[~^]+', String.Escape),
+            (r'[^~^\\@({%s]+' % _squote, String.Single),
+            (r'[({]', String.Single),
+            (r'@{[0-9a-fA-F]{,4}}', String.Escape),
+            (r'@..', String.Escape),
+            (r'[%s]' % _squote, String.Single, '#pop')
+        ],
+        'string': [
+            (r'[~^]+', String.Escape),
+            (r'[^~^\\@({%s]+' % _dquote, String.Double),
+            (r'[({]', String.Double),
+            (r'\\', String.Escape),
+            (r'@(\\\s*[%s]\s*)*@((\\\s*[%s]\s*)*[0-9])*' %
+             (_newline, _newline), String.Escape),
+            (r'@(\\\s*[%s]\s*)*{((\\\s*[%s]\s*)*[0-9a-fA-F]){,4}'
+             r'(\\\s*[%s]\s*)*}' % (_newline, _newline, _newline),
+             String.Escape),
+            (r'@(\\\s*[%s]\s*)*.(\\\s*[%s]\s*)*.' % (_newline, _newline),
+             String.Escape),
+            (r'[%s]' % _dquote, String.Double, '#pop')
+        ],
+        'plain-string': [
+            (r'[^~^\\({\[\]%s]+' % _dquote, String.Double),
+            (r'[~^({\[\]]', String.Double),
+            (r'\\', String.Escape),
+            (r'[%s]' % _dquote, String.Double, '#pop')
+        ],
+        # Names
+        '_constant': [
+            include('_whitespace'),
+            (_name, Name.Constant, '#pop'),
+            include('value')
+        ],
+        '_global': [
+            include('_whitespace'),
+            (_name, Name.Variable.Global, '#pop'),
+            include('value')
+        ],
+        'label?': [
+            include('_whitespace'),
+            (r'(%s)?' % _name, Name.Label, '#pop')
+        ],
+        'variable?': [
+            include('_whitespace'),
+            (r'(%s)?' % _name, Name.Variable, '#pop')
+        ],
+        # Values after hashes
+        'obsolete-dictionary-word': [
+            (r'\S[a-zA-Z_0-9]*', String.Other, '#pop')
+        ],
+        'system-constant': [
+            include('_whitespace'),
+            (_name, Name.Builtin, '#pop')
+        ],
+
+        # Directives
+        'directive': [
+            include('_whitespace'),
+            (r'#', Punctuation),
+            (r';', Punctuation, '#pop'),
+            (r'\[', Punctuation,
+             ('default', 'statements', 'locals', 'routine-name?')),
+            (r'(?i)(abbreviate|endif|dictionary|ifdef|iffalse|ifndef|ifnot|'
+             r'iftrue|ifv3|ifv5|release|serial|switches|system_file|version)'
+             r'\b', Keyword, 'default'),
+            (r'(?i)(array|global)\b', Keyword,
+             ('default', 'directive-keyword?', '_global')),
+            (r'(?i)attribute\b', Keyword, ('default', 'alias?', '_constant')),
+            (r'(?i)class\b', Keyword,
+             ('object-body', 'duplicates', 'class-name')),
+            (r'(?i)(constant|default)\b', Keyword,
+             ('default', 'expression', '_constant')),
+            (r'(?i)(end\b)(.*)', bygroups(Keyword, Text)),
+            (r'(?i)(extend|verb)\b', Keyword, 'grammar'),
+            (r'(?i)fake_action\b', Keyword, ('default', '_constant')),
+            (r'(?i)import\b', Keyword, 'manifest'),
+            (r'(?i)(include|link)\b', Keyword,
+             ('default', 'before-plain-string')),
+            (r'(?i)(lowstring|undef)\b', Keyword, ('default', '_constant')),
+            (r'(?i)message\b', Keyword, ('default', 'diagnostic')),
+            (r'(?i)(nearby|object)\b', Keyword,
+             ('object-body', '_object-head')),
+            (r'(?i)property\b', Keyword,
+             ('default', 'alias?', '_constant', 'property-keyword*')),
+            (r'(?i)replace\b', Keyword,
+             ('default', 'routine-name?', 'routine-name?')),
+            (r'(?i)statusline\b', Keyword, ('default', 'directive-keyword?')),
+            (r'(?i)stub\b', Keyword, ('default', 'routine-name?')),
+            (r'(?i)trace\b', Keyword,
+             ('default', 'trace-keyword?', 'trace-keyword?')),
+            (r'(?i)zcharacter\b', Keyword,
+             ('default', 'directive-keyword?', 'directive-keyword?')),
+            (_name, Name.Class, ('object-body', '_object-head'))
+        ],
+        # [, Replace, Stub
+        'routine-name?': [
+            include('_whitespace'),
+            (r'(%s)?' % _name, Name.Function, '#pop')
+        ],
+        'locals': [
+            include('_whitespace'),
+            (r';', Punctuation, '#pop'),
+            (r'\*', Punctuation),
+            (_name, Name.Variable)
+        ],
+        # Array
+        'many-values': [
+            include('_whitespace'),
+            (r';', Punctuation),
+            (r'\]', Punctuation, '#pop'),
+            (r':', Error),
+            (r'', Text, ('expression', '_expression'))
+        ],
+        # Attribute, Property
+        'alias?': [
+            include('_whitespace'),
+            (r'alias\b', Keyword, ('#pop', '_constant')),
+            (r'', Text, '#pop')
+        ],
+        # Class, Object, Nearby
+        'class-name': [
+            include('_whitespace'),
+            (r'(?=[,;]|(class|has|private|with)\b)', Text, '#pop'),
+            (_name, Name.Class, '#pop')
+        ],
+        'duplicates': [
+            include('_whitespace'),
+            (r'\(', Punctuation, ('#pop', 'expression', '_expression')),
+            (r'', Text, '#pop')
+        ],
+        '_object-head': [
+            (r'[%s]>' % _dash, Punctuation),
+            (r'(class|has|private|with)\b', Keyword.Declaration, '#pop'),
+            include('_global')
+        ],
+        'object-body': [
+            include('_whitespace'),
+            (r';', Punctuation, '#pop:2'),
+            (r',', Punctuation),
+            (r'class\b', Keyword.Declaration, 'class-segment'),
+            (r'(has|private|with)\b', Keyword.Declaration),
+            (r':', Error),
+            (r'', Text, ('_object-expression', '_expression'))
+        ],
+        'class-segment': [
+            include('_whitespace'),
+            (r'(?=[,;]|(class|has|private|with)\b)', Text, '#pop'),
+            (_name, Name.Class),
+            (r'', Text, 'value')
+        ],
+        # Extend, Verb
+        'grammar': [
+            include('_whitespace'),
+            (r'=', Punctuation, ('#pop', 'default')),
+            (r'\*', Punctuation, ('#pop', 'grammar-line')),
+            (r'', Text, '_directive-keyword')
+        ],
+        'grammar-line': [
+            include('_whitespace'),
+            (r';', Punctuation, '#pop'),
+            (r'[/*]', Punctuation),
+            (r'[%s]>' % _dash, Punctuation, 'value'),
+            (r'(noun|scope)\b', Keyword, '=routine'),
+            (r'', Text, '_directive-keyword')
+        ],
+        '=routine': [
+            include('_whitespace'),
+            (r'=', Punctuation, 'routine-name?'),
+            (r'', Text, '#pop')
+        ],
+        # Import
+        'manifest': [
+            include('_whitespace'),
+            (r';', Punctuation, '#pop'),
+            (r',', Punctuation),
+            (r'(?i)(global\b)?', Keyword, '_global')
+        ],
+        # Include, Link, Message
+        'diagnostic': [
+            include('_whitespace'),
+            (r'[%s]' % _dquote, String.Double, ('#pop', 'message-string')),
+            (r'', Text, ('#pop', 'before-plain-string', 'directive-keyword?'))
+        ],
+        'before-plain-string': [
+            include('_whitespace'),
+            (r'[%s]' % _dquote, String.Double, ('#pop', 'plain-string'))
+        ],
+        'message-string': [
+            (r'[~^]+', String.Escape),
+            include('plain-string')
+        ],
+
+        # Keywords used in directives
+        '_directive-keyword!': [
+            include('_whitespace'),
+            (r'(additive|alias|buffer|class|creature|data|error|fatalerror|'
+             r'first|has|held|initial|initstr|last|long|meta|multi|'
+             r'multiexcept|multiheld|multiinside|noun|number|only|private|'
+             r'replace|reverse|scope|score|special|string|table|terminating|'
+             r'time|topic|warning|with)\b', Keyword, '#pop'),
+            (r'[%s]{1,2}>|[+=]' % _dash, Punctuation, '#pop')
+        ],
+        '_directive-keyword': [
+            include('_directive-keyword!'),
+            include('value')
+        ],
+        'directive-keyword?': [
+            include('_directive-keyword!'),
+            (r'', Text, '#pop')
+        ],
+        'property-keyword*': [
+            include('_whitespace'),
+            (r'(additive|long)\b', Keyword),
+            (r'', Text, '#pop')
+        ],
+        'trace-keyword?': [
+            include('_whitespace'),
+            (r'(assembly|dictionary|expressions|lines|linker|objects|off|on|'
+             r'symbols|tokens|verbs)\b', Keyword, '#pop'),
+            (r'', Text, '#pop')
+        ],
+
+        # Statements
+        'statements': [
+            include('_whitespace'),
+            (r'\]', Punctuation, '#pop'),
+            (r'[;{}]', Punctuation),
+            (r'(box|break|continue|default|give|inversion|move|new_line|quit|'
+             r'read|remove|return|rfalse|rtrue|spaces|string|until)\b',
+             Keyword, 'default'),
+            (r'(do|else)\b', Keyword),
+            (r'(font|style)\b', Keyword,
+             ('default', 'miscellaneous-keyword?')),
+            (r'for\b', Keyword, ('for', '(?')),
+            (r'(if|switch|while)', Keyword,
+             ('expression', '_expression', '(?')),
+            (r'(jump|save|restore)\b', Keyword, ('default', 'label?')),
+            (r'objectloop\b', Keyword, ('expression', 'variable?', '(?')),
+            (r'print(_ret)?\b|(?=[%s])' % _dquote, Keyword, 'print-list'),
+            (r'\.', Name.Label, 'label?'),
+            (r'@', Keyword, 'opcode'),
+            (r'#(?![agrnw]\$|#)', Punctuation, 'directive'),
+            (r'<', Punctuation, 'default'),
+            (r'', Text, 'default')
+        ],
+        'miscellaneous-keyword?': [
+            include('_whitespace'),
+            (r'(bold|fixed|from|near|off|on|reverse|roman|to|underline)\b',
+             Keyword, '#pop'),
+            (r'(a|A|an|address|char|name|number|object|property|string|the|'
+             r'The)\b(?=(\s+|(![^%s]*))*\))' % _newline, Keyword.Pseudo,
+             '#pop'),
+            (r'%s(?=(\s+|(![^%s]*))*\))' % (_name, _newline), Name.Function,
+             '#pop'),
+            (r'', Text, '#pop')
+        ],
+        '(?': [
+            include('_whitespace'),
+            (r'\(?', Punctuation, '#pop')
+        ],
+        'for': [
+            include('_whitespace'),
+            (r';?', Punctuation, ('_for-expression', '_expression'))
+        ],
+        'print-list': [
+            include('_whitespace'),
+            (r';', Punctuation, '#pop'),
+            (r':', Error),
+            (r'', Text,
+             ('_list-expression', '_expression', '_list-expression', 'form'))
+        ],
+        'form': [
+            include('_whitespace'),
+            (r'\(', Punctuation, ('#pop', 'miscellaneous-keyword?')),
+            (r'', Text, '#pop')
+        ],
+
+        # Assembly
+        'opcode': [
+            include('_whitespace'),
+            (r'[%s]' % _dquote, String.Double, ('operands', 'plain-string')),
+            (_name, Keyword, 'operands')
+        ],
+        'operands': [
+            (r':', Error),
+            (r'', Text, ('_assembly-expression', '_expression'))
+        ]
+    }
+
+    def get_tokens_unprocessed(self, text):
+        # 'in' is either a keyword or an operator.
+        # If the token two tokens after 'in' is ')', 'in' is a keyword:
+        #   objectloop(a in b)
+        # Otherwise, it is an operator:
+        #   objectloop(a in b && true)
+        objectloop_queue = []
+        objectloop_token_count = -1
+        previous_token = None
+        for index, token, value in RegexLexer.get_tokens_unprocessed(self,
+                                                                     text):
+            if previous_token is Name.Variable and value == 'in':
+                objectloop_queue = [[index, token, value]]
+                objectloop_token_count = 2
+            elif objectloop_token_count > 0:
+                if token not in Comment and token not in Text:
+                    objectloop_token_count -= 1
+                objectloop_queue.append((index, token, value))
+            else:
+                if objectloop_token_count == 0:
+                    if objectloop_queue[-1][2] == ')':
+                        objectloop_queue[0][1] = Keyword
+                    while objectloop_queue:
+                        yield objectloop_queue.pop(0)
+                    objectloop_token_count = -1
+                yield index, token, value
+            if token not in Comment and token not in Text:
+                previous_token = token
+        while objectloop_queue:
+            yield objectloop_queue.pop(0)
+
+
+class Inform7Lexer(RegexLexer):
+    """
+    For `Inform 7 <http://inform7.com/>`_ source code.
+
+    .. versionadded:: 2.0
+    """
+
+    name = 'Inform 7'
+    aliases = ['inform7', 'i7']
+    filenames = ['*.ni', '*.i7x']
+
+    flags = re.MULTILINE | re.DOTALL | re.UNICODE
+
+    _dash = Inform6Lexer._dash
+    _dquote = Inform6Lexer._dquote
+    _newline = Inform6Lexer._newline
+    _start = r'\A|(?<=[%s])' % _newline
+
+    # There are three variants of Inform 7, differing in how to
+    # interpret at signs and braces in I6T. In top-level inclusions, at
+    # signs in the first column are inweb syntax. In phrase definitions
+    # and use options, tokens in braces are treated as I7. Use options
+    # also interpret "{N}".
+    tokens = {}
+    token_variants = ['+i6t-not-inline', '+i6t-inline', '+i6t-use-option']
+
+    for level in token_variants:
+        tokens[level] = {
+            '+i6-root': list(Inform6Lexer.tokens['root']),
+            '+i6t-root': [  # For Inform6TemplateLexer
+                (r'[^%s]*' % Inform6Lexer._newline, Comment.Preproc,
+                 ('directive', '+p'))
+            ],
+            'root': [
+                (r'(\|?\s)+', Text),
+                (r'\[', Comment.Multiline, '+comment'),
+                (r'[%s]' % _dquote, Generic.Heading,
+                 ('+main', '+titling', '+titling-string')),
+                (r'', Text, ('+main', '+heading?'))
+            ],
+            '+titling-string': [
+                (r'[^%s]+' % _dquote, Generic.Heading),
+                (r'[%s]' % _dquote, Generic.Heading, '#pop')
+            ],
+            '+titling': [
+                (r'\[', Comment.Multiline, '+comment'),
+                (r'[^%s.;:|%s]+' % (_dquote, _newline), Generic.Heading),
+                (r'[%s]' % _dquote, Generic.Heading, '+titling-string'),
+                (r'[%s]{2}|(?<=[\s%s])\|[\s%s]' % (_newline, _dquote, _dquote),
+                 Text, ('#pop', '+heading?')),
+                (r'[.;:]|(?<=[\s%s])\|' % _dquote, Text, '#pop'),
+                (r'[|%s]' % _newline, Generic.Heading)
+            ],
+            '+main': [
+                (r'(?i)[^%s:a\[(|%s]+' % (_dquote, _newline), Text),
+                (r'[%s]' % _dquote, String.Double, '+text'),
+                (r':', Text, '+phrase-definition'),
+                (r'(?i)\bas\b', Text, '+use-option'),
+                (r'\[', Comment.Multiline, '+comment'),
+                (r'(\([%s])(.*?)([%s]\))' % (_dash, _dash),
+                 bygroups(Punctuation,
+                          using(this, state=('+i6-root', 'directive'),
+                                i6t='+i6t-not-inline'), Punctuation)),
+                (r'(%s|(?<=[\s;:.%s]))\|\s|[%s]{2,}' %
+                 (_start, _dquote, _newline), Text, '+heading?'),
+                (r'(?i)[a(|%s]' % _newline, Text)
+            ],
+            '+phrase-definition': [
+                (r'\s+', Text),
+                (r'\[', Comment.Multiline, '+comment'),
+                (r'(\([%s])(.*?)([%s]\))' % (_dash, _dash),
+                 bygroups(Punctuation,
+                          using(this, state=('+i6-root', 'directive',
+                                             'default', 'statements'),
+                                i6t='+i6t-inline'), Punctuation), '#pop'),
+                (r'', Text, '#pop')
+            ],
+            '+use-option': [
+                (r'\s+', Text),
+                (r'\[', Comment.Multiline, '+comment'),
+                (r'(\([%s])(.*?)([%s]\))' % (_dash, _dash),
+                 bygroups(Punctuation,
+                          using(this, state=('+i6-root', 'directive'),
+                                i6t='+i6t-use-option'), Punctuation), '#pop'),
+                (r'', Text, '#pop')
+            ],
+            '+comment': [
+                (r'[^\[\]]+', Comment.Multiline),
+                (r'\[', Comment.Multiline, '#push'),
+                (r'\]', Comment.Multiline, '#pop')
+            ],
+            '+text': [
+                (r'[^\[%s]+' % _dquote, String.Double),
+                (r'\[.*?\]', String.Interpol),
+                (r'[%s]' % _dquote, String.Double, '#pop')
+            ],
+            '+heading?': [
+                (r'(\|?\s)+', Text),
+                (r'\[', Comment.Multiline, '+comment'),
+                (r'[%s]{4}\s+' % _dash, Text, '+documentation-heading'),
+                (r'[%s]{1,3}' % _dash, Text),
+                (r'(?i)(volume|book|part|chapter|section)\b[^%s]*' % _newline,
+                 Generic.Heading, '#pop'),
+                (r'', Text, '#pop')
+            ],
+            '+documentation-heading': [
+                (r'\s+', Text),
+                (r'\[', Comment.Multiline, '+comment'),
+                (r'(?i)documentation\s+', Text, '+documentation-heading2'),
+                (r'', Text, '#pop')
+            ],
+            '+documentation-heading2': [
+                (r'\s+', Text),
+                (r'\[', Comment.Multiline, '+comment'),
+                (r'[%s]{4}\s' % _dash, Text, '+documentation'),
+                (r'', Text, '#pop:2')
+            ],
+            '+documentation': [
+                (r'(?i)(%s)\s*(chapter|example)\s*:[^%s]*' %
+                 (_start, _newline), Generic.Heading),
+                (r'(?i)(%s)\s*section\s*:[^%s]*' % (_start, _newline),
+                 Generic.Subheading),
+                (r'((%s)\t.*?[%s])+' % (_start, _newline),
+                 using(this, state='+main')),
+                (r'[^%s\[]+|[%s\[]' % (_newline, _newline), Text),
+                (r'\[', Comment.Multiline, '+comment'),
+            ],
+            '+i6t-not-inline': [
+                (r'(%s)@c( .*?)?([%s]|\Z)' % (_start, _newline),
+                 Comment.Preproc),
+                (r'(%s)@([%s]+|Purpose:)[^%s]*' % (_start, _dash, _newline),
+                 Comment.Preproc),
+                (r'(%s)@p( .*?)?([%s]|\Z)' % (_start, _newline),
+                 Generic.Heading, '+p')
+            ],
+            '+i6t-use-option': [
+                include('+i6t-not-inline'),
+                (r'({)(N)(})', bygroups(Punctuation, Text, Punctuation))
+            ],
+            '+i6t-inline': [
+                (r'({)(\S[^}]*)?(})',
+                 bygroups(Punctuation, using(this, state='+main'),
+                          Punctuation))
+            ],
+            '+i6t': [
+                (r'({[%s])(![^}]*)(}?)' % _dash,
+                 bygroups(Punctuation, Comment.Single, Punctuation)),
+                (r'({[%s])(lines)(:)([^}]*)(}?)' % _dash,
+                 bygroups(Punctuation, Keyword, Punctuation, Text,
+                          Punctuation), '+lines'),
+                (r'({[%s])([^:}]*)(:?)([^}]*)(}?)' % _dash,
+                 bygroups(Punctuation, Keyword, Punctuation, Text,
+                          Punctuation)),
+                (r'(\(\+)(.*?)(\+\)|\Z)',
+                 bygroups(Punctuation, using(this, state='+main'),
+                          Punctuation))
+            ],
+            '+p': [
+                (r'[^@]+', Comment.Preproc),
+                (r'(%s)@c( .*?)?([%s]|\Z)' % (_start, _newline),
+                 Comment.Preproc, '#pop'),
+                (r'(%s)@([%s]|Purpose:)' % (_start, _dash), Comment.Preproc),
+                (r'(%s)@p( .*?)?([%s]|\Z)' % (_start, _newline),
+                 Generic.Heading),
+                (r'@', Comment.Preproc)
+            ],
+            '+lines': [
+                (r'(%s)@c( .*?)?([%s]|\Z)' % (_start, _newline),
+                 Comment.Preproc),
+                (r'(%s)@([%s]|Purpose:)[^%s]*' % (_start, _dash, _newline),
+                 Comment.Preproc),
+                (r'(%s)@p( .*?)?([%s]|\Z)' % (_start, _newline),
+                 Generic.Heading, '+p'),
+                (r'(%s)@[a-zA-Z_0-9]*[ %s]' % (_start, _newline), Keyword),
+                (r'![^%s]*' % _newline, Comment.Single),
+                (r'({)([%s]endlines)(})' % _dash,
+                 bygroups(Punctuation, Keyword, Punctuation), '#pop'),
+                (r'[^@!{]+?([%s]|\Z)|.' % _newline, Text)
+            ]
+        }
+        # Inform 7 can include snippets of Inform 6 template language,
+        # so all of Inform6Lexer's states are copied here, with
+        # modifications to account for template syntax. Inform7Lexer's
+        # own states begin with '+' to avoid name conflicts. Some of
+        # Inform6Lexer's states begin with '_': these are not modified.
+        # They deal with template syntax either by including modified
+        # states, or by matching r'' then pushing to modified states.
+        for token in Inform6Lexer.tokens:
+            if token == 'root':
+                continue
+            tokens[level][token] = list(Inform6Lexer.tokens[token])
+            if not token.startswith('_'):
+                tokens[level][token][:0] = [include('+i6t'), include(level)]
+
+    def __init__(self, **options):
+        level = options.get('i6t', '+i6t-not-inline')
+        if level not in self._all_tokens:
+            self._tokens = self.__class__.process_tokendef(level)
+        else:
+            self._tokens = self._all_tokens[level]
+        RegexLexer.__init__(self, **options)
+
+
+class Inform6TemplateLexer(Inform7Lexer):
+    """
+    For `Inform 6 template
+    <http://inform7.com/sources/src/i6template/Woven/index.html>`_ code.
+
+    .. versionadded:: 2.0
+    """
+
+    name = 'Inform 6 template'
+    aliases = ['i6t']
+    filenames = ['*.i6t']
+
+    def get_tokens_unprocessed(self, text, stack=('+i6t-root',)):
+        return Inform7Lexer.get_tokens_unprocessed(self, text, stack)
+
+
 class MqlLexer(CppLexer):
     """
     For `MQL4 <http://docs.mql4.com/>`_ and
diff --git a/pygments/lexers/functional.py b/pygments/lexers/functional.py
index 07fa9d45..e3342497 100644
--- a/pygments/lexers/functional.py
+++ b/pygments/lexers/functional.py
@@ -19,7 +19,7 @@ __all__ = ['RacketLexer', 'SchemeLexer', 'CommonLispLexer', 'HaskellLexer',
            'AgdaLexer', 'LiterateHaskellLexer', 'LiterateAgdaLexer',
            'SMLLexer', 'OcamlLexer', 'ErlangLexer', 'ErlangShellLexer',
            'OpaLexer', 'CoqLexer', 'NewLispLexer', 'NixLexer', 'ElixirLexer',
-           'ElixirConsoleLexer', 'KokaLexer']
+           'ElixirConsoleLexer', 'KokaLexer', 'IdrisLexer', 'LiterateIdrisLexer']
 
 
 line_re = re.compile('.*?\n')
@@ -1017,6 +1017,115 @@ class HaskellLexer(RegexLexer):
     }
 
 
+class IdrisLexer(RegexLexer):
+    """
+    A lexer for the dependently typed programming language Idris.
+
+    Based on the Haskell and Agda Lexer.
+
+    .. versionadded:: 2.0
+    """
+    name = 'Idris'
+    aliases = ['idris', 'idr']
+    filenames = ['*.idr']
+    mimetypes = ['text/x-idris']
+
+    reserved = ['case','class','data','default','using','do','else',
+                'if','in','infix[lr]?','instance','rewrite','auto',
+                'namespace','codata','mutual','private','public','abstract',
+                'total','partial',
+                'let','proof','of','then','static','where','_','with',
+                'pattern', 'term', 'syntax','prefix',
+                'postulate','parameters','record','dsl','impossible','implicit',
+                'tactics','intros','intro','compute','refine','exaxt','trivial']
+
+    ascii = ['NUL','SOH','[SE]TX','EOT','ENQ','ACK',
+             'BEL','BS','HT','LF','VT','FF','CR','S[OI]','DLE',
+             'DC[1-4]','NAK','SYN','ETB','CAN',
+             'EM','SUB','ESC','[FGRU]S','SP','DEL']
+
+    annotations = ['assert_total','lib','link','include','provide','access',
+                   'default']
+
+    tokens = {
+        'root': [
+            # Declaration
+            (r'^(\s*)([^\s\(\)\{\}]+)(\s*)(:)(\s*)',
+             bygroups(Text, Name.Function, Text, Operator.Word, Text)),
+            # Comments
+            (r'^(\s*)(%%%s)' % '|'.join(annotations),
+             bygroups(Text, Keyword.Reserved)),
+            (r'--(?![!#$%&*+./<=>?@\^|_~:\\]).*?$', Comment.Single),
+            (r'{-', Comment.Multiline, 'comment'),
+            #  Identifiers
+            (ur'\b(%s)(?!\')\b' % '|'.join(reserved), Keyword.Reserved),
+            (r'(import|module)(\s+)', bygroups(Keyword.Reserved, Text), 'module'),
+            (r"('')?[A-Z][\w\']*", Keyword.Type),
+            (r'[a-z][A-Za-z0-9_\']*', Text),
+            #  Special Symbols
+            (r'(<-|::|->|=>|=)', Operator.Word), # specials
+            (r'([\[\]:!#$%&*+.\\/<=>?@^|~-]+)', Operator.Word), # specials
+            #  Numbers
+            (r'\d+[eE][+-]?\d+', Number.Float),
+            (r'\d+\.\d+([eE][+-]?\d+)?', Number.Float),
+            (r'0[xX][\da-fA-F]+', Number.Hex),
+            (r'\d+', Number.Integer),
+            # Strings
+            (r"'", String.Char, 'character'),
+            (r'"', String, 'string'),
+            (r'[^\s\(\)\{\}]+', Text),
+            (r'\s+?', Text),  # Whitespace
+        ],
+        'module': [
+            (r'\s+', Text),
+            (r'([A-Z][a-zA-Z0-9_.]*)(\s+)(\()',
+             bygroups(Name.Namespace, Text, Punctuation), 'funclist'),
+            (r'[A-Z][a-zA-Z0-9_.]*', Name.Namespace, '#pop'),
+        ],
+        'funclist': [
+            (r'\s+', Text),
+            (r'[A-Z][a-zA-Z0-9_]*', Keyword.Type),
+            (r'(_[\w\']+|[a-z][\w\']*)', Name.Function),
+            (r'--.*$', Comment.Single),
+            (r'{-', Comment.Multiline, 'comment'),
+            (r',', Punctuation),
+            (r'[:!#$%&*+.\\/<=>?@^|~-]+', Operator),
+            # (HACK, but it makes sense to push two instances, believe me)
+            (r'\(', Punctuation, ('funclist', 'funclist')),
+            (r'\)', Punctuation, '#pop:2'),
+        ],
+        # NOTE: the next four states are shared in the AgdaLexer; make sure
+        # any change is compatible with Agda as well or copy over and change
+        'comment': [
+            # Multiline Comments
+            (r'[^-{}]+', Comment.Multiline),
+            (r'{-', Comment.Multiline, '#push'),
+            (r'-}', Comment.Multiline, '#pop'),
+            (r'[-{}]', Comment.Multiline),
+        ],
+        'character': [
+            # Allows multi-chars, incorrectly.
+            (r"[^\\']", String.Char),
+            (r"\\", String.Escape, 'escape'),
+            ("'", String.Char, '#pop'),
+        ],
+        'string': [
+            (r'[^\\"]+', String),
+            (r"\\", String.Escape, 'escape'),
+            ('"', String, '#pop'),
+        ],
+        'escape': [
+            (r'[abfnrtv"\'&\\]', String.Escape, '#pop'),
+            (r'\^[][A-Z@\^_]', String.Escape, '#pop'),
+            ('|'.join(ascii), String.Escape, '#pop'),
+            (r'o[0-7]+', String.Escape, '#pop'),
+            (r'x[\da-fA-F]+', String.Escape, '#pop'),
+            (r'\d+', String.Escape, '#pop'),
+            (r'\s+\\', String.Escape, '#pop')
+        ],
+    }
+
+
 class AgdaLexer(RegexLexer):
     """
     For the `Agda <http://wiki.portal.chalmers.se/agda/pmwiki.php>`_
@@ -1173,6 +1282,29 @@ class LiterateHaskellLexer(LiterateLexer):
         LiterateLexer.__init__(self, hslexer, **options)
 
 
+class LiterateIdrisLexer(LiterateLexer):
+    """
+    For Literate Idris (Bird-style or LaTeX) source.
+
+    Additional options accepted:
+
+    `litstyle`
+        If given, must be ``"bird"`` or ``"latex"``.  If not given, the style
+        is autodetected: if the first non-whitespace character in the source
+        is a backslash or percent character, LaTeX is assumed, else Bird.
+
+    .. versionadded:: 2.0
+    """
+    name = 'Literate Idris'
+    aliases = ['lidr', 'literate-idris', 'lidris']
+    filenames = ['*.lidr']
+    mimetypes = ['text/x-literate-idris']
+
+    def __init__(self, **options):
+        hslexer = IdrisLexer(**options)
+        LiterateLexer.__init__(self, hslexer, **options)
+
+
 class LiterateAgdaLexer(LiterateLexer):
     """
     For Literate Agda source.
diff --git a/pygments/lexers/other.py b/pygments/lexers/other.py
index 9a338c0e..d9e7440a 100644
--- a/pygments/lexers/other.py
+++ b/pygments/lexers/other.py
@@ -1217,16 +1217,20 @@ class ModelicaLexer(RegexLexer):
         ],
         'statements': [
             (r'"', String, 'string'),
-            (r'\'', Name, 'quoted_ident'),
             (r'(\d+\.\d*|\.\d+|\d+|\d.)[eE][+-]?\d+[lL]?', Number.Float),
             (r'(\d+\.\d*|\.\d+)', Number.Float),
             (r'\d+[Ll]?', Number.Integer),
             (r'[~!%^&*+=|?:<>/-]', Operator),
-            (r'[()\[\]{},.;]', Punctuation),
             (r'(true|false|NULL|Real|Integer|Boolean)\b', Name.Builtin),
-            (r'([a-zA-Z_][\w\[\]]*|\'[a-zA-Z_\+\-\*\/\^][\w]*\')'
-             r'(\.([a-zA-Z_\][\w\[\]]*|\'[a-zA-Z_\+\-\*\/\^][\w]*\'))+', Name.Class),
+            (r'([a-zA-Z_][\w]*|[\'][^\']+[\'])'
+             r'([\[\d,:\]]*)'
+             r'(\.([a-zA-Z_][\w]*|[\'][^\']+[\']))+'
+             r'([\[\d,:\]]*)', Name.Class),
+            (r'([a-zA-Z_][\w]*|[\'][^\']+[\'])'
+             r'([\[\d,:\]]+)', Name.Class),
             (r'(\'[\w\+\-\*\/\^]+\'|\w+)', Name),
+            (r'[()\[\]{},.;]', Punctuation),
+            (r'\'', Name, 'quoted_ident'),
         ],
         'root': [
             include('whitespace'),
diff --git a/pygments/lexers/templates.py b/pygments/lexers/templates.py
index 7c7a4546..72f81d63 100644
--- a/pygments/lexers/templates.py
+++ b/pygments/lexers/templates.py
@@ -36,9 +36,10 @@ __all__ = ['HtmlPhpLexer', 'XmlPhpLexer', 'CssPhpLexer',
            'MakoCssLexer', 'JspLexer', 'CheetahLexer', 'CheetahHtmlLexer',
            'CheetahXmlLexer', 'CheetahJavascriptLexer', 'EvoqueLexer',
            'EvoqueHtmlLexer', 'EvoqueXmlLexer', 'ColdfusionLexer',
-           'ColdfusionHtmlLexer', 'VelocityLexer', 'VelocityHtmlLexer',
-           'VelocityXmlLexer', 'SspLexer', 'TeaTemplateLexer', 'LassoHtmlLexer',
-           'LassoXmlLexer', 'LassoCssLexer', 'LassoJavascriptLexer']
+           'ColdfusionHtmlLexer', 'ColdfusionCFCLexer', 'VelocityLexer', 
+           'VelocityHtmlLexer', 'VelocityXmlLexer', 'SspLexer', 
+           'TeaTemplateLexer', 'LassoHtmlLexer', 'LassoXmlLexer', 
+           'LassoCssLexer', 'LassoJavascriptLexer']
 
 
 class ErbLexer(Lexer):
@@ -1478,23 +1479,28 @@ class ColdfusionLexer(RegexLexer):
     aliases = ['cfs']
     filenames = []
     mimetypes = []
-    flags = re.IGNORECASE | re.MULTILINE
+    flags = re.IGNORECASE
 
     tokens = {
         'root': [
-            (r'//.*', Comment),
+            (r'//.*?\n', Comment.Single),
+            (r'/\*(?:.|\n)*?\*/', Comment.Multiline),
             (r'\+\+|--', Operator),
             (r'[-+*/^&=!]', Operator),
-            (r'<=|>=|<|>', Operator),
+            (r'<=|>=|<|>|==', Operator),
             (r'mod\b', Operator),
             (r'(eq|lt|gt|lte|gte|not|is|and|or)\b', Operator),
             (r'\|\||&&', Operator),
+            (r'\?', Operator),
             (r'"', String.Double, 'string'),
             # There is a special rule for allowing html in single quoted
             # strings, evidently.
             (r"'.*?'", String.Single),
             (r'\d+', Number),
-            (r'(if|else|len|var|case|default|break|switch)\b', Keyword),
+            (r'(if|else|len|var|case|default|break|switch|component|property|function|do|try|catch|in|continue|for|return|while)\b', Keyword),
+            (r'(required|any|array|binary|boolean|component|date|guid|numeric|query|string|struct|uuid|xml)\b', Keyword),
+            (r'(true|false|null)\b', Keyword.Constant),
+            (r'(application|session|client|cookie|super|this|variables|arguments)\b', Name.Constant),
             (r'([A-Za-z_$][A-Za-z0-9_.]*)(\s*)(\()',
              bygroups(Name.Function, Text, Punctuation)),
             (r'[A-Za-z_$][A-Za-z0-9_.]*', Name.Variable),
@@ -1558,7 +1564,7 @@ class ColdfusionHtmlLexer(DelegatingLexer):
     """
     name = 'Coldfusion HTML'
     aliases = ['cfm']
-    filenames = ['*.cfm', '*.cfml', '*.cfc']
+    filenames = ['*.cfm', '*.cfml']
     mimetypes = ['application/x-coldfusion']
 
     def __init__(self, **options):
@@ -1566,6 +1572,20 @@ class ColdfusionHtmlLexer(DelegatingLexer):
                                                   **options)
 
 
+class ColdfusionCFCLexer(DelegatingLexer):
+    """
+    Coldfusion markup/script components
+    """
+    name = 'Coldfusion CFC'
+    aliases = ['cfc']
+    filenames = ['*.cfc']
+    mimetypes = []
+
+    def __init__(self, **options):
+        super(ColdfusionCFCLexer, self).__init__(ColdfusionHtmlLexer, ColdfusionLexer,
+                                                  **options)
+
+
 class SspLexer(DelegatingLexer):
     """
     Lexer for Scalate Server Pages.
diff --git a/pygments/lexers/web.py b/pygments/lexers/web.py
index 9a714638..c975ad80 100644
--- a/pygments/lexers/web.py
+++ b/pygments/lexers/web.py
@@ -28,7 +28,7 @@ __all__ = ['HtmlLexer', 'XmlLexer', 'JavascriptLexer', 'JsonLexer', 'CssLexer',
            'ObjectiveJLexer', 'CoffeeScriptLexer', 'LiveScriptLexer',
            'DuelLexer', 'ScamlLexer', 'JadeLexer', 'XQueryLexer',
            'DtdLexer', 'DartLexer', 'LassoLexer', 'QmlLexer', 'TypeScriptLexer',
-           'KalLexer', 'CirruLexer']
+           'KalLexer', 'CirruLexer', 'MaskLexer']
 
 
 class JavascriptLexer(RegexLexer):
@@ -4203,6 +4203,7 @@ class CirruLexer(RegexLexer):
             (r'\(', Operator, '#push'),
             (r'"', String, ('#pop', 'string')),
             (r'\s+', Text.Whitespace),
+            (r'\,', Operator, '#pop'),
         ],
         'line': [
             (r'^\B', Text.Whitespace, 'function'),
@@ -4222,3 +4223,118 @@ class CirruLexer(RegexLexer):
             (r'^\s+$', Text.Whitespace),
         ]
     }
+
+
+class MaskLexer(RegexLexer):
+    """
+    For `Mask <http://github.com/atmajs/MaskJS>`__ markup.
+
+    .. versionadded:: 2.0
+    """
+    name = 'Mask'
+    aliases = ['mask']
+    filenames = ['*.mask']
+    mimetypes = ['text/x-mask']
+
+    flags = re.MULTILINE | re.IGNORECASE | re.DOTALL
+    tokens = {
+        'root': [
+            (r'\s+', Text),
+            (r'//.*?\n', Comment.Single),
+            (r'/\*.*?\*/', Comment.Multiline),
+            (r'[\{\};>]', Punctuation),
+            (r"'''", String, 'string-trpl-single'),
+            (r'"""', String, 'string-trpl-double'),
+            (r"'", String, 'string-single'),
+            (r'"', String, 'string-double'),
+            (r'([\w-]+)', Name.Tag, 'node'),
+            (r'([^\.#;{>\s]+)', Name.Class, 'node'),
+            (r'(#[\w_-]+)', Name.Function, 'node'),
+            (r'(\.[\w_-]+)', Name.Variable.Class, 'node')
+        ],
+        'string-base': [
+            (r'\\.', String.Escape),
+            (r'~\[', String.Interpol, 'interpolation'),
+            (r'.', String.Single),  
+        ],
+        'string-single':[
+            (r"'", String.Single, '#pop'),
+            include('string-base')
+        ],  
+        'string-double':[
+            (r'"', String.Single, '#pop'),
+            include('string-base')
+        ],
+        'string-trpl-single':[
+            (r"'''", String.Single, '#pop'),
+            include('string-base')
+        ],
+        'string-trpl-double':[
+            (r'"""', String.Single, '#pop'),
+            include('string-base')
+        ],
+        'interpolation': [
+            (r'\]', String.Interpol, '#pop'),
+            (r'\s*:', String.Interpol, 'expression'),
+            (r'\s*\w+:', Name.Other),
+            (r'[^\]]+', String.Interpol)
+        ],
+        'expression': [
+            (r'[^\]]+', using(JavascriptLexer), '#pop')
+        ],  
+        'node': [
+            (r'\s+', Text),
+            (r'\.', Name.Variable.Class, 'node-class'),
+            (r'\#', Name.Function, 'node-id'),
+            (r'style[ \t]*=', Name.Attribute, 'node-attr-style-value'),
+            (r'[\w_:-]+[ \t]*=', Name.Attribute, 'node-attr-value'),
+            (r'[\w_:-]+', Name.Attribute),
+            (r'[>{;]', Punctuation, '#pop')
+        ],  
+        'node-class': [
+            (r'[\w-]+', Name.Variable.Class),
+            (r'~\[', String.Interpol, 'interpolation'),
+            (r'', Text, '#pop')
+        ],
+        'node-id': [
+            (r'[\w-]+', Name.Function),
+            (r'~\[', String.Interpol, 'interpolation'),
+            (r'', Text, '#pop')
+        ],
+        'node-attr-value':[
+            (r'\s+', Text),
+            (r'[\w_]+', Name.Variable, '#pop'),
+            (r"'", String, 'string-single-pop2'),
+            (r'"', String, 'string-double-pop2'),
+            (r'', Text, '#pop')
+        ],
+        'node-attr-style-value':[
+            (r'\s+', Text),
+            (r"'", String.Single, 'css-single-end'),
+            (r'"', String.Single, 'css-double-end'),
+            include('node-attr-value')
+        ],
+        'css-base': [
+            (r'\s+', Text),
+            (r"[;]", Punctuation),
+            (r"[\w\-_]+\s*:", Name.Builtin)
+        ],
+        'css-single-end': [
+            include('css-base'),
+            (r"'", String.Single, '#pop:2'),
+            (r"[^;']+", Name.Entity)
+        ],
+        'css-double-end': [
+            include('css-base'),
+            (r'"', String.Single, '#pop:2'),
+            (r"[^;\"]+", Name.Entity)
+        ],  
+        'string-single-pop2':[
+            (r"'", String.Single, '#pop:2'),
+            include('string-base')
+        ],
+        'string-double-pop2':[
+            (r'"', String.Single, '#pop:2'),
+            include('string-base')
+        ]
+    }
diff --git a/tests/examplefiles/example.i6t b/tests/examplefiles/example.i6t
new file mode 100644
index 00000000..0f41b425
--- /dev/null
+++ b/tests/examplefiles/example.i6t
@@ -0,0 +1,32 @@
+B/examt: Example Template.
+
+@Purpose: To show the syntax of I6T, specifically the parts relating to the
+inclusion of I7 and at signs in the first column.
+
+@-------------------------------------------------------------------------------
+
+@p Lines.
+
+@c
+{-lines:type}
+! This is a comment.
+{-endlines}
+
+@-This line begins with @-, so it is ignored.
+
+@p Paragraph.
+This is a paragraph.
+@p Another paragraph.
+So
+
+is
+
+this.
+
+@Purpose: This purpose line is ignored.
+
+@c At signs and (+ +).
+[ Foo i;
+print (+score [an I7 value]+), "^";
+@add sp 1 -> i; ! Assembly works even in the first column.
+];
diff --git a/tests/examplefiles/example.i7x b/tests/examplefiles/example.i7x
new file mode 100644
index 00000000..ab94ac69
--- /dev/null
+++ b/tests/examplefiles/example.i7x
@@ -0,0 +1,45 @@
+example by David Corbett begins here.
+
+"Implements testable examples."
+
+An example is a kind of thing. An example can be tested. An example is seldom tested.
+
+example ends here.
+
+----
+[The] documentation [starts here.]
+----
+
+This extension adds examples, which may be tested.
+
+Chapter: Usage
+
+To add an example to the story, we write:
+
+	The foobar is an example.
+
+To interact with it in Inform 6, we write something like:
+
+	To say (E - example): (-
+		print (object) {E};
+	-).
+	[The IDE's documentation viewer does not display the closing -). I don't know how to fix that.]
+
+Section: Testing
+
+We can make an example be tested using:
+
+	now the foobar is tested;
+
+Example: * Exempli Gratia - A simple example.
+
+	*: "Exempli Gratia"
+
+	Include example by David Corbett.
+
+	The Kitchen is a room. The egg is an example, here.
+
+	Before dropping the egg:
+		now the egg is tested.
+	
+	Test me with "get egg / drop egg".
diff --git a/tests/examplefiles/example.inf b/tests/examplefiles/example.inf
new file mode 100644
index 00000000..bc163de9
--- /dev/null
+++ b/tests/examplefiles/example.inf
@@ -0,0 +1,370 @@
+!% $SMALL ! This is ICL, not a comment.
+!% -w
+
+!% A comprehensive test of Inform6Lexer.
+
+Switches d2SDq;
+
+Constant Story "Informal Testing";
+Constant Headline "^Not a game.^";!% This is a comment, not ICL.
+
+Release 1;
+Serial "140128";
+Version 5;
+
+Ifndef TARGET_ZCODE;
+Ifndef TARGET_GLULX;
+Ifndef WORDSIZE;
+Default WORDSIZE 2;
+Constant TARGET_ZCODE;
+Endif;
+Endif;
+Endif;
+
+Ifv3; Message "Compiling to version 3"; Endif;
+Ifv5; Message "Not compiling to version 3"; endif;
+ifdef TARGET_ZCODE;
+#IFTRUE (#version_number == 5);
+Message "Compiling to version 5";
+#ENDIF;
+endif ;
+
+Replace CreatureTest;
+
+Include "Parser";
+Include "VerbLib";
+
+# ! A hash is optional at the top level.
+Object kitchen "Kitchen"
+    with description "You are in a kitchen.",
+        arr 1 2 3 4,
+    has light;
+
+#[ Initialise;
+    location = kitchen;
+    print "v"; inversion; "^";
+];
+
+Ifdef VN_1633;
+Replace IsSeeThrough IsSeeThroughOrig;
+[ IsSeeThrough * o;
+    return o hasnt opaque || IsSeeThroughOrig(o);
+];
+Endif;
+
+Abbreviate "test";
+
+Array table buffer 260;
+
+Attribute reversed;
+Attribute opaque alias locked;
+
+Property long additive additive long alias;
+Property long long long wingspan alias alias;
+
+Class Flier with wingspan 5;
+Class Bird(10) has animate class Flier with wingspan 2;
+
+Constant Constant1;
+Constant Constant2 Constant1;
+Constant Constant3 = Constant2;
+Ifdef VN_1633; Undef Constant; Endif;
+
+Ifdef VN_1633;
+Dictionary 'word' 1 2;
+Ifnot;
+Dictionary dict_word "word";
+Endif;
+
+Fake_action NotReal;
+
+Global global1;
+Global global2 = 69105;
+
+Lowstring low_string "low string";
+
+Iftrue false;
+Message error "Uh-oh!^~false~ shouldn't be ~true~.";
+Endif;
+Iffalse true;
+Message fatalerror "Uh-oh!^~true~ shouldn't be ~false~.";
+Endif;
+
+Nearby person "person"
+    with name 'person',
+         description "This person is barely implemented.",
+         life [ * x y z;
+             Ask: print_ret (The) self, " says nothing.";
+             Answer: print (The) self, " didn't say anything.^"; rfalse;
+         ]
+    has has animate transparent;
+
+Object -> -> test_tube "test tube"
+    with name 'test' "tube" 'testtube',
+    has ~openable ~opaque container;
+
+Bird -> pigeon
+    with name 'pigeon',
+        description [;
+            "The pigeon has a wingspan of ", self.&wingspan-->0, " wing units.";
+        ];
+
+Object -> "thimble" with name 'thimble';
+
+Object -> pebble "pebble" with name 'pebble';
+
+Ifdef TARGET_ZCODE; Trace objects; Endif;
+
+Statusline score;
+
+Stub StubR 3;
+
+Ifdef TARGET_ZCODE;
+Zcharacter "abcdefghijklmnopqrstuvwxyz"
+           "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+           "123456789.,!?_#'0/@{005C}-:()";
+Zcharacter table '@!!' '@<<' '@'A';
+Zcharacter table + '@AE' '@{dc}' '@et' '@:y';
+Ifnot;
+Ifdef TARGET_GLULX;
+Message "Glulx doesn't use ~Zcharacter~.^Oh well."; ! '~' and '^' work here.
+Ifnot;
+Message warning "Uh-oh! ^~^"; ! They don't work in other Messages.
+Endif;
+Endif;
+
+Include "Grammar";
+
+Verb"acquire"'collect'='take';
+
+[ NounFilter; return noun ofclass Bird; ];
+
+[ ScopeFilter obj;
+    switch (scope_stage) {
+    1: rtrue;
+    2: objectloop (obj in compass) PlaceInScope(obj);
+    3: "Nothing is in scope.";
+    }
+];
+
+Verb meta "t" 'test'
+    * 'held' held -> TestHeld
+    * number -> TestNumber
+    * reversed -> TestAttribute
+    * 'creature' creature -> TestCreature
+    * 'multiheld' multiheld -> TestMultiheld
+    * 'm' multiexcept 'into'/"in" noun -> TestMultiexcept
+    * 'm' multiinside 'from' noun -> TestMultiinside
+    * multi -> TestMulti
+    * 'filter'/'f' noun=NounFilter -> TestNounFilter
+    * 'filter'/'f' scope=ScopeFilter -> TestScopeFilter
+    * 'special' special -> TestSpecial
+    * topic -> TestTopic;
+
+Verb 'reverse' 'swap' 'exchange'
+    * held 'for' noun -> reverse
+    * noun 'with' noun -> reverse reverse;
+
+Extend "t" last * noun -> TestNoun;
+
+Extend 't' first * -> Test;
+
+Extend 'wave' replace * -> NewWave;
+
+Extend only 'feel' 'touch' replace * noun -> Feel;
+
+[ TestSub a b o;
+    string 25 low_string;
+    print "Test what?> ";
+    table->0 = 260;
+    parse->0 = 61;
+    #Ifdef TARGET_ZCODE;
+    read buffer parse;
+    #Ifnot; ! TARGET_GLULX
+    KeyboardPrimitive(buffer, parse);
+    #Endif; ! TARGET_
+    switch (parse-->1) {
+    'save':
+        #Ifdef TARGET_ZCODE;
+        #Ifv3;
+        @save ?saved;
+        #Ifnot;
+        save saved;
+        #Endif;
+        #Endif;
+        print "Saving failed.^";
+    'restore':
+        #Ifdef TARGET_ZCODE;
+        restore saved;
+        #Endif;
+        print "Restoring failed.^";
+    'restart':
+        @restart;
+    'quit', 'q//':
+        quit;
+        return 2; rtrue; rfalse; return;
+    'print', 'p//':
+        print "Print:^",
+            " (string): ", (string) "xyzzy^",
+            " (number): ", (number) 123, "^",
+            " (char): ", (char) 'x', "^",
+            " (address): ", (address) 'plugh//p', "^",
+            " (The): ", (The) person, "^",
+            " (the): ", (the) person, "^",
+            " (A): ", (A) person, "^",
+            " (a): ", (a) person, "^",
+            " (an): ", (an) person, "^",
+            " (name): ", (name) person, "^",
+            " (object): ", (object) person, "^",
+            " (property): ", (property) alias, "^",
+            " (<routine>): ", (LanguageNumber) 123, "^",
+            " <expression>: ", a * 2 - 1, "^",
+            " (<expression>): ", (a + person), "^";
+        print "Escapes:^",
+            " by mnemonic: @!! @<< @'A @AE @et @:y^",
+            " by decimal value: @@64 @@126^",
+            " by Unicode value: @{DC}@{002b}^",
+            " by string variable: @25^";
+    'font', 'style': 
+        font off; print "font off^";
+        font on; print "font on^";
+        style reverse; print "style reverse^"; style roman;
+        style bold; print "style bold^";
+        style underline; print "style underline^";
+        style fixed; print "style fixed^";
+        style roman; print "style roman^";
+    'statements':
+        spaces 8;
+        objectloop (o) {
+            print "objectloop (o): ", (the) o, "^";
+        }
+        objectloop (o in compass) { ! 'in' is a keyword
+            print "objectloop (o in compass): ", (the) o, "^";
+        }
+        objectloop (o in compass && true) { ! 'in' is an operator
+            print "objectloop (o in compass && true): ", (the) o, "^";
+        }
+        objectloop (o from se_obj) {
+            print "objectloop (o from se_obj): ", (the) o, "^";
+        }
+        objectloop (o near person) {
+            print "objectloop (o near person): ", (the) o, "^";
+        }
+        #Ifdef TARGET_ZCODE;
+        #Trace assembly on;
+@ ! This is assembly.
+        add -4 ($$1+$3)*2 -> b;
+        @get_sibling test_tube -> b ?saved;
+        @inc [b];
+        @je sp (1+3*0) ? equal;
+        @je 1 ((sp)) ?~ different;
+        .! This is a label:
+            equal;
+        print "sp == 1^";
+        jump label;
+        .different;
+        print "sp @@126= 1^";
+        .label;
+        #Trace off; #Endif; ! TARGET_ZCODE
+        a = random(10);
+        switch (a) {
+        1, 9:
+            box "Testing oneself is best when done alone."
+                "                         -- Jimmy Carter";
+        2, 6, 3 to 5:
+            <Take pigeon>;
+            #Ifdef VN_1633;
+            <Jump, person>;
+            #Endif;
+            a = ##Drop;
+            < ! The angle brackets may be separated by whitespace.
+                < (a) pigeon > >;
+        default:
+            do {
+                give person general ~general;
+            } until (person provides life && ~~false);
+            if (a == 7) a = 4;
+            else a = 5;
+        }
+    'expressions':
+        a = 1+1-1*1/1%1&1|1&&1||1==(1~=(1>(1<(1>=(1<=1)))));
+        a++; ++a; a--; --a;
+        a = person.life;
+        a = kitchen.&arr;
+        a = kitchen.#arr;
+        a = Bird::wingspan;
+        a = kitchen has general;
+        a = kitchen hasnt general;
+        a = kitchen provides arr;
+        a = person in kitchen;
+        a = person notin kitchen;
+        a = person ofclass Bird;
+        a = a == 0 or 1;
+        a = StubR();
+        a = StubR(a);
+        a = StubR(, a);
+        a = "string";
+        a = 'word';
+        a = '''; ! character
+        a = $09afAF;
+        a = $$01;
+        a = ##Eat; a = #a$Eat;
+        a = #g$self;
+        a = #n$!word;
+        a = #r$StubR;
+        a = #dict_par1;
+    default:
+        for (a = 2, b = a; (a < buffer->1 + 2) && (Bird::wingspan): ++a, b--) {
+            print (char) buffer->a;
+        }
+        new_line;
+        for (::) break;
+    }
+    .saved;;
+];
+
+[ TestNumberSub;
+    print_ret parsed_number, " is ", (number) parsed_number, ".";
+];
+
+[ TestAttributeSub; print_ret (The) noun, " has been reversed."; ];
+
+[ CreatureTest obj; return obj has animate; ];
+
+[ TestCreatureSub; print_ret (The) noun, " is a creature."; ];
+
+[ TestMultiheldSub; print_ret "You are holding ", (the) noun, "."; ];
+
+[ TestMultiexceptSub; "You test ", (the) noun, " with ", (the) second, "."; ];
+
+[ TestMultiinsideSub; "You test ", (the) noun, " from ", (the) second, "."; ];
+
+[ TestMultiSub; print_ret (The) noun, " is a thing."; ];
+
+[ TestNounFilterSub; print_ret (The) noun, " is a bird."; ];
+
+[ TestScopeFilterSub; print_ret (The) noun, " is a direction."; ];
+
+[ TestSpecialSub; "Your lucky number is ", parsed_number, "."; ];
+
+[ TestTopicSub; "You discuss a topic."; ];
+
+[ TestNounSub; "That is ", (a) noun, "."; ];
+
+[ TestHeldSub; "You are holding ", (a) noun, "."; ];
+
+[ NewWaveSub; "That would be foolish."; ];
+
+[ FeelSub; print_ret (The) noun, " feels normal."; ];
+
+Global to;
+[ ReverseSub;
+    to = parent(noun);
+    move noun to parent(second);
+    move second to to;
+    give noun reversed;
+    give second reversed;
+    "You swap ", (the) noun, " and ", (the) second, ".";
+];
+
+End: The End directive ends the source code.
diff --git a/tests/examplefiles/example.ni b/tests/examplefiles/example.ni
new file mode 100644
index 00000000..32279e80
--- /dev/null
+++ b/tests/examplefiles/example.ni
@@ -0,0 +1,57 @@
+  | | |
+"Informal by Nature"
+[ * * * ]
+by
+[ * * * ]
+David Corbett
+
+[This is a [nested] comment.]
+
+Section 1 - Use option translation
+
+Use maximum tests of at least 100 translates as (-
+@c
+Constant MAX_TESTS = {N}; —). | Section 2
+
+A room has a number called size.
+
+The Kitchen is a room. "A nondescript kitchen.“ The Kitchen has size 2.
+
+When play begins:
+	say "Testing:[line break]";
+	test 0.
+
+To test (N — number): (—
+	if (Test({N}) == (+size of the Kitchen [this should succeed]+)) {-open—brace}
+		print ”Success.^”;
+	{-close-brace} else {
+		print “Failure.^";
+	}
+]; ! You shouldn't end a routine within a phrase definition, but it works.
+[ Unused;
+	#Include "\
+@p \
+"; ! At signs hold no power here.
+! Of course, the file "@p .h" must exist.
+-).
+
+Include (-!% This is not ICL.
+
+[ Test x;
+	if (x) {x++;}
+	{–! Single line comment.}
+@inc x;
+@p At signs.
+...
+@Purpose: ...
+...
+@-...
+@c ...
+@inc x;
+@c
+@c
+	return x;
+];
+@Purpose: ...
+@-------------------------------------------------------------------------------
+-).
diff --git a/tests/examplefiles/exampleScript.cfc b/tests/examplefiles/exampleScript.cfc
new file mode 100644
index 00000000..002acbcd
--- /dev/null
+++ b/tests/examplefiles/exampleScript.cfc
@@ -0,0 +1,241 @@
+<cfscript>
+/**
+********************************************************************************
+ContentBox - A Modular Content Platform
+Copyright 2012 by Luis Majano and Ortus Solutions, Corp
+www.gocontentbox.org | www.luismajano.com | www.ortussolutions.com
+********************************************************************************
+Apache License, Version 2.0
+
+Copyright Since [2012] [Luis Majano and Ortus Solutions,Corp]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+********************************************************************************
+* A generic content service for content objects
+*/
+component extends="coldbox.system.orm.hibernate.VirtualEntityService" singleton{
+
+	// DI
+	property name="settingService"			inject="id:settingService@cb";
+	property name="cacheBox"				inject="cachebox";
+	property name="log"						inject="logbox:logger:{this}";
+	property name="customFieldService" 	 	inject="customFieldService@cb";
+	property name="categoryService" 	 	inject="categoryService@cb";
+	property name="commentService" 	 		inject="commentService@cb";
+	property name="contentVersionService"	inject="contentVersionService@cb";
+	property name="authorService"			inject="authorService@cb";
+	property name="populator"				inject="wirebox:populator";
+	property name="systemUtil"				inject="SystemUtil@cb";
+	
+	/*
+	* Constructor
+	* @entityName.hint The content entity name to bind this service to.
+	*/
+	ContentService function init(entityName="cbContent"){
+		// init it
+		super.init(entityName=arguments.entityName, useQueryCaching=true);
+
+		// Test scope coloring in pygments
+		this.colorTestVar = "Just for testing pygments!";
+		cookie.colorTestVar = "";
+		client.colorTestVar = ""
+		session.colorTestVar = "";
+		application.colorTestVar = "";
+
+		return this;
+	}
+
+	/**
+	* Clear all content caches
+	* @async.hint Run it asynchronously or not, defaults to false
+	*/
+	function clearAllCaches(boolean async=false){
+		var settings = settingService.getAllSettings(asStruct=true);
+		// Get appropriate cache provider
+		var cache = cacheBox.getCache( settings.cb_content_cacheName );
+		cache.clearByKeySnippet(keySnippet="cb-content",async=arguments.async);
+		return this;
+	}
+
+	/**
+	* Clear all page wrapper caches
+	* @async.hint Run it asynchronously or not, defaults to false
+	*/
+	function clearAllPageWrapperCaches(boolean async=false){
+		var settings = settingService.getAllSettings(asStruct=true);
+		// Get appropriate cache provider
+		var cache = cacheBox.getCache( settings.cb_content_cacheName );
+		cache.clearByKeySnippet(keySnippet="cb-content-pagewrapper",async=arguments.async);
+		return this;
+	}
+
+	/**
+	* Clear all page wrapper caches
+	* @slug.hint The slug partial to clean on
+	* @async.hint Run it asynchronously or not, defaults to false
+	*/
+	function clearPageWrapperCaches(required any slug, boolean async=false){
+		var settings = settingService.getAllSettings(asStruct=true);
+		// Get appropriate cache provider
+		var cache = cacheBox.getCache( settings.cb_content_cacheName );
+		cache.clearByKeySnippet(keySnippet="cb-content-pagewrapper-#arguments.slug#",async=arguments.async);
+		return this;
+	}
+
+	/**
+	* Clear a page wrapper cache
+	* @slug.hint The slug to clean
+	* @async.hint Run it asynchronously or not, defaults to false
+	*/
+	function clearPageWrapper(required any slug, boolean async=false){
+		var settings = settingService.getAllSettings(asStruct=true);
+		// Get appropriate cache provider
+		var cache = cacheBox.getCache( settings.cb_content_cacheName );
+		cache.clear("cb-content-pagewrapper-#arguments.slug#/");
+		return this;
+	}
+
+	/**
+	* Searches published content with cool paramters, remember published content only
+	* @searchTerm.hint The search term to search
+	* @max.hint The maximum number of records to paginate
+	* @offset.hint The offset in the pagination
+	* @asQuery.hint Return as query or array of objects, defaults to array of objects
+	* @sortOrder.hint The sorting of the search results, defaults to publishedDate DESC
+	* @isPublished.hint Search for published, non-published or both content objects [true, false, 'all']
+	* @searchActiveContent.hint Search only content titles or both title and active content. Defaults to both.
+	*/
+	function searchContent(
+		any searchTerm="", 
+		numeric max=0, 
+		numeric offset=0, 
+		boolean asQuery=false, 
+		any sortOrder="publishedDate DESC", 
+		any isPublished=true, 
+		boolean searchActiveContent=true){
+
+		var results = {};
+		var c = newCriteria();
+
+		// only published content
+		if( isBoolean( arguments.isPublished ) ){
+			// Published bit
+			c.isEq( "isPublished", javaCast( "Boolean", arguments.isPublished ) );
+			// Published eq true evaluate other params
+			if( arguments.isPublished ){
+				c.isLt("publishedDate", now() )
+				.$or( c.restrictions.isNull("expireDate"), c.restrictions.isGT("expireDate", now() ) )
+				.isEq("passwordProtection","");
+			}
+		}
+
+		// Search Criteria
+		if( len( arguments.searchTerm ) ){
+			// like disjunctions
+			c.createAlias("activeContent","ac");
+			// Do we search title and active content or just title?
+			if( arguments.searchActiveContent ){
+				c.$or( c.restrictions.like("title","%#arguments.searchTerm#%"),
+				  	  c.restrictions.like("ac.content", "%#arguments.searchTerm#%") );
+			}
+			else{
+				c.like( "title", "%#arguments.searchTerm#%" ); 
+			}
+		}
+
+		// run criteria query and projections count
+		results.count = c.count( "contentID" );
+		results.content = c.resultTransformer( c.DISTINCT_ROOT_ENTITY )
+							.list(offset=arguments.offset, max=arguments.max, sortOrder=arguments.sortOrder, asQuery=arguments.asQuery);
+	
+		return results;
+	}
+
+/********************************************* PRIVATE *********************************************/
+	
+
+	/**
+	* Update the content hits
+	* @contentID.hint The content id to update
+	*/
+	private function syncUpdateHits(required contentID){
+		var q = new Query(sql="UPDATE cb_content SET hits = hits + 1 WHERE contentID = #arguments.contentID#").execute();
+		return this;
+	}
+	
+	
+	private function closureTest(){
+		methodCall(
+			param1,
+			function( arg1, required arg2 ){
+				var settings = settingService.getAllSettings(asStruct=true);
+				// Get appropriate cache provider
+				var cache = cacheBox.getCache( settings.cb_content_cacheName );
+				cache.clear("cb-content-pagewrapper-#arguments.slug#/");
+				return this;
+			},
+			param1
+		);
+	}
+	
+	private function StructliteralTest(){
+		return {
+			foo = bar,
+			brad = 'Wood',
+			func = function( arg1, required arg2 ){
+				var settings = settingService.getAllSettings(asStruct=true);
+				// Get appropriate cache provider
+				var cache = cacheBox.getCache( settings.cb_content_cacheName );
+				cache.clear("cb-content-pagewrapper-#arguments.slug#/");
+				return this;
+			},
+			array = [
+				1,
+				2,
+				3,
+				4,
+				5,
+				'test',
+				'testing',
+				'testerton',
+				{
+					foo = true,
+					brad = false,
+					wood = null
+				}
+			],
+			last = "final"
+		};
+	}
+	
+	private function arrayliteralTest(){
+		return [
+			1,
+			2,
+			3,
+			4,
+			5,
+			'test',
+			'testing',
+			'testerton',
+			{
+				foo = true,
+				brad = false,
+				wood = null
+			},
+			'testy-von-testavich'
+		];
+	}
+	
+}
+</cfscript>
+\ No newline at end of file
diff --git a/tests/examplefiles/exampleTag.cfc b/tests/examplefiles/exampleTag.cfc
new file mode 100644
index 00000000..753bb826
--- /dev/null
+++ b/tests/examplefiles/exampleTag.cfc
@@ -0,0 +1,18 @@
+<cfcomponent>
+	
+	<cffunction name="init" access="public" returntype="any">
+		<cfargument name="arg1" type="any" required="true">
+		<cfset this.myVariable = arguments.arg1>
+
+		<cfreturn this>
+	</cffunction>
+
+	<cffunction name="testFunc" access="private" returntype="void">
+		<cfargument name="arg1" type="any" required="false">
+		
+		<cfif structKeyExists(arguments, "arg1")>
+			<cfset writeoutput("Argument exists")>
+		</cfif>
+	</cffunction>
+	
+</cfcomponent>
+\ No newline at end of file
diff --git a/tests/examplefiles/scope.cirru b/tests/examplefiles/scope.cirru
index b17ff4ea..728bcabf 100644
--- a/tests/examplefiles/scope.cirru
+++ b/tests/examplefiles/scope.cirru
@@ -34,4 +34,10 @@ brackets ((((()))))
 print (add $ (int 1) (int 2))
 
 print $ unwrap $
-  map (a $ int 1) (b $ int 2)
-\ No newline at end of file
+  map (a $ int 1) (b $ int 2)
+
+print a
+  int 1
+  , b c
+  int 2
+  , d
+\ No newline at end of file
diff --git a/tests/examplefiles/test.idr b/tests/examplefiles/test.idr
new file mode 100644
index 00000000..f0e96d88
--- /dev/null
+++ b/tests/examplefiles/test.idr
@@ -0,0 +1,93 @@
+module Main
+
+data Ty = TyInt | TyBool | TyFun Ty Ty
+
+interpTy : Ty -> Type
+interpTy TyInt       = Int
+interpTy TyBool      = Bool
+interpTy (TyFun s t) = interpTy s -> interpTy t
+
+using (G : Vect n Ty)
+
+  data Env : Vect n Ty -> Type where
+      Nil  : Env Nil
+      (::) : interpTy a -> Env G -> Env (a :: G)
+
+  data HasType : (i : Fin n) -> Vect n Ty -> Ty -> Type where
+      stop : HasType fZ (t :: G) t
+      pop  : HasType k G t -> HasType (fS k) (u :: G) t
+
+  lookup : HasType i G t -> Env G -> interpTy t
+  lookup stop    (x :: xs) = x
+  lookup (pop k) (x :: xs) = lookup k xs
+
+  data Expr : Vect n Ty -> Ty -> Type where
+      Var : HasType i G t -> Expr G t
+      Val : (x : Int) -> Expr G TyInt
+      Lam : Expr (a :: G) t -> Expr G (TyFun a t)
+      App : Expr G (TyFun a t) -> Expr G a -> Expr G t
+      Op  : (interpTy a -> interpTy b -> interpTy c) -> Expr G a -> Expr G b ->
+            Expr G c
+      If  : Expr G TyBool -> Expr G a -> Expr G a -> Expr G a
+      Bind : Expr G a -> (interpTy a -> Expr G b) -> Expr G b
+
+  dsl expr
+      lambda      = Lam
+      variable    = Var
+      index_first = stop
+      index_next  = pop
+
+  (<$>) : |(f : Expr G (TyFun a t)) -> Expr G a -> Expr G t
+  (<$>) = \f, a => App f a
+
+  pure : Expr G a -> Expr G a
+  pure = id
+
+  syntax IF [x] THEN [t] ELSE [e] = If x t e
+
+  (==) : Expr G TyInt -> Expr G TyInt -> Expr G TyBool
+  (==) = Op (==)
+
+  (<) : Expr G TyInt -> Expr G TyInt -> Expr G TyBool
+  (<) = Op (<)
+
+  instance Num (Expr G TyInt) where
+    (+) x y = Op (+) x y
+    (-) x y = Op (-) x y
+    (*) x y = Op (*) x y
+
+    abs x = IF (x < 0) THEN (-x) ELSE x
+
+    fromInteger = Val . fromInteger
+
+  interp : Env G -> {static} Expr G t -> interpTy t
+  interp env (Var i)     = lookup i env
+  interp env (Val x)     = x
+  interp env (Lam sc)    = \x => interp (x :: env) sc
+  interp env (App f s)   = (interp env f) (interp env s)
+  interp env (Op op x y) = op (interp env x) (interp env y)
+  interp env (If x t e)  = if (interp env x) then (interp env t) else (interp env e)
+  interp env (Bind v f)  = interp env (f (interp env v))
+
+  eId : Expr G (TyFun TyInt TyInt)
+  eId = expr (\x => x)
+
+  eTEST : Expr G (TyFun TyInt (TyFun TyInt TyInt))
+  eTEST = expr (\x, y => y)
+
+  eAdd : Expr G (TyFun TyInt (TyFun TyInt TyInt))
+  eAdd = expr (\x, y => Op (+) x y)
+
+  eDouble : Expr G (TyFun TyInt TyInt)
+  eDouble = expr (\x => App (App eAdd x) (Var stop))
+
+  eFac : Expr G (TyFun TyInt TyInt)
+  eFac = expr (\x => IF x == 0 THEN 1 ELSE [| eFac (x - 1) |] * x)
+
+testFac : Int
+testFac = interp [] eFac 4
+
+main : IO ()
+main = print testFac
+
+
diff --git a/tests/examplefiles/test.mask b/tests/examplefiles/test.mask
new file mode 100644
index 00000000..39134d74
--- /dev/null
+++ b/tests/examplefiles/test.mask
@@ -0,0 +1,41 @@
+
+// comment
+h4.class-1#id.class-2.other checked='true' disabled name = x param > 'Enter  ..'
+input placeholder=Password type=password >
+    :dualbind x-signal='dom:create' value=user.passord;
+% each='flowers' > 
+    div style='
+        position: absolute;
+        display: inline-block;
+        background: url("image.png") center center no-repeat;
+    ';
+#skippedDiv.other {
+    img src='~[url]';
+    div style="text-align:center;" {
+        '~[: $obj.foo("username", name) + 2]'
+        "~[Localize: stringId]"
+    }
+
+    p > """
+
+        Hello "world"
+    """
+
+    p > '
+        Hello "world"
+    '
+
+    p > "Hello 'world'"
+
+    :customComponent x-value='tt';
+    /* footer > '(c) 2014' */
+}
+
+.skippedDiv >
+    span >
+        #skipped >
+            table >
+                td >
+                    tr > ';)'
+
+br;
+\ No newline at end of file
diff --git a/tests/test_basic_api.py b/tests/test_basic_api.py
index 78227d2f..e89b5c31 100644
--- a/tests/test_basic_api.py
+++ b/tests/test_basic_api.py
@@ -100,7 +100,8 @@ def test_lexer_options():
             'SqliteConsoleLexer', 'MatlabSessionLexer', 'ErlangShellLexer',
             'BashSessionLexer', 'LiterateHaskellLexer', 'LiterateAgdaLexer',
             'PostgresConsoleLexer', 'ElixirConsoleLexer', 'JuliaConsoleLexer',
-            'RobotFrameworkLexer', 'DylanConsoleLexer', 'ShellSessionLexer'):
+            'RobotFrameworkLexer', 'DylanConsoleLexer', 'ShellSessionLexer',
+            'LiterateIdrisLexer'):
             inst = cls(ensurenl=False)
             ensure(inst.get_tokens('a\nb'), 'a\nb')
             inst = cls(ensurenl=False, stripall=True)