import color, mode2, tab2
from lex3 import Grammar, PatternRule, RegionRule
from mode_python import StringGrammar

# this might not be complete...
# see http://gcc.gnu.org/onlinedocs/gcc-2.95.3/cpp_3.html#SEC44
class MacroGrammar(Grammar):
    rules = [
        PatternRule('name', r'(?:(?<=#define )) *[a-zA-Z_][a-zA-Z0-9_]*'),

        PatternRule(r"unop", r"\+=|-=|\*=|/=|//=|%=|&=\|\^=|>>=|<<=|\*\*="),
        PatternRule(r'binop', 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', '"', StringGrammar, '"'),
        PatternRule(r'char', r"'.'|'\\.'|'\\[0-7]{3}'"),

        PatternRule(r"continued", r"\\\n$"),
    ]

class CGrammar(Grammar):
    rules = [
        PatternRule(r'include', r'#include(?!=[a-zA-Z0-9_])'),
        PatternRule(r'header', r'<[-A-Za-z/0-9_\.]+>|"[-A-Za-z/0-9_\.]+"'),
        RegionRule(r'macrocomment', r'#if +(?:0|NULL|FALSE)', Grammar, r'#endif'),
        RegionRule(r'macro', r'#(?:assert|cpu|define|elif|else|endif|error|ident|ifdef|ifndef|if|import|include_next|line|machine|pragma|pragma_once|system|unassert|undef|warning)(?!=[a-zA-Z0-9_])', MacroGrammar, r'\n$'),

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

        PatternRule(r'keyword', r"(?:auto|break|case|char|const|continue|default|double|do|else|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while)(?![a-zA-z_])"),
        PatternRule(r'label', r'[a-zA-Z_][a-zA-Z0-9_]*(?=:)'),
        PatternRule(r'structname', r'(?<=struct ) *[a-zA-Z_][a-zA-Z0-9_]*'),
        PatternRule(r'enumname', r'(?<=enum ) *[a-zA-Z_][a-zA-Z0-9_]*'),
        PatternRule(r'function', r'[a-zA-Z_][a-zA-Z0-9_]*(?= *\()'),

        PatternRule(r'builtin', r"(?:NULL|TRUE|FALSE)"),
        PatternRule(r'identifier', r"[a-zA-Z_][a-zA-Z0-9_]*"),
        PatternRule(r"unop", r"\+=|-=|\*=|/=|//=|%=|&=\|\^=|>>=|<<=|\*\*="),
        PatternRule(r'binop', r"\+|<>|<<|<=|<|-|>>|>=|>|\*\*|&|\*|\||/|\^|==|//|~|!=|%"),

        # this is sketchy as hell
        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', '"', StringGrammar, '"'),
        PatternRule(r'char', r"'.'|'\\.'|'\\[0-7]{3}'"),
        PatternRule(r"eol", r"\n$"),
    ]

class CTabber(tab2.StackTabber):
    def is_base(self, y):
        if y == 0:
            return True
        highlighter = self.mode.window.buffer.highlights[self.mode.name()]
        if not highlighter.tokens[y]:
            return False

        # this assumes that people aren't gonna use these macros inside of
        # blocks, which is probably ok.
        t0 = highlighter.tokens[y][0]
        if t0.name == 'macro.start' and t0.string in ('#define', '#include'):
            return True
        
        # detecting function declarations is annoying; this assumes that people
        # won't put a variable type and name on different lines, but that they
        # might do that for function return type and name.
        #
        # unfortunately, valid function return types might include any of the
        # four types of tokens below
        decl = False
        for t in highlighter.tokens[y]:
            if t.name in ('keyword', 'identifier', 'structname', 'enumname'):
                decl = True
                continue
            if decl and t.name == 'function':
                break
            else:
                decl = False
                break
        if decl:
            return True

        return False
        
    def _handle_open_token(self, currlvl, y, i):
        self._opt_pop('cont')
        token = self.get_token(y, i)
        if token.string == '{':
            self._opt_pop('cond')
        currlvl = tab2.StackTabber._handle_open_token(self, currlvl, y, i)
        return currlvl
    def _handle_close_token(self, currlvl, y, i):
        self._opt_pop('cont')
        currlvl = tab2.StackTabber._handle_close_token(self, currlvl, y, i)
        token = self.get_token(y, i)
        if self.is_rightmost_token(y, i):
            if token.string == '}':
                self._opt_pop('cond')
                self._opt_pop('cont')
            elif self._peek_name() == 'cond':
                pass
            else:
                self._opt_append('cont', currlvl + 4)
        return currlvl
    def _handle_other_token(self, currlvl, y, i):
        token  = self.get_token(y, i)
        fqname = token.fqname()
        if fqname == 'delimiter' and token.string == ';':
            self._opt_pop('cond')
            self._opt_pop('cont')
            self._opt_pop('cond')

        elif fqname == 'keyword':
            if token.string in ('do', 'else', 'for', 'if', 'while'):
                self._append('cond', currlvl + 4)
            elif token.string == 'break':
                self._opt_pop('case', 'while', 'for')
            elif token.string == 'continue':
                self._opt_pop('while', 'for')
            elif token.string == 'case':
                self._opt_pop('case')
                currlvl = self.get_curr_level()
                self._opt_append('case', currlvl + 4)

        elif fqname == 'string.start':
            self._opt_append('string', None)
        elif fqname == 'string.end':
            self._opt_pop('string')
            if self.is_rightmost_token(y, i):
                self._opt_append('cont', currlvl + 4)

        # TODO: this could be a lot better
        elif fqname == 'macro':
            currlvl = 0
        elif fqname.startswith('macro.start'):
            self._opt_append('macro', None)
            currlvl = 0
        elif fqname.startswith('macro.end'):
            self._opt_pop('macro', None)                               

        elif fqname.startswith('macroblock.start'):
            self._opt_append('macroblock', None)                               
            currlvl = 0
        elif fqname.startswith('macroblock.end'):
            self._opt_pop('macroblock', None)                               

        if self.is_rightmost_token(y, i):
            if self._has_markers() and self._peek_name() == 'cond':
                pass
            elif(not fqname.startswith('string') and
                 not fqname.startswith('comment') and
                 not fqname.startswith('macro') and
                 not fqname == 'delimiter' and
                 not fqname == 'header' and
                 not fqname == 'null' and
                 not fqname == 'eol' and
                 token.string not in ('}', ';', '(', '{', '[', ',')):
                self._opt_append('cont', currlvl + 4)
        return currlvl

class C(mode2.Fundamental):
    tabbercls  = CTabber
    grammar    = CGrammar
    opentokens  = ('delimiter',)
    opentags   = {'(': ')', '[': ']', '{': '}'}
    closetokens = ('delimiter',)
    closetags  = {')': '(', ']': '[', '}': '{'}
    def __init__(self, w):
        mode2.Fundamental.__init__(self, w)
        self.add_bindings('close-paren', (')',))
        self.add_bindings('close-brace', ('}',))
        self.add_bindings('close-bracket', (']',))
        self.colors = {
            'macrocomment.start': color.build('red', 'default'),
            'macrocomment.null':  color.build('red', 'default'),
            'macrocomment.end':   color.build('red', 'default'),
            'comment':            color.build('red', 'default'),
            'comment.start':      color.build('red', 'default'),
            'comment.end':        color.build('red', 'default'),
            'comment.null':       color.build('red', 'default'),

            'include': color.build('blue', 'default'),
            'header':  color.build('green', 'default'),

            'macro':                color.build('blue', 'default'),
            'macro.start':          color.build('blue', 'default'),
            'macro.name':           color.build('yellow', 'default'),
            'macro.null':           color.build('magenta', 'default'),
            #'macro.null':           color.build('default', 'default'),
            'macro.continued':      color.build('red', 'default'),
            'macro.delimiter':      color.build('default', 'default'),
            'macro.integer':        color.build('green', 'default'),
            'macro.float':          color.build('green', 'default'),
            'macro.char':           color.build('green', 'default'),
            'macro.string.start':   color.build('green', 'default'),
            'macro.string.escaped': color.build('magenta', 'default'),
            'macro.string.octal':   color.build('magenta', 'default'),
            #'macro.string.escaped': color.build('default', 'default'),
            #'macro.string.octal':   color.build('default', 'default'),
            'macro.string.null':    color.build('green', 'default'),
            'macro.string.end':     color.build('green', 'default'),
            'macro.end':            color.build('magenta', 'default'),
            #'macro.end':            color.build('default', 'default'),

            'label':      color.build('magenta', 'default'),
            'keyword':    color.build('cyan', 'default'),
            'function':   color.build('blue', 'default'),
            'builtin':    color.build('magenta', 'default'),
            'structname': color.build('yellow', 'default'),
            'enumname':   color.build('yellow', 'default'),

            'char':           color.build('green', 'default'),
            'string.start':   color.build('green', 'default'),
            'string.octal':   color.build('green', 'default'),
            'string.escaped': color.build('green', 'default'),
            'string.null':    color.build('green', 'default'),
            'string.end':     color.build('green', 'default'),
            'integer':        color.build('green', 'default'),
            'float':          color.build('green', 'default'),

            'bizzaro':        color.build('magenta', 'green'),
        }
    def name(self):
        return "C"