Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

# -*- coding: utf-8 -*- 

""" 

    pygments.lexers.esoteric 

    ~~~~~~~~~~~~~~~~~~~~~~~~ 

 

    Lexers for esoteric languages. 

 

    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS. 

    :license: BSD, see LICENSE for details. 

""" 

 

from pygments.lexer import RegexLexer, include 

from pygments.token import Text, Comment, Operator, Keyword, Name, String, \ 

    Number, Punctuation, Error 

 

__all__ = ['BrainfuckLexer', 'BefungeLexer', 'RedcodeLexer'] 

 

 

class BrainfuckLexer(RegexLexer): 

    """ 

    Lexer for the esoteric `BrainFuck <http://www.muppetlabs.com/~breadbox/bf/>`_ 

    language. 

    """ 

 

    name = 'Brainfuck' 

    aliases = ['brainfuck', 'bf'] 

    filenames = ['*.bf', '*.b'] 

    mimetypes = ['application/x-brainfuck'] 

 

    tokens = { 

        'common': [ 

            # use different colors for different instruction types 

            (r'[.,]+', Name.Tag), 

            (r'[+-]+', Name.Builtin), 

            (r'[<>]+', Name.Variable), 

            (r'[^.,+\-<>\[\]]+', Comment), 

        ], 

        'root': [ 

            (r'\[', Keyword, 'loop'), 

            (r'\]', Error), 

            include('common'), 

        ], 

        'loop': [ 

            (r'\[', Keyword, '#push'), 

            (r'\]', Keyword, '#pop'), 

            include('common'), 

        ] 

    } 

 

 

class BefungeLexer(RegexLexer): 

    """ 

    Lexer for the esoteric `Befunge <http://en.wikipedia.org/wiki/Befunge>`_ 

    language. 

 

    .. versionadded:: 0.7 

    """ 

    name = 'Befunge' 

    aliases = ['befunge'] 

    filenames = ['*.befunge'] 

    mimetypes = ['application/x-befunge'] 

 

    tokens = { 

        'root': [ 

            (r'[0-9a-f]', Number), 

            (r'[+*/%!`-]', Operator),             # Traditional math 

            (r'[<>^v?\[\]rxjk]', Name.Variable),  # Move, imperatives 

            (r'[:\\$.,n]', Name.Builtin),         # Stack ops, imperatives 

            (r'[|_mw]', Keyword), 

            (r'[{}]', Name.Tag),                  # Befunge-98 stack ops 

            (r'".*?"', String.Double),            # Strings don't appear to allow escapes 

            (r'\'.', String.Single),              # Single character 

            (r'[#;]', Comment),                   # Trampoline... depends on direction hit 

            (r'[pg&~=@iotsy]', Keyword),          # Misc 

            (r'[()A-Z]', Comment),                # Fingerprints 

            (r'\s+', Text),                       # Whitespace doesn't matter 

        ], 

    } 

 

 

class RedcodeLexer(RegexLexer): 

    """ 

    A simple Redcode lexer based on ICWS'94. 

    Contributed by Adam Blinkinsop <blinks@acm.org>. 

 

    .. versionadded:: 0.8 

    """ 

    name = 'Redcode' 

    aliases = ['redcode'] 

    filenames = ['*.cw'] 

 

    opcodes = ('DAT', 'MOV', 'ADD', 'SUB', 'MUL', 'DIV', 'MOD', 

               'JMP', 'JMZ', 'JMN', 'DJN', 'CMP', 'SLT', 'SPL', 

               'ORG', 'EQU', 'END') 

    modifiers = ('A', 'B', 'AB', 'BA', 'F', 'X', 'I') 

 

    tokens = { 

        'root': [ 

            # Whitespace: 

            (r'\s+', Text), 

            (r';.*$', Comment.Single), 

            # Lexemes: 

            #  Identifiers 

            (r'\b(%s)\b' % '|'.join(opcodes), Name.Function), 

            (r'\b(%s)\b' % '|'.join(modifiers), Name.Decorator), 

            (r'[A-Za-z_]\w+', Name), 

            #  Operators 

            (r'[-+*/%]', Operator), 

            (r'[#$@<>]', Operator),  # mode 

            (r'[.,]', Punctuation),  # mode 

            #  Numbers 

            (r'[-+]?\d+', Number.Integer), 

        ], 

    }