pmacs3/mode/java.py

import mode, tab
import context
from lex import Grammar, PatternRule, RegionRule, PatternMatchRule
from mode.python import StringGrammar2
from parse import Any, And, Or, Optional, Name, Match, Matchs
from etags import TagManager

class CommentGrammar(Grammar):
    rules = [
        PatternMatchRule(r'x', r'(@[a-z]+)( +)([^ ]+)', r'javadoc', r'spaces', r'javaname'),
        PatternRule(r"javadoc", r"@[a-z]+"),
        PatternRule(r"data", r"(?:[^@*]|\*(?!/))+"),
    ]

chr1 = '[a-zA-Z_]'
chr2 = '[a-zA-Z0-9_]'
word1 = chr1 + chr2 + '*'
word2 = '(?:' + word1 + r'\.' + ')*' + word1

class JavaGrammar(Grammar):
    rules = [
        PatternRule(r"spaces", r" +"),
        PatternMatchRule('x', r'(import)( +)(' + word2 + '(?:\.\*)?)', 'keyword', 'spaces', 'import'),
        PatternMatchRule('x', r'(package)( +)(' + word2 + ')', 'keyword', 'spaces', 'package'),
        PatternMatchRule('x', r'(class)( +)(' + word1 + ')', 'keyword', 'spaces', 'java_class'),
        PatternMatchRule('x', '(new)( +)(' + word2 + ')', 'keyword', 'spaces', 'java_class'),

        RegionRule(r'java_comment', '/\*', CommentGrammar, '\*/'),
        PatternRule(r'comment', r'//.*$'),

        PatternRule(r'keyword', r"(?:abstract|assert|break|case|catch|class|continue|default|do|else|extends|finally|final|for|if|implements|import|instanceof|interface|native|new|package|private|protected|public|return|static|switch|super|synchronized|threadsafe|throws|throw|transient|try|while)(?![a-zA-Z_])"),
        PatternRule(r'java_label', r'[a-zA-Z_][a-zA-Z0-9_]*(?=:)'),

        PatternMatchRule('x', '(' + word2 + ')((?:\[\])?)( +)(' + word1 + ')( *)(\()',
                         'java_type', 'delimiter', 'spaces', 'java_function', 'spaces', 'delimiter'),
        PatternMatchRule('x', '(' + word2 + ')((?:\[\])?)( +)(' + word1 + ')(?! *\()',
                         'java_type', 'delimiter', 'spaces', 'identifier'),

        PatternRule(r'java_builtin', r"(?:null|true|false|this)"),
        PatternRule(r'identifier', word1),
        PatternRule(r"operator", r"\+=|-=|\*=|/=|//=|%=|&=\|\^=|>>=|<<=|\*\*="),
        PatternRule(r'operator', r"\+|<>|<<|<=|<|-|>>|>=|>|\*\*|&|\*|\||/|\^|==|//|~|!=|%"),

        PatternRule(r"delimiter", r"->|\.|\(|\)|\[|\]|{|}|@|,|:|`|;|=|\?"),

        PatternRule(r"integer", r"(?:0(?![x0-9])|[1-9][0-9]*|0[0-7]+|0[xX][0-9a-fA-F]+)[lL]?"),
        PatternRule(r"float", r"[0-9]+\.[0-9]*|\.[0-9]+|(?:[0-9]|[0-9]+\.[0-9]*|\.[0-9]+)[eE][\+-]?[0-9]+"),
        RegionRule(r'string', '"', StringGrammar2, '"'),
        PatternRule(r'java_char', r"'.'|'\\.'|'\\[0-7]{3}'"),
        PatternRule(r"eol", r"\n$"),
    ]


CLASS_MATCH = And(Optional(Name('spaces')), 
                  Matchs('keyword', ('public', 'protected', 'private')),
                  Name('spaces'),
                  Match('keyword', 'class'),
                  Name('spaces'),
                  Name('java_class'))
CLASS_OFFSET = 1
METHOD_MATCH = And(Optional(Name('spaces')), 
                   Matchs('keyword', ('public', 'protected', 'private')),
                   Name('spaces'),
                   Optional(And(Match('keyword', 'static'), Name('spaces'))),
                   Any(),
                   Name('spaces'),
                   Name('java_function'),
                   Optional(Name('spaces')),
                   Match('delimiter', '('))
METHOD_OFFSET = 2

class JavaTabber2(tab.StackTabber2):
    open_tokens        = {'delimiter': {'{': '}', '(': ')', '[': ']'}}
    close_tokens       = {'delimiter': {'}': '{', ')': '(', ']': '['}}
    control_tokens     = {'keyword': {'if': 1, 'else': 1, 'while': 1, 'do': 1, 'for': 1}}
    end_at_eof         = False
    end_at_tokens      = {'delimiter': {';': 1}}
    nocontinue_tokens  = {'delimiter': {';': 1},
                          'java_comment.start': 1,
                          'java_comment.data': 1,
                          'java_comment.end': 1}
    start_free_tokens  = {'string.start': 'string.end'}
    end_free_tokens    = {'string.end': 'string.start'}
    def is_base(self, y): return y == 0
    def _is_indent(self, t): return t.name == 'spaces'
    def _is_ignored(self, t):
        return t.fqname() in ('spaces', 'eol', 'comment', 'comment.start',
                              'comment.data', 'comment.null', 'comment.end')

class JavaContext(context.Context):
    class_match   = CLASS_MATCH
    class_offset  = CLASS_OFFSET
    method_match  = METHOD_MATCH
    method_offset = METHOD_OFFSET
    def _regen_stack(self, y):
        if y > 0 and self.namelines[y - 1][1]:
            return list(self.namelines[y - 1][1])
        else:
            return []

    def _build_name_map(self, y1, y2, last, curr, stack):
        highlights = self.mode.window.get_highlighter()

        i = y1
        while i < y2:
            if not stack: curr = None
            tokens  = highlights.tokens[i]

            result = self.class_match.match(tokens)
            if result: curr = tokens[result[0] - self.class_offset].string
            result = self.method_match.match(tokens)
            if result: curr = tokens[result[0] - self.method_offset].string

            if curr is not None: self.names.setdefault(curr, i)

            for t in tokens:
                if t.match('delimiter', '{'):
                    stack.append(curr)
                elif t.match('delimiter', '}'):
                    if stack: stack.pop(-1)
                    if stack:
                        curr = stack[-1]
                    else:
                        curr = None

            if curr: self.namelines[i] = (curr, tuple(stack))
            i += 1


class JavaTagManager(TagManager):
    lang  = 'Java'
    exts  = set(('.java',))


class Java(mode.Fundamental):
    name        = 'Java'
    extensions  = ['.java']
    tabbercls   = JavaTabber2
    tagcls      = JavaTagManager
    grammar     = JavaGrammar
    commentc    = '//'
    opentokens  = ('delimiter',)
    opentags    = {'(': ')', '[': ']', '{': '}'}
    closetokens = ('delimiter',)
    closetags   = {')': '(', ']': '[', '}': '{'}
    colors      = {
        'java_comment.start':    ('red', 'default', 'bold'),
        'java_comment.end':      ('red', 'default', 'bold'),
        'java_comment.javadoc':  ('magenta', 'default', 'bold'),
        'java_comment.javaname': ('yellow', 'default', 'bold'),
        'java_comment.data':     ('red', 'default', 'bold'),
        'java_comment.null':     ('red', 'default', 'bold'),
        'import':                ('blue', 'default', 'bold'),
        'java_class':            ('green', 'default', 'bold'),
        'java_label':            ('magenta', 'default', 'bold'),
        'java_builtin':          ('magenta', 'default', 'bold'),
        'java_char':             ('green', 'default', 'bold'),
        'java_function':         ('blue', 'default', 'bold'),
        'java_type':             ('magenta', 'default', 'bold'),
    }

    _bindings = {
        'close-paren':   (')',),
        'close-brace':   ('}',),
        'close-bracket': (']',),
    }

    format = "%(flag)s  %(bname)-18s  (%(mname)s)  %(indent)s  %(cursor)s/%(mark)s  %(perc)s  [%(func)s]"

    def __init__(self, w):
        mode.Fundamental.__init__(self, w)
        self.context = JavaContext(self)

    def get_status_names(self):
        names = mode.Fundamental.get_status_names(self)
        c = self.window.logical_cursor()
        names['func'] = self.get_line_function(c.y)
        return names
    def get_functions(self):
        return self.context.get_names()
    def get_function_names(self):
        return self.context.get_name_list()
    def get_line_function(self, y):
        return self.context.get_line_name(y)

install = Java.install