heuristics.yml

# A collection of simple regexp-based rules that can be applied to content
# to disambiguate languages with the same file extension.
#
# There two top-level keys: disambiguations and named_patterns.
#
# disambiguations     - a list of disambiguation rules, one for each
#                       extension or group of extensions.
# extensions          - an array of file extensions that this block applies to.
# rules               - list of rules that are applied in order to the content
#                       of a file with matching extension. Rules are evaluated
#                       until one of them matches. If none matches, no language
#                       is returned.
# language            - Language to be returned if the rule matches.
# pattern             - Ruby-compatible regular expression that makes the rule
#                       match. If no pattern is specified, the rule always match.
#                       Pattern can be a string with a single regular expression
#                       or an array of strings that will be merged in a single
#                       regular expression (with union).
# and                 - An and block merges multiple rules and checks that all of
#                       of them must match.
# negative_pattern    - Same as pattern, but checks for absence of matches.
# named_pattern       - A pattern can be reused by specifying it in the
#                       named_patterns section and referencing it here by its
#                       key.
# named_patterns      - Key-value map of reusable named patterns.
#
# Please keep this list alphabetized.
#
---
disambiguations:
- extensions: ['.1', '.1in', '.1m', '.1x', '.2', '.3', '.3in', '.3m', '.3p', '.3pm', '.3qt', '.3x', '.4', '.5', '.6', '.7', '.8', '.9', '.man', '.mdoc']
  rules:
  # Document which uses mdoc(7) macros
  - language: Roff Manpage
    and:
    - pattern: '^[.''][ \t]*Dd +(?:[^"\s]+|"[^"]+")'
    - pattern: '^[.''][ \t]*Dt +(?:[^"\s]+|"[^"]+") +"?(?:[1-9]|@[^\s@]+@)'
    - pattern: '^[.''][ \t]*Sh +(?:[^"\s]|"[^"]+")'

  # Document which uses man(7) macros
  - language: Roff Manpage
    and:
    - pattern: '^[.''][ \t]*TH +(?:[^"\s]+|"[^"]+") +"?(?:[1-9]|@[^\s@]+@)'
    - pattern: '^[.''][ \t]*SH +(?:[^"\s]+|"[^"\s]+)'

  # Open-ended fallback to unrendered Roff source
  - language: Roff
- extensions: ['.as']
  rules:
  - language: ActionScript
    pattern: '^\s*(package\s+[a-z0-9_\.]+|import\s+[a-zA-Z0-9_\.]+;|class\s+[A-Za-z0-9_]+\s+extends\s+[A-Za-z0-9_]+)'
  - language: AngelScript
- extensions: ['.asc']
  rules:
  - language: Public Key
    pattern: '^(----[- ]BEGIN|ssh-(rsa|dss)) '
  - language: AsciiDoc
    pattern: '^[=-]+(\s|\n)|{{[A-Za-z]'
  - language: AGS Script
    pattern: '^(\/\/.+|((import|export)\s+)?(function|int|float|char)\s+((room|repeatedly|on|game)_)?([A-Za-z]+[A-Za-z_0-9]+)\s*[;\(])'
- extensions: ['.asm']
  rules:
  - language: Motorola 68K Assembly
    named_pattern: m68k
- extensions: ['.asy']
  rules:
  - language: LTspice Symbol
    pattern: '^SymbolType[ \t]'
  - language: Asymptote
- extensions: ['.bb']
  rules:
  - language: BlitzBasic
    pattern: '(<^\s*; |End Function)'
  - language: BitBake
    pattern: '^\s*(# |include|require)\b'
- extensions: ['.builds']
  rules:
  - language: XML
    pattern: '^(\s*)(?i:<Project|<Import|<Property|<?xml|xmlns)'
  - language: Text
- extensions: ['.ch']
  rules:
  - language: xBase
    pattern: '^\s*#\s*(?i:if|ifdef|ifndef|define|command|xcommand|translate|xtranslate|include|pragma|undef)\b'
- extensions: ['.cl']
  rules:
  - language: Common Lisp
    pattern: '^\s*\((?i:defun|in-package|defpackage) '
  - language: Cool
    pattern: '^class'
  - language: OpenCL
    pattern: '\/\* |\/\/ |^\}'
- extensions: ['.cls']
  rules:
  - language: TeX
    pattern: '\\\w+{'
  - language: ObjectScript
    pattern: '^Class\s'
- extensions: ['.cs']
  rules:
  - language: Smalltalk
    pattern: '![\w\s]+methodsFor: '
  - language: 'C#'
    pattern: '^(\s*namespace\s*[\w\.]+\s*{|\s*\/\/)'
- extensions: ['.d']
  rules:
  - language: D
    # see http://dlang.org/spec/grammar
    # ModuleDeclaration | ImportDeclaration | FuncDeclaration | unittest
    pattern: '^module\s+[\w.]*\s*;|import\s+[\w\s,.:]*;|\w+\s+\w+\s*\(.*\)(?:\(.*\))?\s*{[^}]*}|unittest\s*(?:\(.*\))?\s*{[^}]*}'
  - language: DTrace
    # see http://dtrace.org/guide/chp-prog.html, http://dtrace.org/guide/chp-profile.html, http://dtrace.org/guide/chp-opt.html
    pattern: '^(\w+:\w*:\w*:\w*|BEGIN|END|provider\s+|(tick|profile)-\w+\s+{[^}]*}|#pragma\s+D\s+(option|attributes|depends_on)\s|#pragma\s+ident\s)'
  - language: Makefile
    # path/target : dependency \
    # target : \
    #  : dependency
    # path/file.ext1 : some/path/../file.ext2
    pattern: '([\/\\].*:\s+.*\s\\$|: \\$|^[ %]:|^[\w\s\/\\.]+\w+\.\w+\s*:\s+[\w\s\/\\.]+\w+\.\w+)'
- extensions: ['.dsp']
  rules:
  - language: Microsoft Developer Studio Project
    pattern: '# Microsoft Developer Studio Generated Build File'
  - language: Faust
    pattern: '\bprocess\s*[(=]|\b(library|import)\s*\(\s*"|\bdeclare\s+(name|version|author|copyright|license)\s+"'
- extensions: ['.ecl']
  rules:
  - language: ECLiPSe
    pattern: '^[^#]+:-'
  - language: ECL
    pattern: ':='
- extensions: ['.es']
  rules:
  - language: Erlang
    pattern: '^\s*(?:%%|main\s*\(.*?\)\s*->)'
  - language: JavaScript
    pattern: '(?m:\/\/|("|'')use strict\1|export\s+default\s|\/\*.*?\*\/)'
- extensions: ['.f']
  rules:
  - language: Forth
    pattern: '^: '
  - language: Filebench WML
    pattern: 'flowop'
  - language: Fortran
    named_pattern: fortran
- extensions: ['.for']
  rules:
  - language: Forth
    pattern: '^: '
  - language: Fortran
    named_pattern: fortran
- extensions: ['.fr']
  rules:
  - language: Forth
    pattern: '^(: |also |new-device|previous )'
  - language: Frege
    pattern: '^\s*(import|module|package|data|type) '
  - language: Text
- extensions: ['.fs']
  rules:
  - language: Forth
    pattern: '^(: |new-device)'
  - language: 'F#'
    pattern: '^\s*(#light|import|let|module|namespace|open|type)'
  - language: GLSL
    pattern: '^\s*(#version|precision|uniform|varying|vec[234])'
  - language: Filterscript
    pattern: '#include|#pragma\s+(rs|version)|__attribute__'
- extensions: ['.gd']
  rules:
  - language: GAP
    pattern: '\s*(Declare|BindGlobal|KeyDependentOperation)'
  - language: GDScript
    pattern: '\s*(extends|var|const|enum|func|class|signal|tool|yield|assert|onready)'
- extensions: ['.gml']
  rules:
  - language: XML
    pattern: '(?i:^\s*(\<\?xml|xmlns))'
  - language: Graph Modeling Language
    pattern: '(?i:^\s*(graph|node)\s+\[$)'
  - language: Gerber Image
    pattern: '\*\%$'
  - language: Game Maker Language
- extensions: ['.gs']
  rules:
  - language: GLSL
    pattern: '^#version\s+[0-9]+\b'
  - language: Gosu
    pattern: '^uses java\.'
- extensions: ['.h']
  rules:
  - language: Objective-C
    named_pattern: objectivec
  - language: C++
    named_pattern: cpp
- extensions: ['.hh']
  rules:
  - language: Hack
    pattern: '<\?hh'
- extensions: ['.i']
  rules:
  - language: Motorola 68K Assembly
    named_pattern: m68k
  - language: SWIG
    pattern: '^[ \t]*%[a-z_]+\b|^%[{}]$'
- extensions: ['.ice']
  rules:
  - language: JSON
    pattern: '\A\s*[{\[]'
  - language: Slice
- extensions: ['.inc']
  rules:
  - language: Motorola 68K Assembly
    named_pattern: m68k
  - language: PHP
    pattern: '^<\?(?:php)?'
  - language: SourcePawn
    pattern: '^public\s+(?:SharedPlugin(?:\s+|:)__pl_\w+\s*=(?:\s*{)?|(?:void\s+)?__pl_\w+_SetNTVOptional\(\)(?:\s*{)?)'
  - language: NASL
    pattern:
    - '^\s*include\s*\(\s*(?:"|'')[\\/\w\-\.:\s]+\.(?:nasl|inc)\s*(?:"|'')\s*\)\s*;'
    - '^\s*(?:global|local)_var\s+(?:\w+(?:\s*=\s*[\w\-"'']+)?\s*)(?:,\s*\w+(?:\s*=\s*[\w\-"'']+)?\s*)*+\s*;'
    - '^\s*namespace\s+\w+\s*{'
    - '^\s*object\s+\w+\s*(?:extends\s+\w+(?:::\w+)?)?\s*{'
    - '^\s*(?:public\s+|private\s+|\s*)function\s+\w+\s*\([\w\s,]*\)\s*{'
  - language: POV-Ray SDL
    pattern: '^\s*#(declare|local|macro|while)\s'
- extensions: ['.l']
  rules:
  - language: Common Lisp
    pattern: '\(def(un|macro)\s'
  - language: Lex
    pattern: '^(%[%{}]xs|<.*>)'
  - language: Roff
    pattern: '^\.[A-Za-z]{2}(\s|$)'
  - language: PicoLisp
    pattern: '^\((de|class|rel|code|data|must)\s'
- extensions: ['.ls']
  rules:
  - language: LoomScript
    pattern: '^\s*package\s*[\w\.\/\*\s]*\s*{'
  - language: LiveScript
- extensions: ['.lsp', '.lisp']
  rules:
  - language: Common Lisp
    pattern: '^\s*\((?i:defun|in-package|defpackage) '
  - language: NewLisp
    pattern: '^\s*\(define '
- extensions: ['.m']
  rules:
  - language: Objective-C
    named_pattern: objectivec
  - language: Mercury
    pattern: ':- module'
  - language: MUF
    pattern: '^: '
  - language: M
    pattern: '^\s*;'
  - language: Mathematica
    and:
      - pattern: '\(\*'
      - pattern: '\*\)$'
  - language: MATLAB
    pattern: '^\s*%'
  - language: Limbo
    pattern: '^\w+\s*:\s*module\s*{'
- extensions: ['.mask']
  rules:
  - language: Unity3d Asset
    pattern: 'tag:unity3d.com'
- extensions: ['.md']
  rules:
  - language: Markdown
    pattern:
    - '(^[-A-Za-z0-9=#!\*\[|>])|<\/'
    - '\A\z'
  - language: GCC Machine Description
    pattern: '^(;;|\(define_)'
  - language: Markdown
- extensions: ['.ml']
  rules:
  - language: OCaml
    pattern: '(^\s*module)|let rec |match\s+(\S+\s)+with'
  - language: Standard ML
    pattern: '=> |case\s+(\S+\s)+of'
- extensions: ['.mod']
  rules:
  - language: XML
    pattern: '<!ENTITY '
  - language: Modula-2
    pattern: '^\s*(?i:MODULE|END) [\w\.]+;'
  - language: [Linux Kernel Module, AMPL]
- extensions: ['.ms']
  rules:
  - language: Roff
    pattern: '^[.''][A-Za-z]{2}(\s|$)'
  - language: Unix Assembly
    and:
      - negative_pattern: '/\*'
      - pattern: '^\s*\.(?:include\s|globa?l\s|[A-Za-z][_A-Za-z0-9]*:)'
  - language: MAXScript
- extensions: ['.n']
  rules:
  - language: Roff
    pattern: '^[.'']'
  - language: Nemerle
    pattern: '^(module|namespace|using)\s'
- extensions: ['.ncl']
  rules:
  - language: XML
    pattern: '^\s*<\?xml\s+version'
  - language: Text
    pattern: 'THE_TITLE'
- extensions: ['.nl']
  rules:
  - language: NL
    pattern: '^(b|g)[0-9]+ '
  - language: NewLisp
- extensions: ['.odin']
  rules:
  - language: Object Data Instance Notation
    pattern: '(?:^|<)\s*[A-Za-z0-9_]+\s*=\s*<'
  - language: Odin
    pattern: 'package\s+\w+|\b(?:im|ex)port\s*"[\w:./]+"|\w+\s*::\s*(?:proc|struct)\s*\(|^\s*//\s'
- extensions: ['.p']
  rules:
  - language: Gnuplot
    pattern:
    - '^s?plot\b'
    - '^set\s+(term|terminal|out|output|[xy]tics|[xy]label|[xy]range|style)\b'
  - language: OpenEdge ABL
- extensions: ['.php']
  rules:
  - language: Hack
    pattern: '<\?hh'
  - language: PHP
    pattern: '<\?[^h]'
- extensions: ['.pl']
  rules:
  - language: Prolog
    pattern: '^[^#]*:-'
  - language: Perl
    named_pattern: perl5
  - language: Raku
    named_pattern: perl6
- extensions: ['.plist']
  rules:
  - language: XML Property List
    pattern: '<!DOCTYPE\s+plist'
  - language: OpenStep Property List
- extensions: ['.pm']
  rules:
  - language: Perl
    named_pattern: perl5
  - language: Raku
    named_pattern: perl6
  - language: X PixMap
    pattern: '^\s*\/\* XPM \*\/'
- extensions: ['.pod']
  rules:
  - language: Pod 6
    pattern: '^[\s&&[^\n]]*=(comment|begin pod|begin para|item\d+)'
  - language: Pod
- extensions: ['.pp']
  rules:
  - language: Pascal
    pattern: '^\s*end[.;]'
  - language: Puppet
    pattern: '^\s+\w+\s+=>\s'
- extensions: ['.pro']
  rules:
  - language: Proguard
    pattern: '^-(include\b.*\.pro$|keep\b|keepclassmembers\b|keepattributes\b)'
  - language: Prolog
    pattern: '^[^\[#]+:-'
  - language: INI
    pattern: 'last_client='
  - language: QMake
    and:
    - pattern: HEADERS
    - pattern: SOURCES
  - language: IDL
    pattern: '^\s*function[ \w,]+$'
- extensions: ['.properties']
  rules:
  - language: INI
    and:
    - named_pattern: key_equals_value
    - pattern: '^[;\[]'
  - language: Java Properties
    and:
    - named_pattern: key_equals_value
    - pattern: '^[#!]'
  - language: INI
    named_pattern: key_equals_value
  - language: Java properties
    pattern: '^[^#!][^:]*:'
- extensions: ['.props']
  rules:
  - language: XML
    pattern: '^(\s*)(?i:<Project|<Import|<Property|<\?xml|xmlns)'
  - language: INI
    pattern: '(?i:\w+\s*=\s*)'
- extensions: ['.q']
  rules:
  - language: q
    pattern: '((?i:[A-Z.][\w.]*:{)|(^|\n)\\(cd?|d|l|p|ts?) )'
  - language: HiveQL
    pattern: '(?i:SELECT\s+[\w*,]+\s+FROM|(CREATE|ALTER|DROP)\s(DATABASE|SCHEMA|TABLE))'
- extensions: ['.r']
  rules:
  - language: Rebol
    pattern: '(?i:\bRebol\b)'
  - language: R
    pattern: '<-|^\s*#'
- extensions: ['.rno']
  rules:
  - language: RUNOFF
    pattern: '(?i:^\.!|^\f|\f$|^\.end lit(?:eral)?\b|^\.[a-zA-Z].*?;\.[a-zA-Z](?:[; \t])|\^\*[^\s*][^*]*\\\*(?=$|\s)|^\.c;[ \t]*\w+)'
  - language: Roff
    pattern: '^\.\\" '
- extensions: ['.rpy']
  rules:
  - language: Python
    pattern: '(?m:^(import|from|class|def)\s)'
  - language: "Ren'Py"
- extensions: ['.rs']
  rules:
  - language: Rust
    pattern: '^(use |fn |mod |pub |macro_rules|impl|#!?\[)'
  - language: RenderScript
    pattern: '#include|#pragma\s+(rs|version)|__attribute__'
- extensions: ['.s']
  rules:
  - language: Motorola 68K Assembly
    named_pattern: m68k
- extensions: ['.sc']
  rules:
  - language: SuperCollider
    pattern: '(?i:\^(this|super)\.|^\s*~\w+\s*=\.)'
  - language: Scala
    pattern: '(^\s*import (scala|java)\.|^\s*class\b)'
- extensions: ['.sql']
  rules:
   # Postgres
  - language: PLpgSQL
    pattern: '(?i:^\\i\b|AS \$\$|LANGUAGE ''?plpgsql''?|SECURITY (DEFINER|INVOKER)|BEGIN( WORK )?;)'
  # IBM db2
  - language: SQLPL
    pattern: "(?i:(alter module)|(language sql)|(begin( NOT)+ atomic)|signal SQLSTATE '[0-9]+')"
  # Oracle
  - language: PLSQL
    pattern: '(?i:\$\$PLSQL_|XMLTYPE|sysdate|systimestamp|\.nextval|connect by|AUTHID (DEFINER|CURRENT_USER)|constructor\W+function)'
  # T-SQL
  - language: TSQL
    and:
    - negative_pattern: '(?i:IDENTIFIED|NUMBER|VARCHAR2|REPEAT|UNTIL|IMMEDIATE)'
    - pattern: '(?i:(GO)|(@@)|(CREATE PROCEDURE)|BEGIN( TRY| CATCH)|OUTPUT( INSERTED)|IF|ELSE|IIF|CHOOSE|CURSOR|FETCH|DEALLOCATE|DECLARE)'
  # Generic SQL
  - language: SQL
    negative_pattern: '(?i:begin|boolean|package|exception)'
- extensions: ['.srt']
  rules:
  - language: SubRip Text
    pattern: '^(\d{2}:\d{2}:\d{2},\d{3})\s*(-->)\s*(\d{2}:\d{2}:\d{2},\d{3})$'
- extensions: ['.t']
  rules:
  - language: Perl
    named_pattern: perl5
  - language: Raku
    named_pattern: perl6
  - language: Turing
    pattern: '^\s*%[ \t]+|^\s*var\s+\w+(\s*:\s*\w+)?\s*:=\s*\w+'
- extensions: ['.toc']
  rules:
  - language: World of Warcraft Addon Data
    pattern: '^## |@no-lib-strip@'
  - language: TeX
    pattern: '^\\(contentsline|defcounter|beamer|boolfalse)'
- extensions: ['.ts']
  rules:
  - language: XML
    pattern: '<TS\b'
  - language: TypeScript
- extensions: ['.tst']
  rules:
  - language: GAP
    pattern: 'gap> '
  # Heads up - we don't usually write heuristics like this (with no regex match)
  - language: Scilab
- extensions: ['.tsx']
  rules:
  - language: TSX
    pattern: '^\s*(import.+(from\s+|require\()[''"]react|\/\/\/\s*<reference\s)'
  - language: XML
    pattern: '(?i:^\s*<\?xml\s+version)'
- extensions: ['.v']
  rules:
  - language: Coq
    pattern: '\(\*.*?\*\)|(?:^|\s)(?:Proof|Qed)\.(?:$|\s)|(?:^|\s)Require[ \t]+Import\s'
  - language: Verilog
    pattern: '^[ \t]*module\s+[^\s()]+\s+\#?\(|^[ \t]*`(?:ifdef|timescale)\s|^[ \t]*always[ \t]+@'
  - language: V
    pattern: '\$(?:if|else)[ \t]|^[ \t]*fn\s+[^\s()]+\(.*?\).*?\{|^[ \t]*for\s*\{'
- extensions: ['.vba']
  rules:
  - language: Vim script
    pattern: '^UseVimball'
  - language: VBA
- extensions: ['.w']
  rules:
  - language: OpenEdge ABL
    pattern: '&ANALYZE-SUSPEND _UIB-CODE-BLOCK _CUSTOM _DEFINITIONS'
  - language: CWeb
    pattern: '^@(<|\w+\.)'
- extensions: ['.x']
  rules:
  - language: DirectX 3D File
    pattern:  '^xof 030(2|3)(?:txt|bin|tzip|bzip)\b'
  - language: RPC
    pattern: '\b(program|version)\s+\w+\s*{|\bunion\s+\w+\s+switch\s*\('
  - language: Logos
    pattern: '^%(end|ctor|hook|group)\b'
  - language: Linker Script
    pattern: 'OUTPUT_ARCH\(|OUTPUT_FORMAT\(|SECTIONS'
- extensions: ['.yy']
  rules:
  - language: JSON
    pattern: '\"modelName\"\:\s*\"GM'
  - language: Yacc
named_patterns:
  cpp:
  - '^\s*#\s*include <(cstdint|string|vector|map|list|array|bitset|queue|stack|forward_list|unordered_map|unordered_set|(i|o|io)stream)>'
  - '^\s*template\s*<'
  - '^[ \t]*(try|constexpr)'
  - '^[ \t]*catch\s*\('
  - '^[ \t]*(class|(using[ \t]+)?namespace)\s+\w+'
  - '^[ \t]*(private|public|protected):$'
  - 'std::\w+'
  fortran: '^(?i:[c*][^abd-z]|      (subroutine|program|end|data)\s|\s*!)'
  key_equals_value: '^[^#!;][^=]*='
  m68k:
  - '(?im)\bmoveq(?:\.l)?\s+#(?:\$-?[0-9a-f]{1,3}|%[0-1]{1,8}|-?[0-9]{1,3}),\s*d[0-7]\b'
  - '(?im)^\s*move(?:\.[bwl])?\s+(?:sr|usp),\s*[^\s]+'
  - '(?im)^\s*move\.[bwl]\s+.*\b[ad]\d'
  - '(?im)^\s*movem\.[bwl]\b'
  - '(?im)^\s*move[mp](?:\.[wl])?\b'
  - '(?im)^\s*btst\b'
  - '(?im)^\s*dbra\b'
  objectivec: '^\s*(@(interface|class|protocol|property|end|synchronised|selector|implementation)\b|#import\s+.+\.h[">])'
  perl5: '\buse\s+(?:strict\b|v?5\.)'
  perl6: '^\s*(?:use\s+v6\b|\bmodule\b|\b(?:my\s+)?class\b)'