#!/usr/bin/env python

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

# java2python.lang.base -> lexer and parser support classes.

#

# This module provides the following:

#

# * `Tokens`

#

# This class is used to create the single `token` instance in this

# module. It is used to map between parser tokens and their ids and

# vice-versa.

# ANTLR notes:

#

# recognizers: lexer, parser, treeparser

# streams: string, file name, file handle

#

# Parsers use TokenStreams (CommonTokenStream or TokenRewriteStream)

#

# Tree parsers use TreeNodeStream (CommonTreeNodeStream)

#

# Lexers emit Token objects (buffered in TokenStream objects)

#

# Parsers build trees if their output is AST.

#

# token types: CommonToken and ClassicToken. Our tree adaptor

# creates LocalTree instances instead.

#

# Tree (CommonTree) wraps Token objects. We provide extra functionality via

# the LocalTree class.

#

# TreeAdaptor (CommonTreeAdaptor) is used by the parser to create

# Tree objects. Our adaptor, TreeAdaptor, creates the LocalTree

# instances.

#

from io import StringIO

from antlr4 import CommonTokenStream as TokenStream

from java2python.lib import colors

class Tokens(object):

""" Tokens -> simplifies token id-name and name-id mapping. """

def __init__(self):

self.cache, self.parserModule = {}, None

def __getattr__(self, name):

""" tokenname -> tokenvalue """

return getattr(self.module, name)

@property

def commentTypes(self):

""" Well-known comment types. """

mod = self.module

return (mod.COMMENT, mod.LINE_COMMENT, mod.JAVADOC_COMMENT, )

@property

def map(self):

""" (tokentype, tokenname) mapping as a dictionary """

cache, module = self.cache, self.module

if cache:

return cache

mapping = [(getattr(module, k, None), k) for k in module.tokenNames]

mapping = [(k, v) for k, v in mapping if k is not None]

cache.update(mapping)

return cache

@property

def methodTypes(self):

""" Well-known method types. """

mod = self.module

return (mod.VOID_METHOD_DECL, mod.FUNCTION_METHOD_DECL, )

@property

def primitiveTypeNames(self):

""" Type name of well-known primitive types """

return ('bool', 'str', 'int', 'long', 'float', )

@property

def module(self):

""" Provides lazy import to the parser module. """

module = self.parserModule

if module:

return module

import java2python.lang.JavaParser as module

self.parserModule = module

return module

@staticmethod

def title(name):

""" Returns a nice title given a token type name. """

return ''.join(part.title() for part in name.split('_'))

## sometimes you really do only need one.

tokens = Tokens()