← Back to branch summary

~ubuntu-branches/ubuntu/trusty/wxwidgets2.8/trusty

« back to all changes in this revision

Viewing changes to wxPython/wx/tools/Editra/src/extern/pygments/lexers/hdl.py

  • Committer: Package Import Robot
  • Author(s): Dmitry Shachnev
  • Date: 2013-11-30 21:11:54 UTC
  • mfrom: (1.1.10) (5.1.22 sid)
  • Revision ID: package-import@ubuntu.com-20131130211154-xfa8ttxc4n0zo9jd
Tags: 2.8.12.1+dfsg-2ubuntu1
https://launchpad.net/bugs/1253003
* Merge with Debian unstable (LP: #1253003), remaining changes:
  - Disable bp-menubar-fix.patch.
  - Disable disable_media_python.patch to add wx.media to python-wxgtk2.8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
wxPython/wx/tools/Editra/src/extern/pygments/lexers/hdl.py
1
 
# -*- coding: utf-8 -*-
2
 
"""
3
 
    pygments.lexers.hdl
4
 
    ~~~~~~~~~~~~~~~~~~~
5
 
 
6
 
    Lexers for hardware descriptor languages.
7
 
 
8
 
    :copyright: Copyright 2010 by the Pygments team, see AUTHORS.
9
 
    :license: BSD, see LICENSE for details.
10
 
"""
11
 
 
12
 
import re
13
 
 
14
 
from pygments.lexer import RegexLexer, include, bygroups
15
 
from pygments.token import \
16
 
     Text, Comment, Operator, Keyword, Name, String, Number, Punctuation, \
17
 
     Error
18
 
 
19
 
__all__ = ['VerilogLexer']
20
 
 
21
 
 
22
 
class VerilogLexer(RegexLexer):
23
 
    """
24
 
    For verilog source code with preprocessor directives.
25
 
 
26
 
    *New in Pygments 1.4.*
27
 
    """
28
 
    name = 'verilog'
29
 
    aliases = ['v']
30
 
    filenames = ['*.v', '*.sv']
31
 
    mimetypes = ['text/x-verilog']
32
 
 
33
 
    #: optional Comment or Whitespace
34
 
    _ws = r'(?:\s|//.*?\n|/[*].*?[*]/)+'
35
 
 
36
 
    tokens = {
37
 
        'root': [
38
 
            (r'^\s*`define', Comment.Preproc, 'macro'),
39
 
            (r'\n', Text),
40
 
            (r'\s+', Text),
41
 
            (r'\\\n', Text), # line continuation
42
 
            (r'/(\\\n)?/(\n|(.|\n)*?[^\\]\n)', Comment.Single),
43
 
            (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
44
 
            (r'[{}#@]', Punctuation),
45
 
            (r'L?"', String, 'string'),
46
 
            (r"L?'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\'\n])'", String.Char),
47
 
            (r'(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[lL]?', Number.Float),
48
 
            (r'(\d+\.\d*|\.\d+|\d+[fF])[fF]?', Number.Float),
49
 
            (r'([0-9]+)|(\'h)[0-9a-fA-F]+', Number.Hex),
50
 
            (r'([0-9]+)|(\'b)[0-1]+', Number.Hex),   # should be binary
51
 
            (r'([0-9]+)|(\'d)[0-9]+', Number.Integer),
52
 
            (r'([0-9]+)|(\'o)[0-7]+', Number.Oct),
53
 
            (r'\'[01xz]', Number),
54
 
            (r'\d+[Ll]?', Number.Integer),
55
 
            (r'\*/', Error),
56
 
            (r'[~!%^&*+=|?:<>/-]', Operator),
57
 
            (r'[()\[\],.;\']', Punctuation),
58
 
            (r'`[a-zA-Z_][a-zA-Z0-9_]*', Name.Constant),
59
 
 
60
 
            (r'^\s*(package)(\s+)', bygroups(Keyword.Namespace, Text)),
61
 
            (r'^\s*(import)(\s+)', bygroups(Keyword.Namespace, Text), 'import'),
62
 
 
63
 
            (r'(always|always_comb|always_ff|always_latch|and|assign|automatic|'
64
 
             r'begin|break|buf|bufif0|bufif1|case|casex|casez|cmos|const|'
65
 
             r'continue|deassign|default|defparam|disable|do|edge|else|end|endcase|'
66
 
             r'endfunction|endgenerate|endmodule|endpackage|endprimitive|endspecify|'
67
 
             r'endtable|endtask|enum|event|final|for|force|forever|fork|function|'
68
 
             r'generate|genvar|highz0|highz1|if|initial|inout|input|'
69
 
             r'integer|join|large|localparam|macromodule|medium|module|'
70
 
             r'nand|negedge|nmos|nor|not|notif0|notif1|or|output|packed|'
71
 
             r'parameter|pmos|posedge|primitive|pull0|pull1|pulldown|pullup|rcmos|'
72
 
             r'ref|release|repeat|return|rnmos|rpmos|rtran|rtranif0|'
73
 
             r'rtranif1|scalared|signed|small|specify|specparam|strength|'
74
 
             r'string|strong0|strong1|struct|table|task|'
75
 
             r'tran|tranif0|tranif1|type|typedef|'
76
 
             r'unsigned|var|vectored|void|wait|weak0|weak1|while|'
77
 
             r'xnor|xor)\b', Keyword),
78
 
 
79
 
            (r'(`accelerate|`autoexpand_vectornets|`celldefine|`default_nettype|'
80
 
             r'`else|`elsif|`endcelldefine|`endif|`endprotect|`endprotected|'
81
 
             r'`expand_vectornets|`ifdef|`ifndef|`include|`noaccelerate|`noexpand_vectornets|'
82
 
             r'`noremove_gatenames|`noremove_netnames|`nounconnected_drive|'
83
 
             r'`protect|`protected|`remove_gatenames|`remove_netnames|`resetall|'
84
 
             r'`timescale|`unconnected_drive|`undef)\b', Comment.Preproc),
85
 
 
86
 
            (r'(\$bits|\$bitstoreal|\$bitstoshortreal|\$countdrivers|\$display|\$fclose|'
87
 
             r'\$fdisplay|\$finish|\$floor|\$fmonitor|\$fopen|\$fstrobe|\$fwrite|'
88
 
             r'\$getpattern|\$history|\$incsave|\$input|\$itor|\$key|\$list|\$log|'
89
 
             r'\$monitor|\$monitoroff|\$monitoron|\$nokey|\$nolog|\$printtimescale|'
90
 
             r'\$random|\$readmemb|\$readmemh|\$realtime|\$realtobits|\$reset|\$reset_count|'
91
 
             r'\$reset_value|\$restart|\$rtoi|\$save|\$scale|\$scope|\$shortrealtobits|'
92
 
             r'\$showscopes|\$showvariables|\$showvars|\$sreadmemb|\$sreadmemh|'
93
 
             r'\$stime|\$stop|\$strobe|\$time|\$timeformat|\$write)\b', Name.Builtin),
94
 
 
95
 
            (r'(class)(\s+)', bygroups(Keyword, Text), 'classname'),
96
 
            (r'(byte|shortint|int|longint|interger|time|'
97
 
             r'bit|logic|reg|'
98
 
             r'supply0|supply1|tri|triand|trior|tri0|tri1|trireg|uwire|wire|wand|wor'
99
 
             r'shortreal|real|realtime)\b', Keyword.Type),
100
 
            ('[a-zA-Z_][a-zA-Z0-9_]*:(?!:)', Name.Label),
101
 
            ('[a-zA-Z_][a-zA-Z0-9_]*', Name),
102
 
        ],
103
 
        'classname': [
104
 
            (r'[a-zA-Z_][a-zA-Z0-9_]*', Name.Class, '#pop'),
105
 
        ],
106
 
        'string': [
107
 
            (r'"', String, '#pop'),
108
 
            (r'\\([\\abfnrtv"\']|x[a-fA-F0-9]{2,4}|[0-7]{1,3})', String.Escape),
109
 
            (r'[^\\"\n]+', String), # all other characters
110
 
            (r'\\\n', String), # line continuation
111
 
            (r'\\', String), # stray backslash
112
 
        ],
113
 
        'macro': [
114
 
            (r'[^/\n]+', Comment.Preproc),
115
 
            (r'/[*](.|\n)*?[*]/', Comment.Multiline),
116
 
            (r'//.*?\n', Comment.Single, '#pop'),
117
 
            (r'/', Comment.Preproc),
118
 
            (r'(?<=\\)\n', Comment.Preproc),
119
 
            (r'\n', Comment.Preproc, '#pop'),
120
 
        ],
121
 
        'import': [
122
 
            (r'[a-zA-Z0-9_:]+\*?', Name.Namespace, '#pop')
123
 
        ]
124
 
    }
125
 
 
126
 
    def get_tokens_unprocessed(self, text):
127
 
        for index, token, value in \
128
 
            RegexLexer.get_tokens_unprocessed(self, text):
129
 
            # Convention: mark all upper case names as constants
130
 
            if token is Name:
131
 
                if value.isupper():
132
 
                    token = Name.Constant
133
 
            yield index, token, value
134
 
 
135