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

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

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

""" 

    pygments.lexers.urbi 

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

 

    Lexers for UrbiScript language. 

 

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

    :license: BSD, see LICENSE for details. 

""" 

 

import re 

 

from pygments.lexer import ExtendedRegexLexer, words 

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

    Number, Punctuation 

 

__all__ = ['UrbiscriptLexer'] 

 

 

class UrbiscriptLexer(ExtendedRegexLexer): 

    """ 

    For UrbiScript source code. 

 

    .. versionadded:: 1.5 

    """ 

 

    name = 'UrbiScript' 

    aliases = ['urbiscript'] 

    filenames = ['*.u'] 

    mimetypes = ['application/x-urbiscript'] 

 

    flags = re.DOTALL 

 

    # TODO 

    # - handle Experimental and deprecated tags with specific tokens 

    # - handle Angles and Durations with specific tokens 

 

    def blob_callback(lexer, match, ctx): 

        text_before_blob = match.group(1) 

        blob_start = match.group(2) 

        blob_size_str = match.group(3) 

        blob_size = int(blob_size_str) 

        yield match.start(), String, text_before_blob 

        ctx.pos += len(text_before_blob) 

 

        # if blob size doesn't match blob format (example : "\B(2)(aaa)") 

        # yield blob as a string 

        if ctx.text[match.end() + blob_size] != ")": 

            result = "\\B(" + blob_size_str + ")(" 

            yield match.start(), String, result 

            ctx.pos += len(result) 

            return 

 

        # if blob is well formated, yield as Escape 

        blob_text = blob_start + ctx.text[match.end():match.end()+blob_size] + ")" 

        yield match.start(), String.Escape, blob_text 

        ctx.pos = match.end() + blob_size + 1  # +1 is the ending ")" 

 

    tokens = { 

        'root': [ 

            (r'\s+', Text), 

            # comments 

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

            (r'/\*', Comment.Multiline, 'comment'), 

            (r'(every|for|loop|while)(?:;|&|\||,)', Keyword), 

            (words(( 

                'assert', 'at', 'break', 'case', 'catch', 'closure', 'compl', 

                'continue', 'default', 'else', 'enum', 'every', 'external', 

                'finally', 'for', 'freezeif', 'if', 'new', 'onleave', 'return', 

                'stopif', 'switch', 'this', 'throw', 'timeout', 'try', 

                'waituntil', 'whenever', 'while'), suffix=r'\b'), 

             Keyword), 

            (words(( 

                'asm', 'auto', 'bool', 'char', 'const_cast', 'delete', 'double', 

                'dynamic_cast', 'explicit', 'export', 'extern', 'float', 'friend', 

                'goto', 'inline', 'int', 'long', 'mutable', 'namespace', 'register', 

                'reinterpret_cast', 'short', 'signed', 'sizeof', 'static_cast', 

                'struct', 'template', 'typedef', 'typeid', 'typename', 'union', 

                'unsigned', 'using', 'virtual', 'volatile', 'wchar_t'), suffix=r'\b'), 

             Keyword.Reserved), 

            # deprecated keywords, use a meaningfull token when available 

            (r'(emit|foreach|internal|loopn|static)\b', Keyword), 

            # ignored keywords, use a meaningfull token when available 

            (r'(private|protected|public)\b', Keyword), 

            (r'(var|do|const|function|class)\b', Keyword.Declaration), 

            (r'(true|false|nil|void)\b', Keyword.Constant), 

            (words(( 

                'Barrier', 'Binary', 'Boolean', 'CallMessage', 'Channel', 'Code', 

                'Comparable', 'Container', 'Control', 'Date', 'Dictionary', 'Directory', 

                'Duration', 'Enumeration', 'Event', 'Exception', 'Executable', 'File', 

                'Finalizable', 'Float', 'FormatInfo', 'Formatter', 'Global', 'Group', 

                'Hash', 'InputStream', 'IoService', 'Job', 'Kernel', 'Lazy', 'List', 

                'Loadable', 'Lobby', 'Location', 'Logger', 'Math', 'Mutex', 'nil', 

                'Object', 'Orderable', 'OutputStream', 'Pair', 'Path', 'Pattern', 

                'Position', 'Primitive', 'Process', 'Profile', 'PseudoLazy', 'PubSub', 

                'RangeIterable', 'Regexp', 'Semaphore', 'Server', 'Singleton', 'Socket', 

                'StackFrame', 'Stream', 'String', 'System', 'Tag', 'Timeout', 

                'Traceable', 'TrajectoryGenerator', 'Triplet', 'Tuple', 'UObject', 

                'UValue', 'UVar'), suffix=r'\b'), 

             Name.Builtin), 

            (r'(?:this)\b', Name.Builtin.Pseudo), 

            # don't match single | and & 

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

            (r'(?:and_eq|and|bitand|bitor|in|not|not_eq|or_eq|or|xor_eq|xor)\b', 

             Operator.Word), 

            (r'[{}\[\]()]+', Punctuation), 

            (r'(?:;|\||,|&|\?|!)+', Punctuation), 

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

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

            # Float, Integer, Angle and Duration 

            (r'(?:[0-9]+(?:(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?)?' 

             r'((?:rad|deg|grad)|(?:ms|s|min|h|d))?)\b', Number.Float), 

            # handle binary blob in strings 

            (r'"', String.Double, "string.double"), 

            (r"'", String.Single, "string.single"), 

        ], 

        'string.double': [ 

            (r'((?:\\\\|\\"|[^"])*?)(\\B\((\d+)\)\()', blob_callback), 

            (r'(\\\\|\\"|[^"])*?"', String.Double, '#pop'), 

        ], 

        'string.single': [ 

            (r"((?:\\\\|\\'|[^'])*?)(\\B\((\d+)\)\()", blob_callback), 

            (r"(\\\\|\\'|[^'])*?'", String.Single, '#pop'), 

        ], 

        # from http://pygments.org/docs/lexerdevelopment/#changing-states 

        'comment': [ 

            (r'[^*/]', Comment.Multiline), 

            (r'/\*', Comment.Multiline, '#push'), 

            (r'\*/', Comment.Multiline, '#pop'), 

            (r'[*/]', Comment.Multiline), 

        ] 

    }