/console/app/pygments/lexers/compiled.py

https://bitbucket.org/alex_muscar/myspace-competition-radar · Python · 1251 lines · 1057 code · 69 blank · 125 comment · 89 complexity · c35a71fe239c7fc3bcf58b1e9b5976ea MD5 · raw file 

    

  1. # -*- coding: utf-8 -*-
    2. 

  2. """
    3. 

  3.     pygments.lexers.compiled
    4. 

  4.     ~~~~~~~~~~~~~~~~~~~~~~~~
    5. 

  5. 

  6.     Lexers for compiled languages.
    7. 

  7. 

  8.     :copyright: 2006-2008 by Georg Brandl, Armin Ronacher, Christoph Hack,
    9. 

  9.                 Whitney Young, Kirk McDonald, Stou Sandalski, Krzysiek Goj.
    10. 

  10.     :license: BSD, see LICENSE for more details.
    11. 

  11. """
    12. 

    13. 

  13. import re
    14. 

  14. try:
    15. 

  15.     set
    16. 

  16. except NameError:
    17. 

  17.     from sets import Set as set
    18. 

  18. 

  19. from pygments.scanner import Scanner
    20. 

  20. from pygments.lexer import Lexer, RegexLexer, include, bygroups, using, \
    21. 

  21.                            this
    22. 

  22. from pygments.util import get_bool_opt, get_list_opt
    23. 

  23. from pygments.token import \
    24. 

  24.      Text, Comment, Operator, Keyword, Name, String, Number, Punctuation, \
    25. 

  25.      Error
    26. 

  26. 

  27. # backwards compatibility
    28. 

  28. from pygments.lexers.functional import OcamlLexer
    29. 

  29. 

  30. __all__ = ['CLexer', 'CppLexer', 'DLexer', 'DelphiLexer', 'JavaLexer', 'ScalaLexer',
    31. 

  31.            'DylanLexer', 'OcamlLexer', 'ObjectiveCLexer', 'FortranLexer']
    32. 

  32. 

  33. 

  34. class CLexer(RegexLexer):
    35. 

  35.     """
    36. 

  36.     For C source code with preprocessor directives.
    37. 

  37.     """
    38. 

  38.     name = 'C'
    39. 

  39.     aliases = ['c']
    40. 

  40.     filenames = ['*.c', '*.h']
    41. 

  41.     mimetypes = ['text/x-chdr', 'text/x-csrc']
    42. 

  42. 

  43.     #: optional Comment or Whitespace
    44. 

  44.     _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
    45. 

  45. 

  46.     tokens = {
    47. 

  47.         'whitespace': [
    48. 

  48.             (r'^\s*#if\s+0', Comment.Preproc, 'if0'),
    49. 

  49.             (r'^\s*#', Comment.Preproc, 'macro'),
    50. 

  50.             (r'\n', Text),
    51. 

  51.             (r'\s+', Text),
    52. 

  52.             (r'\\\n', Text), # line continuation
    53. 

  53.             (r'//(\n|(.|\n)*?[^\\]\n)', Comment),
    54. 

  54.             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment),
    55. 

  55.         ],
    56. 

  56.         'statements': [
    57. 

  57.             (r'L?"', String, 'string'),
    58. 

  58.             (r"L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'", String.Char),
    59. 

  59.             (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
    60. 

  60.             (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
    61. 

  61.             (r'0x[0-9a-fA-F]+[Ll]?', Number.Hex),
    62. 

  62.             (r'0[0-7]+[Ll]?', Number.Oct),
    63. 

  63.             (r'\d+[Ll]?', Number.Integer),
    64. 

  64.             (r'[~!%^&*+=|?:<>/-]', Operator),
    65. 

  65.             (r'[()\[\],.]', Punctuation),
    66. 

  66.             (r'\b(case)(.+?)(:)', bygroups(Keyword, using(this), Text)),
    67. 

  67.             (r'(auto|break|case|const|continue|default|do|else|enum|extern|'
    68. 

  68.              r'for|goto|if|register|restricted|return|sizeof|static|struct|'
    69. 

  69.              r'switch|typedef|union|volatile|virtual|while)\b', Keyword),
    70. 

  70.             (r'(int|long|float|short|double|char|unsigned|signed|void)\b',
    71. 

  71.              Keyword.Type),
    72. 

  72.             (r'(_{0,2}inline|naked|restrict|thread|typename)\b', Keyword.Reserved),
    73. 

  73.             (r'__(asm|int8|based|except|int16|stdcall|cdecl|fastcall|int32|'
    74. 

  74.              r'declspec|finally|int64|try|leave)\b', Keyword.Reserved),
    75. 

  75.             (r'(true|false|NULL)\b', Name.Builtin),
    76. 

  76.             ('[a-zA-Z_][a-zA-Z0-9_]*:(?!:)', Name.Label),
    77. 

  77.             ('[a-zA-Z_][a-zA-Z0-9_]*', Name),
    78. 

  78.         ],
    79. 

  79.         'root': [
    80. 

  80.             include('whitespace'),
    81. 

  81.             # functions
    82. 

  82.             (r'((?:[a-zA-Z0-9_*\s])+?(?:\s|[*]))'    # return arguments
    83. 

  83.              r'([a-zA-Z_][a-zA-Z0-9_]*)'             # method name
    84. 

  84.              r'(\s*\([^;]*?\))'                      # signature
    85. 

  85.              r'(' + _ws + r')({)',
    86. 

  86.              bygroups(using(this), Name.Function, using(this), using(this),
    87. 

  87.                       Punctuation),
    88. 

  88.              'function'),
    89. 

  89.             # function declarations
    90. 

  90.             (r'((?:[a-zA-Z0-9_*\s])+?(?:\s|[*]))'    # return arguments
    91. 

  91.              r'([a-zA-Z_][a-zA-Z0-9_]*)'             # method name
    92. 

  92.              r'(\s*\([^;]*?\))'                      # signature
    93. 

  93.              r'(' + _ws + r')(;)',
    94. 

  94.              bygroups(using(this), Name.Function, using(this), using(this),
    95. 

  95.                       Punctuation)),
    96. 

  96.             ('', Text, 'statement'),
    97. 

  97.         ],
    98. 

  98.         'statement' : [
    99. 

  99.             include('whitespace'),
    100. 

  100.             include('statements'),
    101. 

  101.             ('[{}]', Punctuation),
    102. 

  102.             (';', Punctuation, '#pop'),
    103. 

  103.         ],
    104. 

  104.         'function': [
    105. 

  105.             include('whitespace'),
    106. 

  106.             include('statements'),
    107. 

  107.             (';', Punctuation),
    108. 

  108.             ('{', Punctuation, '#push'),
    109. 

  109.             ('}', Punctuation, '#pop'),
    110. 

  110.         ],
    111. 

  111.         'string': [
    112. 

  112.             (r'"', String, '#pop'),
    113. 

  113.             (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape),
    114. 

  114.             (r'[^\\"\n]+', String), # all other characters
    115. 

  115.             (r'\\\n', String), # line continuation
    116. 

  116.             (r'\\', String), # stray backslash
    117. 

  117.         ],
    118. 

  118.         'macro': [
    119. 

  119.             (r'[^/\n]+', Comment.Preproc),
    120. 

  120.             (r'/[*](.|\n)*?[*]/', Comment),
    121. 

  121.             (r'//.*?\n', Comment, '#pop'),
    122. 

  122.             (r'/', Comment.Preproc),
    123. 

  123.             (r'(?<=\\)\n', Comment.Preproc),
    124. 

  124.             (r'\n', Comment.Preproc, '#pop'),
    125. 

  125.         ],
    126. 

  126.         'if0': [
    127. 

  127.             (r'^\s*#if.*?(?<!\\)\n', Comment, '#push'),
    128. 

  128.             (r'^\s*#el(?:se|if).*\n', Comment.Preproc, '#pop'),
    129. 

  129.             (r'^\s*#endif.*?(?<!\\)\n', Comment, '#pop'),
    130. 

  130.             (r'.*?\n', Comment),
    131. 

  131.         ]
    132. 

  132.     }
    133. 

  133. 

  134.     stdlib_types = ['size_t', 'ssize_t', 'off_t', 'wchar_t', 'ptrdiff_t',
    135. 

  135.             'sig_atomic_t', 'fpos_t', 'clock_t', 'time_t', 'va_list',
    136. 

  136.             'jmp_buf', 'FILE', 'DIR', 'div_t', 'ldiv_t', 'mbstate_t',
    137. 

  137.             'wctrans_t', 'wint_t', 'wctype_t']
    138. 

  138.     c99_types = ['_Bool', '_Complex', 'int8_t', 'int16_t', 'int32_t', 'int64_t',
    139. 

  139.             'uint8_t', 'uint16_t', 'uint32_t', 'uint64_t', 'int_least8_t',
    140. 

  140.             'int_least16_t', 'int_least32_t', 'int_least64_t',
    141. 

  141.             'uint_least8_t', 'uint_least16_t', 'uint_least32_t',
    142. 

  142.             'uint_least64_t', 'int_fast8_t', 'int_fast16_t', 'int_fast32_t',
    143. 

  143.             'int_fast64_t', 'uint_fast8_t', 'uint_fast16_t', 'uint_fast32_t',
    144. 

  144.             'uint_fast64_t', 'intptr_t', 'uintptr_t', 'intmax_t', 'uintmax_t']
    145. 

  145. 

  146.     def __init__(self, **options):
    147. 

  147.         self.stdlibhighlighting = get_bool_opt(options,
    148. 

  148.                 'stdlibhighlighting', True)
    149. 

  149.         self.c99highlighting = get_bool_opt(options,
    150. 

  150.                 'c99highlighting', True)
    151. 

  151.         RegexLexer.__init__(self, **options)
    152. 

  152. 

  153.     def get_tokens_unprocessed(self, text):
    154. 

  154.         for index, token, value in \
    155. 

  155.             RegexLexer.get_tokens_unprocessed(self, text):
    156. 

  156.             if token is Name:
    157. 

  157.                 if self.stdlibhighlighting and value in self.stdlib_types:
    158. 

  158.                     token = Keyword.Type
    159. 

  159.                 elif self.c99highlighting and value in self.c99_types:
    160. 

  160.                     token = Keyword.Type
    161. 

  161.             yield index, token, value
    162. 

  162. 

  163. class CppLexer(RegexLexer):
    164. 

  164.     """
    165. 

  165.     For C++ source code with preprocessor directives.
    166. 

  166.     """
    167. 

  167.     name = 'C++'
    168. 

  168.     aliases = ['cpp', 'c++']
    169. 

  169.     filenames = ['*.cpp', '*.hpp', '*.c++', '*.h++', '*.cc', '*.hh', '*.cxx', '*.hxx']
    170. 

  170.     mimetypes = ['text/x-c++hdr', 'text/x-c++src']
    171. 

  171. 

  172.     tokens = {
    173. 

  173.         'root': [
    174. 

  174.             (r'^\s*#if\s+0', Comment.Preproc, 'if0'),
    175. 

  175.             (r'^\s*#', Comment.Preproc, 'macro'),
    176. 

  176.             (r'\n', Text),
    177. 

  177.             (r'\s+', Text),
    178. 

  178.             (r'\\\n', Text), # line continuation
    179. 

  179.             (r'/(\\\n)?/(\n|(.|\n)*?[^\\]\n)', Comment),
    180. 

  180.             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment),
    181. 

  181.             (r'[{}]', Punctuation),
    182. 

  182.             (r'L?"', String, 'string'),
    183. 

  183.             (r"L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'", String.Char),
    184. 

  184.             (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
    185. 

  185.             (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
    186. 

  186.             (r'0x[0-9a-fA-F]+[Ll]?', Number.Hex),
    187. 

  187.             (r'0[0-7]+[Ll]?', Number.Oct),
    188. 

  188.             (r'\d+[Ll]?', Number.Integer),
    189. 

  189.             (r'[~!%^&*+=|?:<>/-]', Operator),
    190. 

  190.             (r'[()\[\],.;]', Punctuation),
    191. 

  191.             (r'(asm|auto|break|case|catch|const|const_cast|continue|'
    192. 

  192.              r'default|delete|do|dynamic_cast|else|enum|explicit|export|'
    193. 

  193.              r'extern|for|friend|goto|if|mutable|namespace|new|operator|'
    194. 

  194.              r'private|protected|public|register|reinterpret_cast|return|'
    195. 

  195.              r'restrict|sizeof|static|static_cast|struct|switch|template|'
    196. 

  196.              r'this|throw|throws|try|typedef|typeid|typename|union|using|'
    197. 

  197.              r'volatile|virtual|while)\b', Keyword),
    198. 

  198.             (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
    199. 

  199.             (r'(bool|int|long|float|short|double|char|unsigned|signed|'
    200. 

  200.              r'void|wchar_t)\b', Keyword.Type),
    201. 

  201.             (r'(_{0,2}inline|naked|thread)\b', Keyword.Reserved),
    202. 

  202.             (r'__(asm|int8|based|except|int16|stdcall|cdecl|fastcall|int32|'
    203. 

  203.              r'declspec|finally|int64|try|leave|wchar_t|w64|virtual_inheritance|'
    204. 

  204.              r'uuidof|unaligned|super|single_inheritance|raise|noop|'
    205. 

  205.              r'multiple_inheritance|m128i|m128d|m128|m64|interface|'
    206. 

  206.              r'identifier|forceinline|event|assume)\b', Keyword.Reserved),
    207. 

  207.             (r'(true|false)\b', Keyword.Constant),
    208. 

  208.             (r'NULL\b', Name.Builtin),
    209. 

  209.             ('[a-zA-Z_][a-zA-Z0-9_]*:(?!:)', Name.Label),
    210. 

  210.             ('[a-zA-Z_][a-zA-Z0-9_]*', Name),
    211. 

  211.         ],
    212. 

  212.         'classname': [
    213. 

  213.             (r'[a-zA-Z_][a-zA-Z0-9_]*', Name.Class, '#pop'),
    214. 

  214.             # template specification
    215. 

  215.             (r'\s*(?=>)', Text, '#pop'),
    216. 

  216.         ],
    217. 

  217.         'string': [
    218. 

  218.             (r'"', String, '#pop'),
    219. 

  219.             (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape),
    220. 

  220.             (r'[^\\"\n]+', String), # all other characters
    221. 

  221.             (r'\\\n', String), # line continuation
    222. 

  222.             (r'\\', String), # stray backslash
    223. 

  223.         ],
    224. 

  224.         'macro': [
    225. 

  225.             (r'[^/\n]+', Comment.Preproc),
    226. 

  226.             (r'/[*](.|\n)*?[*]/', Comment),
    227. 

  227.             (r'//.*?\n', Comment, '#pop'),
    228. 

  228.             (r'/', Comment.Preproc),
    229. 

  229.             (r'(?<=\\)\n', Comment.Preproc),
    230. 

  230.             (r'\n', Comment.Preproc, '#pop'),
    231. 

  231.         ],
    232. 

  232.         'if0': [
    233. 

  233.             (r'^\s*#if.*?(?<!\\)\n', Comment, '#push'),
    234. 

  234.             (r'^\s*#endif.*?(?<!\\)\n', Comment, '#pop'),
    235. 

  235.             (r'.*?\n', Comment),
    236. 

  236.         ]
    237. 

  237.     }
    238. 

  238. 

  239. 

  240. class DLexer(RegexLexer):
    241. 

  241.     """
    242. 

  242.     For D source.
    243. 

  243.     """
    244. 

  244.     name = 'D'
    245. 

  245.     filenames = ['*.d', '*.di']
    246. 

  246.     aliases = ['d']
    247. 

  247.     mimetypes = ['text/x-dsrc']
    248. 

  248. 

  249.     tokens = {
    250. 

  250.         'root': [
    251. 

  251.             (r'\n', Text),
    252. 

  252.             (r'\s+', Text),
    253. 

  253.             #(r'\\\n', Text), # line continuations
    254. 

  254.             # Comments
    255. 

  255.             (r'//(.*?)\n', Comment),
    256. 

  256.             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment),
    257. 

  257.             (r'/\+', Comment, 'nested_comment'),
    258. 

  258.             # Keywords
    259. 

  259.             (r'(abstract|alias|align|asm|assert|auto|body|break|case|cast'
    260. 

  260.              r'|catch|class|const|continue|debug|default|delegate|delete'
    261. 

  261.              r'|deprecated|do|else|enum|export|extern|finally|final'
    262. 

  262.              r'|foreach_reverse|foreach|for|function|goto|if|import|inout'
    263. 

  263.              r'|interface|invariant|in|is|lazy|mixin|module|new|nothrow|out'
    264. 

  264.              r'|override|package|pragma|private|protected|public|pure|ref|return'
    265. 

  265.              r'|scope|static|struct|super|switch|synchronized|template|this'
    266. 

  266.              r'|throw|try|typedef|typeid|typeof|union|unittest|version|volatile'
    267. 

  267.              r'|while|with|__traits)\b', Keyword
    268. 

  268.             ),
    269. 

  269.             (r'(bool|byte|cdouble|cent|cfloat|char|creal|dchar|double|float'
    270. 

  270.              r'|idouble|ifloat|int|ireal|long|real|short|ubyte|ucent|uint|ulong'
    271. 

  271.              r'|ushort|void|wchar)\b', Keyword.Type
    272. 

  272.             ),
    273. 

  273.             (r'(false|true|null)\b', Keyword.Constant),
    274. 

  274.             (r'macro\b', Keyword.Reserved),
    275. 

  275.             (r'(string|wstring|dstring)\b', Name.Builtin),
    276. 

  276.             # FloatLiteral
    277. 

  277.             # -- HexFloat
    278. 

  278.             (r'0[xX]([0-9a-fA-F_]*\.[0-9a-fA-F_]+|[0-9a-fA-F_]+)'
    279. 

  279.              r'[pP][+\-]?[0-9_]+[fFL]?[i]?', Number.Float),
    280. 

  280.             # -- DecimalFloat
    281. 

  281.             (r'[0-9_]+(\.[0-9_]+[eE][+\-]?[0-9_]+|'
    282. 

  282.              r'\.[0-9_]*|[eE][+\-]?[0-9_]+)[fFL]?[i]?', Number.Float),
    283. 

  283.             (r'\.(0|[1-9][0-9_]*)([eE][+\-]?[0-9_]+)?[fFL]?[i]?', Number.Float),
    284. 

  284.             # IntegerLiteral
    285. 

  285.             # -- Binary
    286. 

  286.             (r'0[Bb][01_]+', Number),
    287. 

  287.             # -- Octal
    288. 

  288.             (r'0[0-7_]+', Number.Oct),
    289. 

  289.             # -- Hexadecimal
    290. 

  290.             (r'0[xX][0-9a-fA-F_]+', Number.Hex),
    291. 

  291.             # -- Decimal
    292. 

  292.             (r'(0|[1-9][0-9_]*)([LUu]|Lu|LU|uL|UL)?', Number.Integer),
    293. 

  293.             # CharacterLiteral
    294. 

  294.             (r"""'(\\['"?\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}"""
    295. 

  295.              r"""|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|\\&\w+;|.)'""",
    296. 

  296.              String.Char
    297. 

  297.             ),
    298. 

  298.             # StringLiteral
    299. 

  299.             # -- WysiwygString
    300. 

  300.             (r'r"[^"]*"[cwd]?', String),
    301. 

  301.             # -- AlternateWysiwygString
    302. 

  302.             (r'`[^`]*`[cwd]?', String),
    303. 

  303.             # -- DoubleQuotedString
    304. 

  304.             (r'"(\\\\|\\"|[^"])*"[cwd]?', String),
    305. 

  305.             # -- EscapeSequence
    306. 

  306.             (r"""\\(['"?\\abfnrtv]|x[0-9a-fA-F]{2}|[0-7]{1,3}"""
    307. 

  307.              r"""|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|&\w+;)""",
    308. 

  308.              String
    309. 

  309.             ),
    310. 

  310.             # -- HexString
    311. 

  311.             (r'x"[0-9a-fA-F_\s]*"[cwd]?', String),
    312. 

  312.             # -- DelimitedString
    313. 

  313.             (r'q"\[', String, 'delimited_bracket'),
    314. 

  314.             (r'q"\(', String, 'delimited_parenthesis'),
    315. 

  315.             (r'q"<', String, 'delimited_angle'),
    316. 

  316.             (r'q"{', String, 'delimited_curly'),
    317. 

  317.             (r'q"([a-zA-Z_]\w*)\n.*?\n\1"', String),
    318. 

  318.             (r'q"(.).*?\1"', String),
    319. 

  319.             # -- TokenString
    320. 

  320.             (r'q{', String, 'token_string'),
    321. 

  321.             # Tokens
    322. 

  322.             (r'(~=|\^=|%=|\*=|==|!>=|!<=|!<>=|!<>|!<|!>|!=|>>>=|>>>|>>=|>>|>='
    323. 

  323.              r'|<>=|<>|<<=|<<|<=|\+\+|\+=|--|-=|\|\||\|=|&&|&=|\.\.\.|\.\.|/=)'
    324. 

  324.              r'|[/.&|\-+<>!()\[\]{}?,;:$=*%^~]', Punctuation
    325. 

  325.             ),
    326. 

  326.             # Identifier
    327. 

  327.             (r'[a-zA-Z_]\w*', Name),
    328. 

  328.         ],
    329. 

  329.         'nested_comment': [
    330. 

  330.             (r'[^+/]+', Comment),
    331. 

  331.             (r'/\+', Comment, '#push'),
    332. 

  332.             (r'\+/', Comment, '#pop'),
    333. 

  333.             (r'[+/]', Comment),
    334. 

  334.         ],
    335. 

  335.         'token_string': [
    336. 

  336.             (r'{', Punctuation, 'token_string_nest'),
    337. 

  337.             (r'}', String, '#pop'),
    338. 

  338.             include('root'),
    339. 

  339.         ],
    340. 

  340.         'token_string_nest': [
    341. 

  341.             (r'{', Punctuation, '#push'),
    342. 

  342.             (r'}', Punctuation, '#pop'),
    343. 

  343.             include('root'),
    344. 

  344.         ],
    345. 

  345.         'delimited_bracket': [
    346. 

  346.             (r'[^\[\]]+', String),
    347. 

  347.             (r'\[', String, 'delimited_inside_bracket'),
    348. 

  348.             (r'\]"', String, '#pop'),
    349. 

  349.         ],
    350. 

  350.         'delimited_inside_bracket': [
    351. 

  351.             (r'[^\[\]]+', String),
    352. 

  352.             (r'\[', String, '#push'),
    353. 

  353.             (r'\]', String, '#pop'),
    354. 

  354.         ],
    355. 

  355.         'delimited_parenthesis': [
    356. 

  356.             (r'[^\(\)]+', String),
    357. 

  357.             (r'\(', String, 'delimited_inside_parenthesis'),
    358. 

  358.             (r'\)"', String, '#pop'),
    359. 

  359.         ],
    360. 

  360.         'delimited_inside_parenthesis': [
    361. 

  361.             (r'[^\(\)]+', String),
    362. 

  362.             (r'\(', String, '#push'),
    363. 

  363.             (r'\)', String, '#pop'),
    364. 

  364.         ],
    365. 

  365.         'delimited_angle': [
    366. 

  366.             (r'[^<>]+', String),
    367. 

  367.             (r'<', String, 'delimited_inside_angle'),
    368. 

  368.             (r'>"', String, '#pop'),
    369. 

  369.         ],
    370. 

  370.         'delimited_inside_angle': [
    371. 

  371.             (r'[^<>]+', String),
    372. 

  372.             (r'<', String, '#push'),
    373. 

  373.             (r'>', String, '#pop'),
    374. 

  374.         ],
    375. 

  375.         'delimited_curly': [
    376. 

  376.             (r'[^{}]+', String),
    377. 

  377.             (r'{', String, 'delimited_inside_curly'),
    378. 

  378.             (r'}"', String, '#pop'),
    379. 

  379.         ],
    380. 

  380.         'delimited_inside_curly': [
    381. 

  381.             (r'[^{}]+', String),
    382. 

  382.             (r'{', String, '#push'),
    383. 

  383.             (r'}', String, '#pop'),
    384. 

  384.         ],
    385. 

  385.     }
    386. 

  386. 

  387. 

  388. class DelphiLexer(Lexer):
    389. 

  389.     """
    390. 

  390.     For `Delphi <http://www.borland.com/delphi/>`_ (Borland Object Pascal),
    391. 

  391.     Turbo Pascal and Free Pascal source code.
    392. 

  392. 

  393.     Additional options accepted:
    394. 

  394. 

  395.     `turbopascal`
    396. 

  396.         Highlight Turbo Pascal specific keywords (default: ``True``).
    397. 

  397.     `delphi`
    398. 

  398.         Highlight Borland Delphi specific keywords (default: ``True``).
    399. 

  399.     `freepascal`
    400. 

  400.         Highlight Free Pascal specific keywords (default: ``True``).
    401. 

  401.     `units`
    402. 

  402.         A list of units that should be considered builtin, supported are
    403. 

  403.         ``System``, ``SysUtils``, ``Classes`` and ``Math``.
    404. 

  404.         Default is to consider all of them builtin.
    405. 

  405.     """
    406. 

  406.     name = 'Delphi'
    407. 

  407.     aliases = ['delphi', 'pas', 'pascal', 'objectpascal']
    408. 

  408.     filenames = ['*.pas']
    409. 

  409.     mimetypes = ['text/x-pascal']
    410. 

  410. 

  411.     TURBO_PASCAL_KEYWORDS = [
    412. 

  412.         'absolute', 'and', 'array', 'asm', 'begin', 'break', 'case',
    413. 

  413.         'const', 'constructor', 'continue', 'destructor', 'div', 'do',
    414. 

  414.         'downto', 'else', 'end', 'file', 'for', 'function', 'goto',
    415. 

  415.         'if', 'implementation', 'in', 'inherited', 'inline', 'interface',
    416. 

  416.         'label', 'mod', 'nil', 'not', 'object', 'of', 'on', 'operator',
    417. 

  417.         'or', 'packed', 'procedure', 'program', 'record', 'reintroduce',
    418. 

  418.         'repeat', 'self', 'set', 'shl', 'shr', 'string', 'then', 'to',
    419. 

  419.         'type', 'unit', 'until', 'uses', 'var', 'while', 'with', 'xor'
    420. 

  420.     ]
    421. 

  421. 

  422.     DELPHI_KEYWORDS = [
    423. 

  423.         'as', 'class', 'except', 'exports', 'finalization', 'finally',
    424. 

  424.         'initialization', 'is', 'library', 'on', 'property', 'raise',
    425. 

  425.         'threadvar', 'try'
    426. 

  426.     ]
    427. 

  427. 

  428.     FREE_PASCAL_KEYWORDS = [
    429. 

  429.         'dispose', 'exit', 'false', 'new', 'true'
    430. 

  430.     ]
    431. 

  431. 

  432.     BLOCK_KEYWORDS = set([
    433. 

  433.         'begin', 'class', 'const', 'constructor', 'destructor', 'end',
    434. 

  434.         'finalization', 'function', 'implementation', 'initialization',
    435. 

  435.         'label', 'library', 'operator', 'procedure', 'program', 'property',
    436. 

  436.         'record', 'threadvar', 'type', 'unit', 'uses', 'var'
    437. 

  437.     ])
    438. 

  438. 

  439.     FUNCTION_MODIFIERS = set([
    440. 

  440.         'alias', 'cdecl', 'export', 'inline', 'interrupt', 'nostackframe',
    441. 

  441.         'pascal', 'register', 'safecall', 'softfloat', 'stdcall',
    442. 

  442.         'varargs', 'name', 'dynamic', 'near', 'virtual', 'external',
    443. 

  443.         'override', 'assembler'
    444. 

  444.     ])
    445. 

  445. 

  446.     # XXX: those aren't global. but currently we know no way for defining
    447. 

  447.     #      them just for the type context.
    448. 

  448.     DIRECTIVES = set([
    449. 

  449.         'absolute', 'abstract', 'assembler', 'cppdecl', 'default', 'far',
    450. 

  450.         'far16', 'forward', 'index', 'oldfpccall', 'private', 'protected',
    451. 

  451.         'published', 'public'
    452. 

  452.     ])
    453. 

  453. 

  454.     BUILTIN_TYPES = set([
    455. 

  455.         'ansichar', 'ansistring', 'bool', 'boolean', 'byte', 'bytebool',
    456. 

  456.         'cardinal', 'char', 'comp', 'currency', 'double', 'dword',
    457. 

  457.         'extended', 'int64', 'integer', 'iunknown', 'longbool', 'longint',
    458. 

  458.         'longword', 'pansichar', 'pansistring', 'pbool', 'pboolean',
    459. 

  459.         'pbyte', 'pbytearray', 'pcardinal', 'pchar', 'pcomp', 'pcurrency',
    460. 

  460.         'pdate', 'pdatetime', 'pdouble', 'pdword', 'pextended', 'phandle',
    461. 

  461.         'pint64', 'pinteger', 'plongint', 'plongword', 'pointer',
    462. 

  462.         'ppointer', 'pshortint', 'pshortstring', 'psingle', 'psmallint',
    463. 

  463.         'pstring', 'pvariant', 'pwidechar', 'pwidestring', 'pword',
    464. 

  464.         'pwordarray', 'pwordbool', 'real', 'real48', 'shortint',
    465. 

  465.         'shortstring', 'single', 'smallint', 'string', 'tclass', 'tdate',
    466. 

  466.         'tdatetime', 'textfile', 'thandle', 'tobject', 'ttime', 'variant',
    467. 

  467.         'widechar', 'widestring', 'word', 'wordbool'
    468. 

  468.     ])
    469. 

  469. 

  470.     BUILTIN_UNITS = {
    471. 

  471.         'System': [
    472. 

  472.             'abs', 'acquireexceptionobject', 'addr', 'ansitoutf8',
    473. 

  473.             'append', 'arctan', 'assert', 'assigned', 'assignfile',
    474. 

  474.             'beginthread', 'blockread', 'blockwrite', 'break', 'chdir',
    475. 

  475.             'chr', 'close', 'closefile', 'comptocurrency', 'comptodouble',
    476. 

  476.             'concat', 'continue', 'copy', 'cos', 'dec', 'delete',
    477. 

  477.             'dispose', 'doubletocomp', 'endthread', 'enummodules',
    478. 

  478.             'enumresourcemodules', 'eof', 'eoln', 'erase', 'exceptaddr',
    479. 

  479.             'exceptobject', 'exclude', 'exit', 'exp', 'filepos', 'filesize',
    480. 

  480.             'fillchar', 'finalize', 'findclasshinstance', 'findhinstance',
    481. 

  481.             'findresourcehinstance', 'flush', 'frac', 'freemem',
    482. 

  482.             'get8087cw', 'getdir', 'getlasterror', 'getmem',
    483. 

  483.             'getmemorymanager', 'getmodulefilename', 'getvariantmanager',
    484. 

  484.             'halt', 'hi', 'high', 'inc', 'include', 'initialize', 'insert',
    485. 

  485.             'int', 'ioresult', 'ismemorymanagerset', 'isvariantmanagerset',
    486. 

  486.             'length', 'ln', 'lo', 'low', 'mkdir', 'move', 'new', 'odd',
    487. 

  487.             'olestrtostring', 'olestrtostrvar', 'ord', 'paramcount',
    488. 

  488.             'paramstr', 'pi', 'pos', 'pred', 'ptr', 'pucs4chars', 'random',
    489. 

  489.             'randomize', 'read', 'readln', 'reallocmem',
    490. 

  490.             'releaseexceptionobject', 'rename', 'reset', 'rewrite', 'rmdir',
    491. 

  491.             'round', 'runerror', 'seek', 'seekeof', 'seekeoln',
    492. 

  492.             'set8087cw', 'setlength', 'setlinebreakstyle',
    493. 

  493.             'setmemorymanager', 'setstring', 'settextbuf',
    494. 

  494.             'setvariantmanager', 'sin', 'sizeof', 'slice', 'sqr', 'sqrt',
    495. 

  495.             'str', 'stringofchar', 'stringtoolestr', 'stringtowidechar',
    496. 

  496.             'succ', 'swap', 'trunc', 'truncate', 'typeinfo',
    497. 

  497.             'ucs4stringtowidestring', 'unicodetoutf8', 'uniquestring',
    498. 

  498.             'upcase', 'utf8decode', 'utf8encode', 'utf8toansi',
    499. 

  499.             'utf8tounicode', 'val', 'vararrayredim', 'varclear',
    500. 

  500.             'widecharlentostring', 'widecharlentostrvar',
    501. 

  501.             'widechartostring', 'widechartostrvar',
    502. 

  502.             'widestringtoucs4string', 'write', 'writeln'
    503. 

  503.         ],
    504. 

  504.         'SysUtils': [
    505. 

  505.             'abort', 'addexitproc', 'addterminateproc', 'adjustlinebreaks',
    506. 

  506.             'allocmem', 'ansicomparefilename', 'ansicomparestr',
    507. 

  507.             'ansicomparetext', 'ansidequotedstr', 'ansiextractquotedstr',
    508. 

  508.             'ansilastchar', 'ansilowercase', 'ansilowercasefilename',
    509. 

  509.             'ansipos', 'ansiquotedstr', 'ansisamestr', 'ansisametext',
    510. 

  510.             'ansistrcomp', 'ansistricomp', 'ansistrlastchar', 'ansistrlcomp',
    511. 

  511.             'ansistrlicomp', 'ansistrlower', 'ansistrpos', 'ansistrrscan',
    512. 

  512.             'ansistrscan', 'ansistrupper', 'ansiuppercase',
    513. 

  513.             'ansiuppercasefilename', 'appendstr', 'assignstr', 'beep',
    514. 

  514.             'booltostr', 'bytetocharindex', 'bytetocharlen', 'bytetype',
    515. 

  515.             'callterminateprocs', 'changefileext', 'charlength',
    516. 

  516.             'chartobyteindex', 'chartobytelen', 'comparemem', 'comparestr',
    517. 

  517.             'comparetext', 'createdir', 'createguid', 'currentyear',
    518. 

  518.             'currtostr', 'currtostrf', 'date', 'datetimetofiledate',
    519. 

  519.             'datetimetostr', 'datetimetostring', 'datetimetosystemtime',
    520. 

  520.             'datetimetotimestamp', 'datetostr', 'dayofweek', 'decodedate',
    521. 

  521.             'decodedatefully', 'decodetime', 'deletefile', 'directoryexists',
    522. 

  522.             'diskfree', 'disksize', 'disposestr', 'encodedate', 'encodetime',
    523. 

  523.             'exceptionerrormessage', 'excludetrailingbackslash',
    524. 

  524.             'excludetrailingpathdelimiter', 'expandfilename',
    525. 

  525.             'expandfilenamecase', 'expanduncfilename', 'extractfiledir',
    526. 

  526.             'extractfiledrive', 'extractfileext', 'extractfilename',
    527. 

  527.             'extractfilepath', 'extractrelativepath', 'extractshortpathname',
    528. 

  528.             'fileage', 'fileclose', 'filecreate', 'filedatetodatetime',
    529. 

  529.             'fileexists', 'filegetattr', 'filegetdate', 'fileisreadonly',
    530. 

  530.             'fileopen', 'fileread', 'filesearch', 'fileseek', 'filesetattr',
    531. 

  531.             'filesetdate', 'filesetreadonly', 'filewrite', 'finalizepackage',
    532. 

  532.             'findclose', 'findcmdlineswitch', 'findfirst', 'findnext',
    533. 

  533.             'floattocurr', 'floattodatetime', 'floattodecimal', 'floattostr',
    534. 

  534.             'floattostrf', 'floattotext', 'floattotextfmt', 'fmtloadstr',
    535. 

  535.             'fmtstr', 'forcedirectories', 'format', 'formatbuf', 'formatcurr',
    536. 

  536.             'formatdatetime', 'formatfloat', 'freeandnil', 'getcurrentdir',
    537. 

  537.             'getenvironmentvariable', 'getfileversion', 'getformatsettings',
    538. 

  538.             'getlocaleformatsettings', 'getmodulename', 'getpackagedescription',
    539. 

  539.             'getpackageinfo', 'gettime', 'guidtostring', 'incamonth',
    540. 

  540.             'includetrailingbackslash', 'includetrailingpathdelimiter',
    541. 

  541.             'incmonth', 'initializepackage', 'interlockeddecrement',
    542. 

  542.             'interlockedexchange', 'interlockedexchangeadd',
    543. 

  543.             'interlockedincrement', 'inttohex', 'inttostr', 'isdelimiter',
    544. 

  544.             'isequalguid', 'isleapyear', 'ispathdelimiter', 'isvalidident',
    545. 

  545.             'languages', 'lastdelimiter', 'loadpackage', 'loadstr',
    546. 

  546.             'lowercase', 'msecstotimestamp', 'newstr', 'nextcharindex', 'now',
    547. 

  547.             'outofmemoryerror', 'quotedstr', 'raiselastoserror',
    548. 

  548.             'raiselastwin32error', 'removedir', 'renamefile', 'replacedate',
    549. 

  549.             'replacetime', 'safeloadlibrary', 'samefilename', 'sametext',
    550. 

  550.             'setcurrentdir', 'showexception', 'sleep', 'stralloc', 'strbufsize',
    551. 

  551.             'strbytetype', 'strcat', 'strcharlength', 'strcomp', 'strcopy',
    552. 

  552.             'strdispose', 'strecopy', 'strend', 'strfmt', 'stricomp',
    553. 

  553.             'stringreplace', 'stringtoguid', 'strlcat', 'strlcomp', 'strlcopy',
    554. 

  554.             'strlen', 'strlfmt', 'strlicomp', 'strlower', 'strmove', 'strnew',
    555. 

  555.             'strnextchar', 'strpas', 'strpcopy', 'strplcopy', 'strpos',
    556. 

  556.             'strrscan', 'strscan', 'strtobool', 'strtobooldef', 'strtocurr',
    557. 

  557.             'strtocurrdef', 'strtodate', 'strtodatedef', 'strtodatetime',
    558. 

  558.             'strtodatetimedef', 'strtofloat', 'strtofloatdef', 'strtoint',
    559. 

  559.             'strtoint64', 'strtoint64def', 'strtointdef', 'strtotime',
    560. 

  560.             'strtotimedef', 'strupper', 'supports', 'syserrormessage',
    561. 

  561.             'systemtimetodatetime', 'texttofloat', 'time', 'timestamptodatetime',
    562. 

  562.             'timestamptomsecs', 'timetostr', 'trim', 'trimleft', 'trimright',
    563. 

  563.             'tryencodedate', 'tryencodetime', 'tryfloattocurr', 'tryfloattodatetime',
    564. 

  564.             'trystrtobool', 'trystrtocurr', 'trystrtodate', 'trystrtodatetime',
    565. 

  565.             'trystrtofloat', 'trystrtoint', 'trystrtoint64', 'trystrtotime',
    566. 

  566.             'unloadpackage', 'uppercase', 'widecomparestr', 'widecomparetext',
    567. 

  567.             'widefmtstr', 'wideformat', 'wideformatbuf', 'widelowercase',
    568. 

  568.             'widesamestr', 'widesametext', 'wideuppercase', 'win32check',
    569. 

  569.             'wraptext'
    570. 

  570.         ],
    571. 

  571.         'Classes': [
    572. 

  572.             'activateclassgroup', 'allocatehwnd', 'bintohex', 'checksynchronize',
    573. 

  573.             'collectionsequal', 'countgenerations', 'deallocatehwnd', 'equalrect',
    574. 

  574.             'extractstrings', 'findclass', 'findglobalcomponent', 'getclass',
    575. 

  575.             'groupdescendantswith', 'hextobin', 'identtoint',
    576. 

  576.             'initinheritedcomponent', 'inttoident', 'invalidpoint',
    577. 

  577.             'isuniqueglobalcomponentname', 'linestart', 'objectbinarytotext',
    578. 

  578.             'objectresourcetotext', 'objecttexttobinary', 'objecttexttoresource',
    579. 

  579.             'pointsequal', 'readcomponentres', 'readcomponentresex',
    580. 

  580.             'readcomponentresfile', 'rect', 'registerclass', 'registerclassalias',
    581. 

  581.             'registerclasses', 'registercomponents', 'registerintegerconsts',
    582. 

  582.             'registernoicon', 'registernonactivex', 'smallpoint', 'startclassgroup',
    583. 

  583.             'teststreamformat', 'unregisterclass', 'unregisterclasses',
    584. 

  584.             'unregisterintegerconsts', 'unregistermoduleclasses',
    585. 

  585.             'writecomponentresfile'
    586. 

  586.         ],
    587. 

  587.         'Math': [
    588. 

  588.             'arccos', 'arccosh', 'arccot', 'arccoth', 'arccsc', 'arccsch', 'arcsec',
    589. 

  589.             'arcsech', 'arcsin', 'arcsinh', 'arctan2', 'arctanh', 'ceil',
    590. 

  590.             'comparevalue', 'cosecant', 'cosh', 'cot', 'cotan', 'coth', 'csc',
    591. 

  591.             'csch', 'cycletodeg', 'cycletograd', 'cycletorad', 'degtocycle',
    592. 

  592.             'degtograd', 'degtorad', 'divmod', 'doubledecliningbalance',
    593. 

  593.             'ensurerange', 'floor', 'frexp', 'futurevalue', 'getexceptionmask',
    594. 

  594.             'getprecisionmode', 'getroundmode', 'gradtocycle', 'gradtodeg',
    595. 

  595.             'gradtorad', 'hypot', 'inrange', 'interestpayment', 'interestrate',
    596. 

  596.             'internalrateofreturn', 'intpower', 'isinfinite', 'isnan', 'iszero',
    597. 

  597.             'ldexp', 'lnxp1', 'log10', 'log2', 'logn', 'max', 'maxintvalue',
    598. 

  598.             'maxvalue', 'mean', 'meanandstddev', 'min', 'minintvalue', 'minvalue',
    599. 

  599.             'momentskewkurtosis', 'netpresentvalue', 'norm', 'numberofperiods',
    600. 

  600.             'payment', 'periodpayment', 'poly', 'popnstddev', 'popnvariance',
    601. 

  601.             'power', 'presentvalue', 'radtocycle', 'radtodeg', 'radtograd',
    602. 

  602.             'randg', 'randomrange', 'roundto', 'samevalue', 'sec', 'secant',
    603. 

  603.             'sech', 'setexceptionmask', 'setprecisionmode', 'setroundmode',
    604. 

  604.             'sign', 'simpleroundto', 'sincos', 'sinh', 'slndepreciation', 'stddev',
    605. 

  605.             'sum', 'sumint', 'sumofsquares', 'sumsandsquares', 'syddepreciation',
    606. 

  606.             'tan', 'tanh', 'totalvariance', 'variance'
    607. 

  607.         ]
    608. 

  608.     }
    609. 

  609. 

  610.     ASM_REGISTERS = set([
    611. 

  611.         'ah', 'al', 'ax', 'bh', 'bl', 'bp', 'bx', 'ch', 'cl', 'cr0',
    612. 

  612.         'cr1', 'cr2', 'cr3', 'cr4', 'cs', 'cx', 'dh', 'di', 'dl', 'dr0',
    613. 

  613.         'dr1', 'dr2', 'dr3', 'dr4', 'dr5', 'dr6', 'dr7', 'ds', 'dx',
    614. 

  614.         'eax', 'ebp', 'ebx', 'ecx', 'edi', 'edx', 'es', 'esi', 'esp',
    615. 

  615.         'fs', 'gs', 'mm0', 'mm1', 'mm2', 'mm3', 'mm4', 'mm5', 'mm6',
    616. 

  616.         'mm7', 'si', 'sp', 'ss', 'st0', 'st1', 'st2', 'st3', 'st4', 'st5',
    617. 

  617.         'st6', 'st7', 'xmm0', 'xmm1', 'xmm2', 'xmm3', 'xmm4', 'xmm5',
    618. 

  618.         'xmm6', 'xmm7'
    619. 

  619.     ])
    620. 

  620. 

  621.     ASM_INSTRUCTIONS = set([
    622. 

  622.         'aaa', 'aad', 'aam', 'aas', 'adc', 'add', 'and', 'arpl', 'bound',
    623. 

  623.         'bsf', 'bsr', 'bswap', 'bt', 'btc', 'btr', 'bts', 'call', 'cbw',
    624. 

  624.         'cdq', 'clc', 'cld', 'cli', 'clts', 'cmc', 'cmova', 'cmovae',
    625. 

  625.         'cmovb', 'cmovbe', 'cmovc', 'cmovcxz', 'cmove', 'cmovg',
    626. 

  626.         'cmovge', 'cmovl', 'cmovle', 'cmovna', 'cmovnae', 'cmovnb',
    627. 

  627.         'cmovnbe', 'cmovnc', 'cmovne', 'cmovng', 'cmovnge', 'cmovnl',
    628. 

  628.         'cmovnle', 'cmovno', 'cmovnp', 'cmovns', 'cmovnz', 'cmovo',
    629. 

  629.         'cmovp', 'cmovpe', 'cmovpo', 'cmovs', 'cmovz', 'cmp', 'cmpsb',
    630. 

  630.         'cmpsd', 'cmpsw', 'cmpxchg', 'cmpxchg486', 'cmpxchg8b', 'cpuid',
    631. 

  631.         'cwd', 'cwde', 'daa', 'das', 'dec', 'div', 'emms', 'enter', 'hlt',
    632. 

  632.         'ibts', 'icebp', 'idiv', 'imul', 'in', 'inc', 'insb', 'insd',
    633. 

  633.         'insw', 'int', 'int01', 'int03', 'int1', 'int3', 'into', 'invd',
    634. 

  634.         'invlpg', 'iret', 'iretd', 'iretw', 'ja', 'jae', 'jb', 'jbe',
    635. 

  635.         'jc', 'jcxz', 'jcxz', 'je', 'jecxz', 'jg', 'jge', 'jl', 'jle',
    636. 

  636.         'jmp', 'jna', 'jnae', 'jnb', 'jnbe', 'jnc', 'jne', 'jng', 'jnge',
    637. 

  637.         'jnl', 'jnle', 'jno', 'jnp', 'jns', 'jnz', 'jo', 'jp', 'jpe',
    638. 

  638.         'jpo', 'js', 'jz', 'lahf', 'lar', 'lcall', 'lds', 'lea', 'leave',
    639. 

  639.         'les', 'lfs', 'lgdt', 'lgs', 'lidt', 'ljmp', 'lldt', 'lmsw',
    640. 

  640.         'loadall', 'loadall286', 'lock', 'lodsb', 'lodsd', 'lodsw',
    641. 

  641.         'loop', 'loope', 'loopne', 'loopnz', 'loopz', 'lsl', 'lss', 'ltr',
    642. 

  642.         'mov', 'movd', 'movq', 'movsb', 'movsd', 'movsw', 'movsx',
    643. 

  643.         'movzx', 'mul', 'neg', 'nop', 'not', 'or', 'out', 'outsb', 'outsd',
    644. 

  644.         'outsw', 'pop', 'popa', 'popad', 'popaw', 'popf', 'popfd', 'popfw',
    645. 

  645.         'push', 'pusha', 'pushad', 'pushaw', 'pushf', 'pushfd', 'pushfw',
    646. 

  646.         'rcl', 'rcr', 'rdmsr', 'rdpmc', 'rdshr', 'rdtsc', 'rep', 'repe',
    647. 

  647.         'repne', 'repnz', 'repz', 'ret', 'retf', 'retn', 'rol', 'ror',
    648. 

  648.         'rsdc', 'rsldt', 'rsm', 'sahf', 'sal', 'salc', 'sar', 'sbb',
    649. 

  649.         'scasb', 'scasd', 'scasw', 'seta', 'setae', 'setb', 'setbe',
    650. 

  650.         'setc', 'setcxz', 'sete', 'setg', 'setge', 'setl', 'setle',
    651. 

  651.         'setna', 'setnae', 'setnb', 'setnbe', 'setnc', 'setne', 'setng',
    652. 

  652.         'setnge', 'setnl', 'setnle', 'setno', 'setnp', 'setns', 'setnz',
    653. 

  653.         'seto', 'setp', 'setpe', 'setpo', 'sets', 'setz', 'sgdt', 'shl',
    654. 

  654.         'shld', 'shr', 'shrd', 'sidt', 'sldt', 'smi', 'smint', 'smintold',
    655. 

  655.         'smsw', 'stc', 'std', 'sti', 'stosb', 'stosd', 'stosw', 'str',
    656. 

  656.         'sub', 'svdc', 'svldt', 'svts', 'syscall', 'sysenter', 'sysexit',
    657. 

  657.         'sysret', 'test', 'ud1', 'ud2', 'umov', 'verr', 'verw', 'wait',
    658. 

  658.         'wbinvd', 'wrmsr', 'wrshr', 'xadd', 'xbts', 'xchg', 'xlat',
    659. 

  659.         'xlatb', 'xor'
    660. 

  660.     ])
    661. 

  661. 

  662.     def __init__(self, **options):
    663. 

  663.         Lexer.__init__(self, **options)
    664. 

  664.         self.keywords = set()
    665. 

  665.         if get_bool_opt(options, 'turbopascal', True):
    666. 

  666.             self.keywords.update(self.TURBO_PASCAL_KEYWORDS)
    667. 

  667.         if get_bool_opt(options, 'delphi', True):
    668. 

  668.             self.keywords.update(self.DELPHI_KEYWORDS)
    669. 

  669.         if get_bool_opt(options, 'freepascal', True):
    670. 

  670.             self.keywords.update(self.FREE_PASCAL_KEYWORDS)
    671. 

  671.         self.builtins = set()
    672. 

  672.         for unit in get_list_opt(options, 'units', self.BUILTIN_UNITS.keys()):
    673. 

  673.             self.builtins.update(self.BUILTIN_UNITS[unit])
    674. 

  674. 

  675.     def get_tokens_unprocessed(self, text):
    676. 

  676.         scanner = Scanner(text, re.DOTALL | re.MULTILINE | re.IGNORECASE)
    677. 

  677.         stack = ['initial']
    678. 

  678.         in_function_block = False
    679. 

  679.         in_property_block = False
    680. 

  680.         was_dot = False
    681. 

  681.         next_token_is_function = False
    682. 

  682.         next_token_is_property = False
    683. 

  683.         collect_labels = False
    684. 

  684.         block_labels = set()
    685. 

  685.         brace_balance = [0, 0]
    686. 

  686. 

  687.         while not scanner.eos:
    688. 

  688.             token = Error
    689. 

  689. 

  690.             if stack[-1] == 'initial':
    691. 

  691.                 if scanner.scan(r'\s+'):
    692. 

  692.                     token = Text
    693. 

  693.                 elif scanner.scan(r'\{.*?\}|\(\*.*?\*\)'):
    694. 

  694.                     if scanner.match.startswith('$'):
    695. 

  695.                         token = Comment.Preproc
    696. 

  696.                     else:
    697. 

  697.                         token = Comment.Multiline
    698. 

  698.                 elif scanner.scan(r'//.*?$'):
    699. 

  699.                     token = Comment.Single
    700. 

  700.                 elif scanner.scan(r'[-+*\/=<>:;,.@\^]'):
    701. 

  701.                     token = Operator
    702. 

  702.                     # stop label highlighting on next ";"
    703. 

  703.                     if collect_labels and scanner.match == ';':
    704. 

  704.                         collect_labels = False
    705. 

  705.                 elif scanner.scan(r'[\(\)\[\]]+'):
    706. 

  706.                     token = Punctuation
    707. 

  707.                     # abort function naming ``foo = Function(...)``
    708. 

  708.                     next_token_is_function = False
    709. 

  709.                     # if we are in a function block we count the open
    710. 

  710.                     # braces because ootherwise it's impossible to
    711. 

  711.                     # determine the end of the modifier context
    712. 

  712.                     if in_function_block or in_property_block:
    713. 

  713.                         if scanner.match == '(':
    714. 

  714.                             brace_balance[0] += 1
    715. 

  715.                         elif scanner.match == ')':
    716. 

  716.                             brace_balance[0] -= 1
    717. 

  717.                         elif scanner.match == '[':
    718. 

  718.                             brace_balance[1] += 1
    719. 

  719.                         elif scanner.match == ']':
    720. 

  720.                             brace_balance[1] -= 1
    721. 

  721.                 elif scanner.scan(r'[A-Za-z_][A-Za-z_0-9]*'):
    722. 

  722.                     lowercase_name = scanner.match.lower()
    723. 

  723.                     if lowercase_name == 'result':
    724. 

  724.                         token = Name.Builtin.Pseudo
    725. 

  725.                     elif lowercase_name in self.keywords:
    726. 

  726.                         token = Keyword
    727. 

  727.                         # if we are in a special block and a
    728. 

  728.                         # block ending keyword occours (and the parenthesis
    729. 

  729.                         # is balanced) we end the current block context
    730. 

  730.                         if (in_function_block or in_property_block) and \
    731. 

  731.                            lowercase_name in self.BLOCK_KEYWORDS and \
    732. 

  732.                            brace_balance[0] <= 0 and \
    733. 

  733.                            brace_balance[1] <= 0:
    734. 

  734.                             in_function_block = False
    735. 

  735.                             in_property_block = False
    736. 

  736.                             brace_balance = [0, 0]
    737. 

  737.                             block_labels = set()
    738. 

  738.                         if lowercase_name in ('label', 'goto'):
    739. 

  739.                             collect_labels = True
    740. 

  740.                         elif lowercase_name == 'asm':
    741. 

  741.                             stack.append('asm')
    742. 

  742.                         elif lowercase_name == 'property':
    743. 

  743.                             in_property_block = True
    744. 

  744.                             next_token_is_property = True
    745. 

  745.                         elif lowercase_name in ('procedure', 'operator',
    746. 

  746.                                                 'function', 'constructor',
    747. 

  747.                                                 'destructor'):
    748. 

  748.                             in_function_block = True
    749. 

  749.                             next_token_is_function = True
    750. 

  750.                     # we are in a function block and the current name
    751. 

  751.                     # is in the set of registered modifiers. highlight
    752. 

  752.                     # it as pseudo keyword
    753. 

  753.                     elif in_function_block and \
    754. 

  754.                          lowercase_name in self.FUNCTION_MODIFIERS:
    755. 

  755.                         token = Keyword.Pseudo
    756. 

  756.                     # if we are in a property highlight some more
    757. 

  757.                     # modifiers
    758. 

  758.                     elif in_property_block and \
    759. 

  759.                          lowercase_name in ('read', 'write'):
    760. 

  760.                         token = Keyword.Pseudo
    761. 

  761.                         next_token_is_function = True
    762. 

  762.                     # if the last iteration set next_token_is_function
    763. 

  763.                     # to true we now want this name highlighted as
    764. 

  764.                     # function. so do that and reset the state
    765. 

  765.                     elif next_token_is_function:
    766. 

  766.                         # Look if the next token is a dot. If yes it's
    767. 

  767.                         # not a function, but a class name and the
    768. 

  768.                         # part after the dot a function name
    769. 

  769.                         if scanner.test(r'\s*\.\s*'):
    770. 

  770.                             token = Name.Class
    771. 

  771.                         # it's not a dot, our job is done
    772. 

  772.                         else:
    773. 

  773.                             token = Name.Function
    774. 

  774.                             next_token_is_function = False
    775. 

  775.                     # same for properties
    776. 

  776.                     elif next_token_is_property:
    777. 

  777.                         token = Name.Property
    778. 

  778.                         next_token_is_property = False
    779. 

  779.                     # Highlight this token as label and add it
    780. 

  780.                     # to the list of known labels
    781. 

  781.                     elif collect_labels:
    782. 

  782.                         token = Name.Label
    783. 

  783.                         block_labels.add(scanner.match.lower())
    784. 

  784.                     # name is in list of known labels
    785. 

  785.                     elif lowercase_name in block_labels:
    786. 

  786.                         token = Name.Label
    787. 

  787.                     elif lowercase_name in self.BUILTIN_TYPES:
    788. 

  788.                         token = Keyword.Type
    789. 

  789.                     elif lowercase_name in self.DIRECTIVES:
    790. 

  790.                         token = Keyword.Pseudo
    791. 

  791.                     # builtins are just builtins if the token
    792. 

  792.                     # before isn't a dot
    793. 

  793.                     elif not was_dot and lowercase_name in self.builtins:
    794. 

  794.                         token = Name.Builtin
    795. 

  795.                     else:
    796. 

  796.                         token = Name
    797. 

  797.                 elif scanner.scan(r"'"):
    798. 

  798.                     token = String
    799. 

  799.                     stack.append('string')
    800. 

  800.                 elif scanner.scan(r'\#(\d+|\$[0-9A-Fa-f]+)'):
    801. 

  801.                     token = String.Char
    802. 

  802.                 elif scanner.scan(r'\$[0-9A-Fa-f]+'):
    803. 

  803.                     token = Number.Hex
    804. 

  804.                 elif scanner.scan(r'\d+(?![eE]|\.[^.])'):
    805. 

  805.                     token = Number.Integer
    806. 

  806.                 elif scanner.scan(r'\d+(\.\d+([eE][+-]?\d+)?|[eE][+-]?\d+)'):
    807. 

  807.                     token = Number.Float
    808. 

  808.                 else:
    809. 

  809.                     # if the stack depth is deeper than once, pop
    810. 

  810.                     if len(stack) > 1:
    811. 

  811.                         stack.pop()
    812. 

  812.                     scanner.get_char()
    813. 

  813. 

  814.             elif stack[-1] == 'string':
    815. 

  815.                 if scanner.scan(r"''"):
    816. 

  816.                     token = String.Escape
    817. 

  817.                 elif scanner.scan(r"'"):
    818. 

  818.                     token = String
    819. 

  819.                     stack.pop()
    820. 

  820.                 elif scanner.scan(r"[^']*"):
    821. 

  821.                     token = String
    822. 

  822.                 else:
    823. 

  823.                     scanner.get_char()
    824. 

  824.                     stack.pop()
    825. 

  825. 

  826.             elif stack[-1] == 'asm':
    827. 

  827.                 if scanner.scan(r'\s+'):
    828. 

  828.                     token = Text
    829. 

  829.                 elif scanner.scan(r'end'):
    830. 

  830.                     token = Keyword
    831. 

  831.                     stack.pop()
    832. 

  832.                 elif scanner.scan(r'\{.*?\}|\(\*.*?\*\)'):
    833. 

  833.                     if scanner.match.startswith('$'):
    834. 

  834.                         token = Comment.Preproc
    835. 

  835.                     else:
    836. 

  836.                         token = Comment.Multiline
    837. 

  837.                 elif scanner.scan(r'//.*?$'):
    838. 

  838.                     token = Comment.Single
    839. 

  839.                 elif scanner.scan(r"'"):
    840. 

  840.                     token = String
    841. 

  841.                     stack.append('string')
    842. 

  842.                 elif scanner.scan(r'@@[A-Za-z_][A-Za-z_0-9]*'):
    843. 

  843.                     token = Name.Label
    844. 

  844.                 elif scanner.scan(r'[A-Za-z_][A-Za-z_0-9]*'):
    845. 

  845.                     lowercase_name = scanner.match.lower()
    846. 

  846.                     if lowercase_name in self.ASM_INSTRUCTIONS:
    847. 

  847.                         token = Keyword
    848. 

  848.                     elif lowercase_name in self.ASM_REGISTERS:
    849. 

  849.                         token = Name.Builtin
    850. 

  850.                     else:
    851. 

  851.                         token = Name
    852. 

  852.                 elif scanner.scan(r'[-+*\/=<>:;,.@\^]+'):
    853. 

  853.                     token = Operator
    854. 

  854.                 elif scanner.scan(r'[\(\)\[\]]+'):
    855. 

  855.                     token = Punctuation
    856. 

  856.                 elif scanner.scan(r'\$[0-9A-Fa-f]+'):
    857. 

  857.                     token = Number.Hex
    858. 

  858.                 elif scanner.scan(r'\d+(?![eE]|\.[^.])'):
    859. 

  859.                     token = Number.Integer
    860. 

  860.                 elif scanner.scan(r'\d+(\.\d+([eE][+-]?\d+)?|[eE][+-]?\d+)'):
    861. 

  861.                     token = Number.Float
    862. 

  862.                 else:
    863. 

  863.                     scanner.get_char()
    864. 

  864.                     stack.pop()
    865. 

  865. 

  866.             # save the dot!!!11
    867. 

  867.             if scanner.match.strip():
    868. 

  868.                 was_dot = scanner.match == '.'
    869. 

  869.             yield scanner.start_pos, token, scanner.match or ''
    870. 

  870. 

  871. 

  872. class JavaLexer(RegexLexer):
    873. 

  873.     """
    874. 

  874.     For `Java <http://www.sun.com/java/>`_ source code.
    875. 

  875.     """
    876. 

    877. 

  877.     name = 'Java'
    878. 

  878.     aliases = ['java']
    879. 

  879.     filenames = ['*.java']
    880. 

  880.     mimetypes = ['text/x-java']
    881. 

  881. 

  882.     flags = re.MULTILINE | re.DOTALL
    883. 

  883. 

  884.     #: optional Comment or Whitespace
    885. 

  885.     _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
    886. 

  886. 

  887.     tokens = {
    888. 

  888.         'root': [
    889. 

  889.             # method names
    890. 

  890.             (r'^(\s*(?:[a-zA-Z_][a-zA-Z0-9_\.\[\]]*\s+)+?)' # return arguments
    891. 

  891.              r'([a-zA-Z_][a-zA-Z0-9_]*)'                    # method name
    892. 

  892.              r'(\s*)(\()',                                  # signature start
    893. 

  893.              bygroups(using(this), Name.Function, Text, Operator)),
    894. 

  894.             (r'[^\S\n]+', Text),
    895. 

  895.             (r'//.*?\n', Comment),
    896. 

  896.             (r'/\*.*?\*/', Comment),
    897. 

  897.             (r'@[a-zA-Z_][a-zA-Z0-9_\.]*', Name.Decorator),
    898. 

  898.             (r'(assert|break|case|catch|continue|default|do|else|finally|for|'
    899. 

  899.              r'if|goto|instanceof|new|return|switch|this|throw|try|while)\b',
    900. 

  900.              Keyword),
    901. 

  901.             (r'(abstract|const|enum|extends|final|implements|native|private|'
    902. 

  902.              r'protected|public|static|strictfp|super|synchronized|throws|'
    903. 

  903.              r'transient|volatile)\b', Keyword.Declaration),
    904. 

  904.             (r'(boolean|byte|char|double|float|int|long|short|void)\b',
    905. 

  905.              Keyword.Type),
    906. 

  906.             (r'(package)(\s+)', bygroups(Keyword.Namespace, Text)),
    907. 

  907.             (r'(true|false|null)\b', Keyword.Constant),
    908. 

  908.             (r'(class|interface)(\s+)', bygroups(Keyword.Declaration, Text), 'class'),
    909. 

  909.             (r'(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
    910. 

  910.             (r'"(\\\\|\\"|[^"])*"', String),
    911. 

  911.             (r"'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'", String.Char),
    912. 

  912.             (r'(\.)([a-zA-Z_][a-zA-Z0-9_]*)', bygroups(Operator, Name.Attribute)),
    913. 

  913.             (r'[a-zA-Z_][a-zA-Z0-9_]*:', Name.Label),
    914. 

  914.             (r'[a-zA-Z_\$][a-zA-Z0-9_]*', Name),
    915. 

  915.             (r'[~\^\*!%&\[\]\(\)\{\}<>\|+=:;,./?-]', Operator),
    916. 

  916.             (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
    917. 

  917.             (r'0x[0-9a-f]+', Number.Hex),
    918. 

  918.             (r'[0-9]+L?', Number.Integer),
    919. 

  919.             (r'\n', Text)
    920. 

  920.         ],
    921. 

  921.         'class': [
    922. 

  922.             (r'[a-zA-Z_][a-zA-Z0-9_]*', Name.Class, '#pop')
    923. 

  923.         ],
    924. 

  924.         'import': [
    925. 

  925.             (r'[a-zA-Z0-9_.]+\*?', Name.Namespace, '#pop')
    926. 

  926.         ],
    927. 

  927.     }
    928. 

  928. 

  929. class ScalaLexer(RegexLexer):
    930. 

  930.     """
    931. 

  931.     For `Scala <http://www.scala-lang.org>`_ source code.
    932. 

  932.     """
    933. 

    934. 

  934.     name = 'Scala'
    935. 

  935.     aliases = ['scala']
    936. 

  936.     filenames = ['*.scala']
    937. 

  937.     mimetypes = ['text/x-scala']
    938. 

  938. 

  939.     flags = re.MULTILINE | re.DOTALL
    940. 

  940. 

  941.     #: optional Comment or Whitespace
    942. 

  942.     _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
    943. 

  943. 

  944.     tokens = {
    945. 

  945.         'root': [
    946. 

  946.             # method names
    947. 

  947.             (r'(class|interface|trait|object)(\s+)', bygroups(Keyword, Text), 'class'),
    948. 

  948.             (r'^(\s*def)'
    949. 

  949.              r'([a-zA-Z_][a-zA-Z0-9_]*)'                    # method name
    950. 

  950.              r'(\s*)(\()',                                  # signature start
    951. 

  951.              bygroups(using(this), Name.Function, Text, Operator)),
    952. 

  952.             (r"'([a-zA-Z_][a-zA-Z0-9_]*)", Text.Symbol),
    953. 

  953.             (r'[^\S\n]+', Text),
    954. 

  954.             (r'//.*?\n', Comment),
    955. 

  955.             (r'/\*.*?\*/', Comment),
    956. 

  956.             (r'@[a-zA-Z_][a-zA-Z0-9_\.]*', Name.Decorator),
    957. 

  957.             (r'(abstract|case|catch|do|else|extends|final|finally|for|forSome'
    958. 

  958.              r'|if|implicit|lazy|match|new|null|override|private|protected'
    959. 

  959.              r'|requires|return|sealed|super|this|throw|try|type|while|with'
    960. 

  960.              r'|yield|let|def|var|println|=>|<-|_)\b', Keyword),
    961. 

  961.             (r'(boolean|byte|char|double|float|int|long|short|void)\b',
    962. 

  962.              Keyword.Type),
    963. 

  963.             (r'(String|Int|Array|HashMap)\b', Keyword.Type),
    964. 

  964.             (r'(true|false|null)\b', Keyword.Constant),
    965. 

  965.             (r'(import)(\s+)', bygroups(Keyword, Text), 'import'),
    966. 

  966.             (r'"(\\\\|\\"|[^"])*"', String),
    967. 

  967.             (r"'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'", String.Char),
    968. 

  968.             (r'(\.)([a-zA-Z_][a-zA-Z0-9_]*)', bygroups(Operator, Name.Attribute)),
    969. 

  969.             (r'[a-zA-Z_\$][a-zA-Z0-9_]*', Name),
    970. 

  970.             (r'[~\^\*!%&\[\]\(\)\{\}<>\|+=:;,./?-]', Operator),
    971. 

  971.             (r'[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?', Number.Float),
    972. 

  972.             (r'0x[0-9a-f]+', Number.Hex),
    973. 

  973.             (r'[0-9]+L?', Number.Integer),
    974. 

  974.             (r'\n', Text)
    975. 

  975.         ],
    976. 

  976.         'class': [
    977. 

  977.             (r'[a-zA-Z_][a-zA-Z0-9_]*', Name.Class, '#pop'),
    978. 

  978.             (r'([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\()',
    979. 

  979.              bygroups(Name.Class, Text, Operator), '#pop'),
    980. 

  980.         ],
    981. 

  981.         'import': [
    982. 

  982.             (r'[a-zA-Z0-9_.]+\*?', Name.Namespace, '#pop')
    983. 

  983.         ],
    984. 

  984.     }
    985. 

  985. 

  986. 

  987. class DylanLexer(RegexLexer):
    988. 

  988.     """
    989. 

  989.     For the `Dylan <http://www.opendylan.org/>`_ language.
    990. 

  990. 

  991.     *New in Pygments 0.7.*
    992. 

  992.     """
    993. 

    994. 

  994.     name = 'Dylan'
    995. 

  995.     aliases = ['dylan']
    996. 

  996.     filenames = ['*.dylan']
    997. 

  997.     mimetypes = ['text/x-dylan']
    998. 

  998. 

  999.     flags = re.DOTALL
    1000. 

  1000. 

  1001.     tokens = {
    1002. 

  1002.         'root': [
    1003. 

  1003.             (r'\b(subclass|abstract|block|c(on(crete|stant)|lass)|domain'
    1004. 

  1004.              r'|ex(c(eption|lude)|port)|f(unction(|al))|generic|handler'
    1005. 

  1005.              r'|i(n(herited|line|stance|terface)|mport)|library|m(acro|ethod)'
    1006. 

  1006.              r'|open|primary|sealed|si(deways|ngleton)|slot'
    1007. 

  1007.              r'|v(ariable|irtual))\b', Name.Builtin),
    1008. 

  1008.             (r'<\w+>', Keyword.Type),
    1009. 

  1009.             (r'#?"(?:\\.|[^"])+?"', String.Double),
    1010. 

  1010.             (r'//.*?\n', Comment),
    1011. 

  1011.             (r'/\*[\w\W]*?\*/', Comment.Multiline),
    1012. 

  1012.             (r'\'.*?\'', String.Single),
    1013. 

  1013.             (r'=>|\b(a(bove|fterwards)|b(e(gin|low)|y)|c(ase|leanup|reate)'
    1014. 

  1014.              r'|define|else(|if)|end|f(inally|or|rom)|i[fn]|l(et|ocal)|otherwise'
    1015. 

  1015.              r'|rename|s(elect|ignal)|t(hen|o)|u(n(less|til)|se)|wh(en|ile))\b',
    1016. 

  1016.              Keyword),
    1017. 

  1017.             (r'([ \t])([!\$%&\*\/:<=>\?~_^a-zA-Z0-9.+\-]*:)',
    1018. 

  1018.              bygroups(Text, Name.Variable)),
    1019. 

  1019.             (r'([ \t]*)(\S+[^:])([ \t]*)(\()([ \t]*)',
    1020. 

  1020.              bygroups(Text, Name.Function, Text, Punctuation, Text)),
    1021. 

  1021.             (r'-?[0-9.]+', Number),
    1022. 

  1022.             (r'[(),;]', Punctuation),
    1023. 

  1023.             (r'\$[a-zA-Z0-9-]+', Name.Constant),
    1024. 

  1024.             (r'[!$%&*/:<>=?~^.+\[\]{}-]+', Operator),
    1025. 

  1025.             (r'\s+', Text),
    1026. 

  1026.             (r'#[a-zA-Z0-9-]+', Keyword),
    1027. 

  1027.             (r'[a-zA-Z0-9-]+', Name.Variable),
    1028. 

  1028.         ],
    1029. 

  1029.     }
    1030. 

  1030. 

  1031. 

  1032. class ObjectiveCLexer(RegexLexer):
    1033. 

  1033.     """
    1034. 

  1034.     For Objective-C source code with preprocessor directives.
    1035. 

  1035.     """
    1036. 

    1037. 

  1037.     name = 'Objective-C'
    1038. 

  1038.     aliases = ['objective-c', 'objectivec', 'obj-c', 'objc']
    1039. 

  1039.     #XXX: objc has .h files too :-/
    1040. 

  1040.     filenames = ['*.m']
    1041. 

  1041.     mimetypes = ['text/x-objective-c']
    1042. 

  1042. 

  1043.     #: optional Comment or Whitespace
    1044. 

  1044.     _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
    1045. 

  1045. 

  1046.     tokens = {
    1047. 

  1047.         'whitespace': [
    1048. 

  1048.             (r'^(\s*)(#if\s+0)', bygroups(Text, Comment.Preproc), 'if0'),
    1049. 

  1049.             (r'^(\s*)(#)', bygroups(Text, Comment.Preproc), 'macro'),
    1050. 

  1050.             (r'\n', Text),
    1051. 

  1051.             (r'\s+', Text),
    1052. 

  1052.             (r'\\\n', Text), # line continuation
    1053. 

  1053.             (r'//(\n|(.|\n)*?[^\\]\n)', Comment),
    1054. 

  1054.             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment),
    1055. 

  1055.         ],
    1056. 

  1056.         'statements': [
    1057. 

  1057.             (r'(L|@)?"', String, 'string'),
    1058. 

  1058.             (r"(L|@)?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'", String.Char),
    1059. 

  1059.             (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
    1060. 

  1060.             (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
    1061. 

  1061.             (r'0x[0-9a-fA-F]+[Ll]?', Number.Hex),
    1062. 

  1062.             (r'0[0-7]+[Ll]?', Number.Oct),
    1063. 

  1063.             (r'\d+[Ll]?', Number.Integer),
    1064. 

  1064.             (r'[~!%^&*+=|?:<>/-]', Operator),
    1065. 

  1065.             (r'[()\[\],.]', Punctuation),
    1066. 

  1066.             (r'(auto|break|case|const|continue|default|do|else|enum|extern|'
    1067. 

  1067.              r'for|goto|if|register|restricted|return|sizeof|static|struct|'
    1068. 

  1068.              r'switch|typedef|union|volatile|virtual|while|in|@selector|'
    1069. 

  1069.              r'@private|@protected|@public|@encode|'
    1070. 

  1070.              r'@synchronized|@try|@throw|@catch|@finally|@end|@property|'
    1071. 

  1071.              r'@synthesize|@dynamic)\b', Keyword),
    1072. 

  1072.             (r'(int|long|float|short|double|char|unsigned|signed|void|'
    1073. 

  1073.              r'id|BOOL|IBOutlet|IBAction|SEL)\b', Keyword.Type),
    1074. 

  1074.             (r'(_{0,2}inline|naked|restrict|thread|typename)\b', Keyword.Reserved),
    1075. 

  1075.             (r'__(asm|int8|based|except|int16|stdcall|cdecl|fastcall|int32|'
    1076. 

  1076.              r'declspec|finally|int64|try|leave)\b', Keyword.Reserved),
    1077. 

  1077.             (r'(TRUE|FALSE|nil|NULL)\b', Name.Builtin),
    1078. 

  1078.             ('[a-zA-Z_][a-zA-Z0-9_]*:(?!:)', Name.Label),
    1079. 

  1079.             ('[a-zA-Z_][a-zA-Z0-9_]*', Name),
    1080. 

  1080.         ],
    1081. 

  1081.         'root': [
    1082. 

  1082.             include('whitespace'),
    1083. 

  1083.             # functions
    1084. 

  1084.             (r'((?:[a-zA-Z0-9_*\s])+?(?:\s|[*]))'    # return arguments
    1085. 

  1085.              r'([a-zA-Z_][a-zA-Z0-9_]*)'             # method name
    1086. 

  1086.              r'(\s*\([^;]*?\))'                      # signature
    1087. 

  1087.              r'(' + _ws + r')({)',
    1088. 

  1088.              bygroups(using(this), Name.Function, using(this), Text, Punctuation),
    1089. 

  1089.              'function'),
    1090. 

  1090.             # function declarations
    1091. 

  1091.             (r'((?:[a-zA-Z0-9_*\s])+?(?:\s|[*]))'    # return arguments
    1092. 

  1092.              r'([a-zA-Z_][a-zA-Z0-9_]*)'             # method name
    1093. 

  1093.              r'(\s*\([^;]*?\))'                      # signature
    1094. 

  1094.              r'(' + _ws + r')(;)',
    1095. 

  1095.              bygroups(using(this), Name.Function, using(this), Text, Punctuation)),
    1096. 

  1096.             (r'(@interface|@implementation)(\s+)', bygroups(Keyword, Text), 'classname'),
    1097. 

  1097.             (r'(@class|@protocol)(\s+)', bygroups(Keyword, Text), 'forward_classname'),
    1098. 

  1098.             (r'(\s*)(@end)(\s*)', bygroups(Text, Keyword, Text)),
    1099. 

  1099.             ('', Text, 'statement'),
    1100. 

  1100.         ],
    1101. 

  1101.         'classname' : [
    1102. 

  1102.             # interface definition that inherits
    1103. 

  1103.             ('([a-zA-Z_][a-zA-Z0-9_]*)(\s*:\s*)([a-zA-Z_][a-zA-Z0-9_]*)?',
    1104. 

  1104.              bygroups(Name.Class, Text, Name.Class), '#pop'),
    1105. 

  1105.             # interface definition for a category
    1106. 

  1106.             ('([a-zA-Z_][a-zA-Z0-9_]*)(\s*)(\([a-zA-Z_][a-zA-Z0-9_]*\))',
    1107. 

  1107.              bygroups(Name.Class, Text, Name.Label), '#pop'),
    1108. 

  1108.             # simple interface / implementation
    1109. 

  1109.             ('([a-zA-Z_][a-zA-Z0-9_]*)', Name.Class, '#pop')
    1110. 

  1110.         ],
    1111. 

  1111.         'forward_classname' : [
    1112. 

  1112.           ('([a-zA-Z_][a-zA-Z0-9_]*)(\s*,\s*)',
    1113. 

  1113.            bygroups(Name.Class, Text), 'forward_classname'),
    1114. 

  1114.           ('([a-zA-Z_][a-zA-Z0-9_]*)(\s*;?)',
    1115. 

  1115.            bygroups(Name.Class, Text), '#pop')
    1116. 

  1116.         ],
    1117. 

  1117.         'statement' : [
    1118. 

  1118.             include('whitespace'),
    1119. 

  1119.             include('statements'),
    1120. 

  1120.             ('[{}]', Punctuation),
    1121. 

  1121.             (';', Punctuation, '#pop'),
    1122. 

  1122.         ],
    1123. 

  1123.         'function': [
    1124. 

  1124.             include('whitespace'),
    1125. 

  1125.             include('statements'),
    1126. 

  1126.             (';', Punctuation),
    1127. 

  1127.             ('{', Punctuation, '#push'),
    1128. 

  1128.             ('}', Punctuation, '#pop'),
    1129. 

  1129.         ],
    1130. 

  1130.         'string': [
    1131. 

  1131.             (r'"', String, '#pop'),
    1132. 

  1132.             (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape),
    1133. 

  1133.             (r'[^\\"\n]+', String), # all other characters
    1134. 

  1134.             (r'\\\n', String), # line continuation
    1135. 

  1135.             (r'\\', String), # stray backslash
    1136. 

  1136.         ],
    1137. 

  1137.         'macro': [
    1138. 

  1138.             (r'[^/\n]+', Comment.Preproc),
    1139. 

  1139.             (r'/[*](.|\n)*?[*]/', Comment),
    1140. 

  1140.             (r'//.*?\n', Comment, '#pop'),
    1141. 

  1141.             (r'/', Comment.Preproc),
    1142. 

  1142.             (r'(?<=\\)\n', Comment.Preproc),
    1143. 

  1143.             (r'\n', Comment.Preproc, '#pop'),
    1144. 

  1144.         ],
    1145. 

  1145.         'if0': [
    1146. 

  1146.             (r'^\s*#if.*?(?<!\\)\n', Comment, '#push'),
    1147. 

  1147.             (r'^\s*#endif.*?(?<!\\)\n', Comment, '#pop'),
    1148. 

  1148.             (r'.*?\n', Comment),
    1149. 

  1149.         ]
    1150. 

  1150.     }
    1151. 

  1151. 

  1152. 

  1153. class FortranLexer(RegexLexer):
    1154. 

  1154.     '''
    1155. 

  1155.     Lexer for FORTRAN 90 code.
    1156. 

  1156. 

  1157.     *New in Pygments 0.10.*
    1158. 

  1158.     '''
    1159. 

  1159.     name = 'Fortran'
    1160. 

  1160.     aliases = ['fortran']
    1161. 

  1161.     filenames = ['*.f', '*.f90']
    1162. 

  1162.     mimetypes = ['text/x-fortran']
    1163. 

  1163.     flags = re.IGNORECASE
    1164. 

  1164. 

  1165.     # Data Types: INTEGER, REAL, COMPLEX, LOGICAL, CHARACTER and DOUBLE PRECISION
    1166. 

  1166.     # Operators: **, *, +, -, /, <, >, <=, >=, ==, /=
    1167. 

  1167.     # Logical (?): NOT, AND, OR, EQV, NEQV
    1168. 

  1168. 

  1169.     # Builtins:
    1170. 

  1170.     # http://gcc.gnu.org/onlinedocs/gcc-3.4.6/g77/Table-of-Intrinsic-Functions.html
    1171. 

  1171. 

  1172.     tokens = {
    1173. 

  1173.         'root': [
    1174. 

  1174.             (r'!.*\n', Comment),
    1175. 

  1175.             include('strings'),
    1176. 

  1176.             include('core'),
    1177. 

  1177.             (r'[a-z][a-z0-9_]*', Name.Variable),
    1178. 

  1178.             include('nums'),
    1179. 

  1179.             (r'[\s]+', Text),
    1180. 

  1180.         ],
    1181. 

  1181.         'core': [
    1182. 

  1182.             # Statements
    1183. 

  1183.             (r'\b(ACCEPT|ALLOCATABLE|ALLOCATE|ARRAY|ASSIGN|BACKSPACE|BLOCK DATA|'
    1184. 

  1184.              r'BYTE|CALL|CASE|CLOSE|COMMON|CONTAINS|CONTINUE|CYCLE|DATA|'
    1185. 

  1185.              r'DEALLOCATE|DECODE|DIMENSION|DO|ENCODE|END FILE|ENDIF|END|ENTRY|'
    1186. 

  1186.              r'EQUIVALENCE|EXIT|EXTERNAL|EXTRINSIC|FORALL|FORMAT|FUNCTION|GOTO|'
    1187. 

  1187.              r'IF|IMPLICIT|INCLUDE|INQUIRE|INTENT|INTERFACE|INTRINSIC|MODULE|'
    1188. 

  1188.              r'NAMELIST|NULLIFY|NONE|OPEN|OPTIONAL|OPTIONS|PARAMETER|PAUSE|'
    1189. 

  1189.              r'POINTER|PRINT|PRIVATE|PROGRAM|PUBLIC|PURE|READ|RECURSIVE|RETURN|'
    1190. 

  1190.              r'REWIND|SAVE|SELECT|SEQUENCE|STOP|SUBROUTINE|TARGET|TYPE|USE|'
    1191. 

  1191.              r'VOLATILE|WHERE|WRITE|WHILE|THEN|ELSE|ENDIF)\s*\b',
    1192. 

  1192.              Keyword),
    1193. 

  1193. 

  1194.             # Data Types
    1195. 

  1195.             (r'\b(CHARACTER|COMPLEX|DOUBLE PRECISION|DOUBLE COMPLEX|INTEGER|'
    1196. 

  1196.              r'LOGICAL|REAL)\s*\b',
    1197. 

  1197.              Keyword.Type),
    1198. 

  1198. 

  1199.             # Operators
    1200. 

  1200.             (r'(\*\*|\*|\+|-|\/|<|>|<=|>=|==|\/=|=)', Operator),
    1201. 

  1201. 

  1202.             (r'(::)', Keyword.Declaration),
    1203. 

  1203. 

  1204.             (r'[(),:&%]', Punctuation),
    1205. 

  1205. 

  1206.             # Intrinsics
    1207. 

  1207.             (r'\b(Abort|Abs|Access|AChar|ACos|AdjustL|AdjustR|AImag|AInt|Alarm|'
    1208. 

  1208.              r'All|Allocated|ALog|AMax|AMin|AMod|And|ANInt|Any|'
    1209. 

  1209.              r'ASin|Associated|ATan|BesJ|BesJN|BesY|BesYN|'
    1210. 

  1210.              r'Bit_Size|BTest|CAbs|CCos|Ceiling|CExp|Char|ChDir|ChMod|CLog|'
    1211. 

  1211.              r'Cmplx|Complex|Conjg|Cos|CosH|Count|CPU_Time|CShift|CSin|CSqRt|'
    1212. 

  1212.              r'CTime|DAbs|DACos|DASin|DATan|Date_and_Time|DbesJ|'
    1213. 

  1213.              r'DbesJ|DbesJN|DbesY|DbesY|DbesYN|Dble|DCos|DCosH|DDiM|DErF|DErFC|'
    1214. 

  1214.              r'DExp|Digits|DiM|DInt|DLog|DLog|DMax|DMin|DMod|DNInt|Dot_Product|'
    1215. 

  1215.              r'DProd|DSign|DSinH|DSin|DSqRt|DTanH|DTan|DTime|EOShift|Epsilon|'
    1216. 

  1216.              r'ErF|ErFC|ETime|Exit|Exp|Exponent|FDate|FGet|FGetC|Float|'
    1217. 

  1217.              r'Floor|Flush|FNum|FPutC|FPut|Fraction|FSeek|FStat|FTell|'
    1218. 

  1218.              r'GError|GetArg|GetCWD|GetEnv|GetGId|GetLog|GetPId|GetUId|'
    1219. 

  1219.              r'GMTime|HostNm|Huge|IAbs|IAChar|IAnd|IArgC|IBClr|IBits|'
    1220. 

  1220.              r'IBSet|IChar|IDate|IDiM|IDInt|IDNInt|IEOr|IErrNo|IFix|Imag|'
    1221. 

  1221.              r'ImagPart|Index|Int|IOr|IRand|IsaTty|IShft|IShftC|ISign|'
    1222. 

  1222.              r'ITime|Kill|Kind|LBound|Len|Len_Trim|LGe|LGt|Link|LLe|LLt|LnBlnk|'
    1223. 

  1223.              r'Loc|Log|Log|Logical|Long|LShift|LStat|LTime|MatMul|Max|'
    1224. 

  1224.              r'MaxExponent|MaxLoc|MaxVal|MClock|Merge|Min|MinExponent|MinLoc|'
    1225. 

  1225.              r'MinVal|Mod|Modulo|MvBits|Nearest|NInt|Not|Or|Pack|PError|'
    1226. 

  1226.              r'Precision|Present|Product|Radix|Rand|Random_Number|Random_Seed|'
    1227. 

  1227.              r'Range|Real|RealPart|Rename|Repeat|Reshape|RRSpacing|RShift|Scale|'
    1228. 

  1228.              r'Scan|Second|Selected_Int_Kind|Selected_Real_Kind|Set_Exponent|'
    1229. 

  1229.              r'Shape|Short|Sign|Signal|SinH|Sin|Sleep|Sngl|Spacing|Spread|SqRt|'
    1230. 

  1230.              r'SRand|Stat|Sum|SymLnk|System|System_Clock|Tan|TanH|Time|'
    1231. 

  1231.              r'Tiny|Transfer|Transpose|Trim|TtyNam|UBound|UMask|Unlink|Unpack|'
    1232. 

  1232.              r'Verify|XOr|ZAbs|ZCos|ZExp|ZLog|ZSin|ZSqRt)\s*\b',
    1233. 

  1233.              Name.Builtin),
    1234. 

  1234. 

  1235.             # Booleans
    1236. 

  1236.             (r'\.(true|false)\.', Name.Builtin),
    1237. 

  1237.             # Comparing Operators
    1238. 

  1238.             (r'\.(eq|ne|lt|le|gt|ge|not|and|or|eqv|neqv)\.', Operator.Word),
    1239. 

  1239.         ],
    1240. 

  1240. 

  1241.         'strings': [
    1242. 

  1242.             (r'"(\\\\|\\[0-7]+|\\.|[^"])*"', String.Double),
    1243. 

  1243.             (r"'(\\\\|\\[0-7]+|\\.|[^'])*'", String.Single),
    1244. 

  1244.         ],
    1245. 

  1245. 

  1246.         'nums': [
    1247. 

  1247.             (r'\d+(?![.Ee])', Number.Integer),
    1248. 

  1248.             (r'[+-]?\d*\.\d+([eE][-+]?\d+)?', Number.Float),
    1249. 

  1249.             (r'[+-]?\d+\.\d*([eE][-+]?\d+)?', Number.Float),
    1250. 

  1250.         ],
    1251. 

  1251.     }
    1252.