Esempio n. 1
0
    def tokenize(self, sourcecode, filesource='<stdin>'):
        "Tokenize the given string of source code."
        self.errmsg = NCPTL_Error(filesource)

        # Keep track of all the comments we've encountered by storing
        # a mapping from line number to comment (including the initial
        # hash character).
        self.line2comment = {}

        # Initialize the lexer.
        lex.lex(module=self)

        # Repeatedly invoke the lexer and return all of the tokens it produces.
        self.lineno = 1
        lex.input(sourcecode)
        self.toklist = []
        while 1:
            # Acquire the next token and assign it a line number if necessary.
            token = lex.token()
            if not token:
                break
            if token.lineno < self.lineno:
                token.lineno = self.lineno

            # Hack: Disambiguate op_mult and star on the parser's behalf.
            if token.type in ["comma", "rparen"]:
                try:
                    if self.toklist[-1].type == "op_mult":
                        self.toklist[-1].type = "star"
                except IndexError:
                    pass

            # We now have one more valid token.
            self.toklist.append(token)
        return self.toklist
Esempio n. 2
0
def run_lexer(): 
    tokens_neglect=(
    'OBRACK','CBRACK','COMMA','SHARP',
    'LBRACE','RBRACE'
    )  
    st=[]
    lb={}
    fpath = "test.deout" 
    f = open(fpath,"r") 
    file = f.read() 
    lex.input(file)
    f.close()
    i=0
    flag=0
    while 1:
        token = lex.token()       # Get a token 
        if not token: break       # No more tokens
        if token.type=='INSTRUCTION': 
            st.append([token.value]) 
            flag=1
            i+=1
        elif token.type=='NEWLINE':
            if flag==1:
                flag=0 
        elif token.type=='LABEL':
            lb[token.value]=i
        elif token.type == 'NUMBER' or token.type == 'REGISTER' \
            or token.type == 'IDENTIFIER': 
            if flag==1:
                st[-1].append(token.value)
        elif token.type in tokens_neglect:
            pass
        else :
            pass 
    return st,lb
Esempio n. 3
0
def _internal_tests():
    tests = [
        ("(", "LPAREN", "("),
        (")", "RPAREN", ")"),
        ("1234", "INT", 1234),
        ("-1234", "INT", -1234),
        ("1.", "FLOAT", 1.0),
        ("-1.", "FLOAT", -1.0),
        ("0.1", "FLOAT", 0.1),
        ("0.1e-1", "FLOAT", 0.1e-1),
        (r'""', "STRING", ""),
        (r'"foo"', "STRING", "foo"),
        (r'"\""', "STRING", '"'),
        (r'"\n\t\"\\"', "STRING", '\n\t"\\'),
        ("#1.0\n(", "LPAREN", "("),
        ("\n\n(", "LPAREN", "("),
        ("&1", "SYMBOL", "&1"),
        ("-", "SYMBOL", "-"),
    ]
    for i in tests:
        (s, type, value) = i
        lex.input(s)
        tok = lex.token()
        try:
            assert tok.type == type
            assert tok.value == value
            assert not lex.token()
        except AssertionError, e:
            sys.stderr.write("squeamish: test failed: %s led to %s\n" % (` i `, tok))
            raise AssertionError
Esempio n. 4
0
def test_lex():
    import sys
    prog = sys.stdin.read()
    lex.input(prog)
    while True:
        token = lex.token()
        if not token: break
        print "(%s, '%s', %d)" % (token.type, token.value, token.lineno)
Esempio n. 5
0
def test_lex():
    import sys
    prog = sys.stdin.read()
    lex.input(prog)
    while True:
        token = lex.token()
        if not token: break
        print "(%s, '%s', %d)" % (token.type, token.value, token.lineno)
Esempio n. 6
0
def token_list(rnc):
    lex.lex()
    lex.input(rnc)
    ts = []
    while 1:
        t = lex.token()
        if t is None:
            break
        ts.append(t)
    return ts
Esempio n. 7
0
def test_lex():
    import sys
    file = open(sys.argv[1])
    lines = file.readlines()
    file.close()
    prog = "".join(lines)
    lex.input(prog)
    while True:
        token = lex.token()
        if not token: break
        print "(%s, '%s', %d)" % (token.type, token.value, token.lineno)
Esempio n. 8
0
def lexTheCode(code):

    lex.input(code)

    # DEBUG OUTPUT
    print "----------------"
    print "TOKENS:"
    print "----------------"
    while True:
         tok = lex.token()
         if not tok: break
         print tok
Esempio n. 9
0
def lexTheCode(code):

    lex.input(code)

    # DEBUG OUTPUT
    print "----------------"
    print "TOKENS:"
    print "----------------"
    while True:
        tok = lex.token()
        if not tok: break
        print tok
Esempio n. 10
0
    def lexer(self, data):
        """ helper method to control lexer process. Return the tokenize
            data string.
        """

        lex.input(data)
        tokens = []
        while 1:
            tok = lex.token()
            if not tok: break
            tokens.append(tok)

        return tokens
Esempio n. 11
0
    def lexer(self, data):
        """ helper method to control lexer process. Return the tokenize
            data string.
        """

        lex.input(data)
        tokens = []
        while 1:
            tok = lex.token()
            if not tok: break
            tokens.append(tok)

        return tokens
Esempio n. 12
0
def _external_tests():
    while 1:
        try:
            s = raw_input("squeamish> ")
        except EOFError:
            break
        if not s:
            continue
        lex.input(s)
        while 1:
            tok = lex.token()
            if tok:
                print ` tok `
            else:
                break
Esempio n. 13
0
def run_lexer():
    """This is just a debugging function that prints out a list of
    tokens, it's not actually called by the compiler or anything."""
    
    import sys
    file = open(sys.argv[1])
    lines = file.readlines()
    file.close()
    strings = ""
    for i in lines:
        strings += i
    lex.input(strings)
    while 1:
        token = lex.token()       # Get a token
        if not token: break        # No more tokens
        print "(%s,'%s',%d)" % (token.type, token.value, token.lineno)
Esempio n. 14
0
def run_lexer():
    """This is just a debugging function that prints out a list of
    tokens, it's not actually called by the compiler or anything."""

    import sys
    file = open(sys.argv[1])
    lines = file.readlines()
    file.close()
    strings = ""
    for i in lines:
        strings += i
    lex.input(strings)
    while 1:
        token = lex.token()  # Get a token
        if not token: break  # No more tokens
        print "(%s,'%s',%d)" % (token.type, token.value, token.lineno)
Esempio n. 15
0
def get_tokens(string):
    tokens = lex.input(s)
    l = []
    while 1:
        token = lex.token()
        if not token: break
        l.append(token)
    return l
Esempio n. 16
0
def get_tokens(String):
    tokens = lex.input(String) # la s ne plantait pas et il prenait la valeur de la main !!! quelle blague !!!
    l = []
    while 1:
        token = lex.token()
        if not token: break
        l.append(token)
    return l
Esempio n. 17
0
def compute_string(s, debug=False):
    lex.input(s)
    
    if debug:
        while 1:
            tok = lex.token()
            if not tok: break
            if tok.type != 'NEWLINE':
                print "line %d:%s(%s)"%(tok.lineno, tok.type, tok.value)
            else:
                print("line %d:%s(\\n)"%(tok.lineno, tok.type))
    
    result = yacc.parse(s) #, debug=2)
    print result.__class__
    print(explore(result,0))
    print("------------------ End Explore ------------------")
    r = compute(result)
    print("\nResult = %s of type %s" % (r, r.__class__))
    print("\nListing vars")
    for k in vars:
        print("%s:%s:%s" % (k, vars[k].__class__, vars[k]))
    return r
Esempio n. 18
0
def run_lexer(strings): 
    lex.input(strings)
    while 1:
        token = lex.token()       # Get a token
        if not token: break        # No more tokens 
Esempio n. 19
0
    _lineno = 1
    while 1:
        try:
            s = raw_input('ompc> ') + '\n'
        except EOFError:
            break

        # preprocess, the returned values are strip of whitespace, and
        # the optional coment is returned
        s, com = _ompc_preprocess(s)
        # if s is None a continuation was requested, submit the next line
        if s is None:
            continue

        # if s is empty don't do anything
        if not s:
            continue

        if LEXDEBUG:
            # Tokenize
            lex.input(s)
            while 1:
                tok = lex.token()
                if not tok: break  # No more input
                print tok
                print _errors
                _errors = []

        yacc.myparse(s)
        print
Esempio n. 20
0
    t.lexer.lineno += len(t.value)

def t_error(t):
    raise SyntaxError("syntax error on line %d near '%s'\n" % (t.lineno, t.value))

def t_FLOAT(t):
    r'\d+\.\d+'
    t.value = float(t.value)
    return t

def t_NUMBER(t):
    r'\d+'
    t.value = float(t.value)
    return t

def t_ID(t):
    r'[a-zA-Z_][a-zA-Z_0-9]*'
    t.type = reserved.get(t.value,'ID')   
    # t.value = (t.value, symbol_lookup(t.value))
    return t

if __name__ == '__main__':
    lexer = lex.lex()
    lex.input(sys.stdin.read())
    while True:
        t = lex.token()
        if not t:
            break
        print t.value, '\t:\t', t.type

Esempio n. 21
0
def t_NUMERO(t):
    r'\d+'
    t.value = int(t.value)
    return t


def t_error(t):
    print("Illegal character '%s'" % t.value[0])
    t.lexer.skip(1)


def leerArchivo(entrada):
    return open(entrada, "r")


def remplazar(texto):
    texto = texto.replace("_", "_SUBLINE_")
    texto = texto.replace("-", "_")
    return texto


lex.lex()
for i in leerArchivo(
        input("introduzca el nombre del archivo con la extension .txt\n")):
    lex.input(remplazar(i))
    while True:
        tok = lex.token()
        if not tok: break
        print(str(tok.value) + " - " + str(tok.type))
Esempio n. 22
0
t_ignore  = ' \t\r'

# Error handling rule
def t_error(t):
    #print "Illegal character '%s' on line %d" % (t.value[0], t.lineno)
    t.value = t.value[0]
    t.skip(1)
    return t
    
# Build the lexer
lexer = lex.lex(optimize=1)

def get_lexer():
    global lexer
    lexer = lex.lex(optimize=1)
    return lexer

# debugging
if __name__ == '__main__': #pragma: no cover
    # Test it out
    data = open(sys.argv[1],"r").read()

    # Give the lexer some input
    lex.input(data)

    # Tokenize
    while 1:
        tok = lex.token()
        if not tok: break      # No more input
        print tok
Esempio n. 23
0
                      (t.lineno, t.value))


def t_FLOAT(t):
    r'\d+\.\d+'
    t.value = float(t.value)
    return t


def t_NUMBER(t):
    r'\d+'
    t.value = float(t.value)
    return t


def t_ID(t):
    r'[a-zA-Z_][a-zA-Z_0-9]*'
    t.type = reserved.get(t.value, 'ID')
    # t.value = (t.value, symbol_lookup(t.value))
    return t


if __name__ == '__main__':
    lexer = lex.lex()
    lex.input(sys.stdin.read())
    while True:
        t = lex.token()
        if not t:
            break
        print t.value, '\t:\t', t.type
Esempio n. 24
0
import lex

tokens = ["a","b","c","d"]

t_a = r'a'
t_b = r'b'
t_c = r'c'
t_d = r'd'


# Error handling rule
def t_error(t):
    print("Hay un caracter no valido")
    t.lexer.skip(1)

lex.lex() # Build the lexer

lex.input("abcx")
while True:
    tok = lex.token()
    if not tok: break
    print (str(tok.value))
Esempio n. 25
0
t_CHAR = r'\'(\\.|[^\\\'])\''

t_LPAREN = r'\('
t_RPAREN = r'\)'
t_LBRACKET = r'\['
t_RBRACKET = r'\]'
t_LBRACE = r'\{'
t_RBRACE = r'\}'
t_COMMA = r','
t_SEMI = r';'
t_COLON = r':'

t_CONDOP = r'\?'
# t_ELLIPSIS         = r'\.\.\.'


def t_status(t):
    print "illegal '%s' line %d" % (t.value[0], t.lineno)
    #exit(1)
    t.skip(1)


lex.lex()

if __name__ == '__main__':
    lex.input(data)
    while 1:
        tok = lex.token()
        if not tok: break  # No more input
        print tok
Esempio n. 26
0
error_count = 0
# Error handling rule
def t_error(t):
    print "Illegal character '%s'" % t.value[0]
    t.lexer.skip(1)
    global error_count
    error_count += 1

# Build the lexer
lexer = lex.lex()

if __name__ == '__main__':
    # file
    if len(sys.argv) > 1:
        lex.input(''.join(open(sys.argv[1], 'r').readlines()))
        while 1:
            tok = lex.token()
            if not tok: break
            print tok
        print 'errors: %d\n' % error_count
    # interactive
    else:
        while True:
           try:
               s = raw_input('asmlex > ')
           except EOFError:
               break
           if not s: continue
           lex.input(s)
           while 1:
Esempio n. 27
0
    t.skip(1)

# Build the lexer
import lex
lex.lex()

source = """
[[this]junk
[theother=something]the text
 to be marked u
p[another=thingy]junk
]
"""

lex.input(source)
if 0:
   while 1:
      token = lex.token()
      if not token:
         break
#      print "TOKEN", token

#
###############################################################################################################################
#
# Parsing rules

precedence = (
# ('left','PLUS','MINUS')
    )
Esempio n. 28
0
#t while condition do statements end
#t break
#t continue

from_disk = False

if __name__ == '__main__':
    import sys
    if not from_disk:
        s = raw_input('>>> ')
    else:
        f = file('essai.txt')
        s = f.read()
        print("s last: %s" % (s[len(s)-1],))
    #s += "\n"
    lex.input(s)

while 1:
    tok = lex.token()
    if not tok: break
    if tok.type != 'NEWLINE':
        print "line %d:%s(%s)"%(tok.lineno, tok.type, tok.value)
    else:
        print("line %d:%s(\\n)"%(tok.lineno, tok.type))

class Node:
    def __init__(self, code, parameters = None, sbg = None, sbd = None, value = None):
        self.code = code
        self.parameters = parameters
        self.sbg = sbg
        self.sbd = sbd
Esempio n. 29
0
            print('Bad line in ' + htmlmapfile, lines[i])
        else:
            tofind = fl.group(1)
            #   replace all _ in tofind with \_
            #            m     = len(tofind)
            #            tfind = tofind[0]
            #	    for j in range(1,m):
            #		if tofind[j] == '_':
            #		    tfind = tfind+'\\'
            #                tfind = tfind+tofind[j]
            mappedstring[tofind] = fl.group(2)
            mappedlink[tofind] = fl.group(3)

#   Read in file that is to be mapped
    lines = sys.stdin.read()
    lex.input(lines)

    text = ''
    bracket = 0
    vbracket = 0
    lstinline_bracket = 0
    lstinlinemod_bracket = 0
    lstlisting_bracket = 0
    outputlisting_bracket = 0
    bashlisting_bracket = 0
    makelisting_bracket = 0
    tikzpicture_bracket = 0
    while 1:
        token = lex.token()  # Get a token
        if not token: break  # No more tokens
        if token.type == 'NEWLINE':
Esempio n. 30
0
	def __init__(self, fileName):
		self.main_node = Node.MainNode("main-node", "tmp")
		self.element_parse_stack = []
		debug.debug("Parse file : '" + fileName + "'")
		
		self.header_file_name = fileName
		
		self.anon_union_counter = [-1, 0]
		# load all the file data :
		headerFileStr = tools.file_read_data(fileName)
		
		# Strip out template declarations
		# TODO : What is the real need ???
		#headerFileStr = re.sub("template[\t ]*<[^>]*>", "", headerFileStr)
		# remove all needed \r unneeded ==> this simplify next resExp ...
		headerFileStr = re.sub("\r", "\r\n", headerFileStr)
		headerFileStr = re.sub("\r\n\n", "\r\n", headerFileStr)
		headerFileStr = re.sub("\r", "", headerFileStr)
		# TODO : Can generate some error ...
		headerFileStr = re.sub("\#if 0(.*?)(\#endif|\#else)", "", headerFileStr, flags=re.DOTALL)
		headerFileafter = re.sub("\@interface(.*?)\@end", "", headerFileStr, flags=re.DOTALL)
		if headerFileStr != headerFileafter :
			debug.debug(" Objective C interface ... ==> not supported")
			return
		
		#debug.verbose(headerFileStr)
		
		#Filter out Extern "C" statements. These are order dependent
		headerFileStr = re.sub(r'extern( |\t)+"[Cc]"( |\t)*{', "{", headerFileStr)
		headerFileStr = re.sub(r'\\\n', "##multiline##", headerFileStr)
		headerFileStr += '\n'
		debug.debug(headerFileStr)
		
		###### debug.info(headerFileStr)
		self.stack = [] # token stack to find the namespace and the element name ...
		self.previous = None
		self.name_stack = [] # 
		self.brace_depth = 0
		self.brace_depth_type = []
		self.last_comment = []
		self.sub_module_count_brace = 0;
		lex.lex()
		lex.input(headerFileStr)
		self.cur_line = 0
		self.cur_char = 0
		self.count_pthese = 0
		while True:
			tok = lex.token()
			if not tok:
				break
			debug.verbose("TOK: " + str(tok))
			self.stack.append( tok.value )
			self.cur_line = tok.lineno
			self.cur_char = tok.lexpos
			# special case to remove internal function define in header:
			if self.previous_is('function') == True:
				if tok.type == 'OPEN_BRACE':
					self.sub_module_count_brace += 1
					debug.verbose("openBrace " + str(self.sub_module_count_brace))
				elif tok.type == 'CLOSE_BRACE':
					self.sub_module_count_brace -= 1
					debug.verbose("closeBrace " + str(self.sub_module_count_brace) + " line:" + str(self.cur_line))
				if self.sub_module_count_brace <= 0:
					self.brace_type_pop()
					self.last_comment = []
				continue
			# normal case:
			if tok.type == 'PRECOMP':
				debug.debug("PRECOMP: " + str(tok))
				self.stack = []
				self.name_stack = []
				self.last_comment = []
				# Do nothing for macro ==> many time not needed ...
				continue
			if tok.type == 'COMMENT_SINGLELINE_DOC_PREVIOUS':
				if self.previous_is('enum') == True:
					if self.name_stack[-1] == ",":
						self.name_stack[-1] = "//!< " + tok.value
						self.name_stack.append(",")
					else:
						self.name_stack.append("//!< " + tok.value)
				elif     self.previous != None \
				     and self.previous.get_node_type() == 'variable':
					self.previous.add_doc([tok.value])
				else:
					#self.last_comment.append(tok.value)
					pass
			if tok.type == 'COMMENT_MULTILINE_DOC':
				self.last_comment.append(tok.value)
			if tok.type == 'COMMENT_SINGLELINE_DOC':
				self.last_comment.append(tok.value)
			if tok.type == 'OPEN_BRACE':
				if self.count_pthese >= 1:
					# special case of lamba declaration inside initialisation of constructor
					self.name_stack.append(tok.value)
					debug.info("plop 0 " +str(self.count_pthese))
				else:
					# When we open a brace, this is the time to parse the stack ...
					# Clean the stack : (remove \t\r\n , and concatenate the 'xx', ':', ':', 'yy'  in 'xx::yy',
					self.name_stack = create_compleate_class_name(self.name_stack)
					if len(self.name_stack) <= 0:
						#open brace with no name ...
						self.brace_type_push('empty', [])
					elif is_a_function(self.name_stack):
						# need to parse sub function internal description...
						self.sub_module_count_brace = 1
						self.brace_type_push('function', self.name_stack)
						debug.verbose("openBrace *** " + str(self.name_stack))
					elif 'namespace' in self.name_stack:
						self.brace_type_push('namespace', self.name_stack)
					elif 'class' in self.name_stack:
						self.brace_type_push('class', self.name_stack)
					elif 'enum' in self.name_stack:
						self.brace_type_push('enum', self.name_stack)
					elif 'struct' in self.name_stack:
						self.brace_type_push('struct', self.name_stack)
					elif 'typedef' in self.name_stack:
						self.brace_type_push('typedef', self.name_stack)
					elif 'using' in self.name_stack:
						self.brace_type_push('using', self.name_stack)
					elif 'union' in self.name_stack:
						self.brace_type_push('union', self.name_stack)
					else:
						self.brace_type_push('unknow', self.name_stack)
					self.stack = []
					self.name_stack = []
					self.last_comment = []
			elif tok.type == 'CLOSE_BRACE':
				if self.count_pthese >= 1:
					debug.info("plop 2 " +str(self.count_pthese))
					# special case of lamba declaration inside initialisation of constructor
					self.name_stack.append(tok.value)
				else:
					if len(self.name_stack) != 0:
						if self.previous_is('enum') == True:
							self.brace_type_append('enum list', self.name_stack);
						else:
							debug.warning(self.gen_debug_space() + "end brace DROP : " + str(self.name_stack));
					self.stack = []
					self.name_stack = []
					self.last_comment = []
					self.brace_type_pop()
					self.name_stack = create_compleate_class_name(self.name_stack)
			if tok.type == 'OPEN_PAREN':
				self.count_pthese += 1
				self.name_stack.append(tok.value)
			elif tok.type == 'CLOSE_PAREN':
				self.count_pthese -= 1
				self.name_stack.append(tok.value)
			elif tok.type == 'OPEN_SQUARE_BRACKET':
				self.name_stack.append(tok.value)
			elif tok.type == 'CLOSE_SQUARE_BRACKET':
				self.name_stack.append(tok.value)
			elif tok.type == 'EQUALS':
				self.name_stack.append(tok.value)
			elif tok.type == 'COMMA':
				self.name_stack.append(tok.value)
			elif tok.type == 'BACKSLASH':
				self.name_stack.append(tok.value)
			elif tok.type == 'PIPE':
				self.name_stack.append(tok.value)
			elif tok.type == 'PERCENT':
				self.name_stack.append(tok.value)
			elif tok.type == 'CARET':
				self.name_stack.append(tok.value)
			elif tok.type == 'EXCLAMATION':
				self.name_stack.append(tok.value)
			elif tok.type == 'SQUOTE':
				self.name_stack.append(tok.value)
			elif tok.type == 'NUMBER':
				self.name_stack.append(tok.value)
			elif tok.type == 'MINUS':
				self.name_stack.append(tok.value)
			elif tok.type == 'PLUS':
				self.name_stack.append(tok.value)
			elif tok.type == 'STRING_LITERAL':
				self.name_stack.append(tok.value)
			elif     tok.type == 'NAME' \
			      or tok.type == 'AMPERSTAND' \
			      or tok.type == 'ASTERISK' \
			      or tok.type == 'CHAR_LITERAL':
				self.name_stack.append(tok.value)
			elif tok.type == 'COLON':
				if self.name_stack[0] in Node.access_list:
					debug.debug(self.gen_debug_space() + "change visibility : " + self.name_stack[0]);
					self.brace_type_change_access(self.name_stack[0])
					self.name_stack = []
					self.stack = []
				else :
					self.name_stack.append(tok.value)
			elif tok.type == 'SEMI_COLON':
				if self.count_pthese >= 1:
					debug.info("plop 3 " +str(self.count_pthese))
					# special case of lamba declaration inside initialisation of constructor
					self.name_stack.append(tok.value)
				else:
					if len(self.name_stack) != 0:
						self.name_stack = create_compleate_class_name(self.name_stack)
						if is_a_function(self.name_stack):
							self.brace_type_append('function', self.name_stack);
						elif 'namespace' in self.name_stack:
							debug.debug(self.gen_debug_space() + "find a namespace DECLARATION : " + str(self.name_stack));
						elif 'class' in self.name_stack:
							debug.debug(self.gen_debug_space() + "find a class     DECLARATION : " + str(self.name_stack));
						elif 'enum' in self.name_stack:
							debug.debug(self.gen_debug_space() + "find a enum      DECLARATION : " + str(self.name_stack));
						elif 'struct' in self.name_stack:
							debug.debug(self.gen_debug_space() + "find a struct    DECLARATION : " + str(self.name_stack));
						elif 'typedef' in self.name_stack:
							debug.warning(self.gen_debug_space() + "find a typedef    DECLARATION : " + str(self.name_stack) + " ==> lose it ...");
							#self.brace_type_push('typedef', self.name_stack);
						elif 'using' in self.name_stack:
							debug.info(self.gen_debug_space() + "find a using      DECLARATION : " + str(self.name_stack));
							self.brace_type_append('using', self.name_stack);
						elif 'union' in self.name_stack:
							debug.debug(self.gen_debug_space() + "find a union     DECLARATION : " + str(self.name_stack));
						else:
							if self.previous_is('enum') == True:
								self.brace_type_append('enum list', self.name_stack);
							else:
								# TODO : Check if it is true in all case : 
								self.brace_type_append('variable', self.name_stack);
								#debug.warning(self.gen_debug_space() + "variable : " + str(self.name_stack));
					self.stack = []
					self.name_stack = []
					self.last_comment = []
Esempio n. 31
0
    def __init__(self, headerFileName, argType="file"):
        if argType == "file":
            self.headerFileName = os.path.expandvars(headerFileName)
            self.mainClass = os.path.split(self.headerFileName)[1][:-2]
            headerFileStr = ""
        #            if headerFileName[-2:] != ".h":
        #                raise Exception("file must be a header file and end with .h")
        elif argType == "string":
            self.headerFileName = ""
            self.mainClass = "???"
            headerFileStr = headerFileName
        else:
            raise Exception("Arg type must be either file or string")
        self.curClass = ""
        self.classes = {}
        self.enums = []
        self.nameStack = []
        self.nameSpaces = []
        self.curAccessSpecifier = "private"

        if len(self.headerFileName):
            headerFileStr = "\n".join(open(self.headerFileName).readlines())
        self.braceDepth = 0
        lex.input(headerFileStr)
        curLine = 0
        curChar = 0

        # Add for Mediatek code change check
        global mtkChange
        mtkChange = False
        defs = " "
        macro = "ANDROID_DEFAULT_CODE"
        ignorePreComp = 0
        try:
            while True:
                tok = lex.token()
                # Example: LexToken(COLON,';',1,373)
                # where (tok.name, tok.value, ?, ?)
                if not tok:
                    break
                curLine = tok.lineno
                curChar = tok.lexpos

                # For Mediatek code change check begin
                if tok.type == "PRECOMP_MACRO":
                    if tok.value.startswith("#ifndef") or tok.value.startswith("#ifdef") or tok.value.startswith("#if"):
                        if macro in tok.value:
                            if tok.value.startswith("#ifndef") or tok.value.startswith("#ifdef"):
                                defs = tok.value[:7].split()
                            else:
                                if "!defined" in tok.value:
                                    defs = "#ifndef"
                                else:
                                    defs = "#ifdef"

                            if "#ifndef" in defs:
                                mtkChange = True
                            else:
                                mtkChange = False
                        elif defs != " ":
                            ignorePreComp = ignorePreComp + 1

                    elif not ignorePreComp and tok.value.startswith("#else"):
                        if "#ifndef" in defs and mtkChange == True:
                            mtkChange = False
                        elif "#ifdef" in defs and mtkChange == False:
                            mtkChange = True
                    elif tok.value.startswith("#endif"):
                        if ignorePreComp > 0:
                            ignorePreComp = ignorePreComp - 1
                        elif "#ifndef" in defs or "#ifdef" in defs:
                            mtkChange = False
                            defs = " "
                            ignorePreComp = 0
                # For Mediatek code change check end
                if tok.type == "OPEN_BRACE":
                    if len(self.nameStack) and is_namespace(self.nameStack):
                        self.nameSpaces.append(self.nameStack[1])
                    if len(self.nameStack) and not is_enum_namestack(self.nameStack):
                        self.evaluate_stack()
                    else:
                        self.nameStack.append(tok.value)
                    self.braceDepth += 1
                elif tok.type == "CLOSE_BRACE":
                    if self.braceDepth == 0:
                        continue
                    if self.braceDepth == len(self.nameSpaces):
                        tmp = self.nameSpaces.pop()
                    if len(self.nameStack) and is_enum_namestack(self.nameStack):
                        self.nameStack.append(tok.value)
                    elif self.braceDepth < 10:
                        self.evaluate_stack()
                    else:
                        self.nameStack = []
                    self.braceDepth -= 1
                    ######if (self.braceDepth == 0):
                    if self.braceDepth == 1:
                        self.curClass = ""

                if tok.type == "OPEN_PAREN":
                    self.nameStack.append(tok.value)
                elif tok.type == "CLOSE_PAREN":
                    self.nameStack.append(tok.value)
                elif tok.type == "EQUALS":
                    self.nameStack.append(tok.value)
                elif tok.type == "COMMA":
                    self.nameStack.append(tok.value)
                elif tok.type == "NUMBER":
                    self.nameStack.append(tok.value)
                elif tok.type == "MINUS":
                    self.nameStack.append(tok.value)
                elif tok.type == "PLUS":
                    self.nameStack.append(tok.value)
                elif tok.type == "STRING_LITERAL":
                    self.nameStack.append(tok.value)
                elif tok.type == "NAME" or tok.type == "AMPERSTAND" or tok.type == "ASTERISK":
                    if tok.value == "class" or tok.value == "struct":
                        self.nameStack.append(tok.value)
                    elif tok.value in supportedAccessSpecifier and self.braceDepth == len(self.nameSpaces) + 1:
                        self.curAccessSpecifier = tok.value
                    else:
                        self.nameStack.append(tok.value)
                elif tok.type == "COLON":
                    # Dont want colon to be first in stack
                    if len(self.nameStack) == 0:
                        continue
                    self.nameStack.append(tok.value)
                elif tok.type == "SEMI_COLON":
                    if self.braceDepth < 10:
                        self.evaluate_stack()
        except:
            raise CppParseError(
                'Not able to parse %s on line %d evaluating "%s"\nError around: %s'
                % (self.headerFileName, tok.lineno, tok.value, " ".join(self.nameStack))
            )
Esempio n. 32
0
        else:
            tofind = fl.group(1)
#   replace all _ in tofind with \_
#            m     = len(tofind)
#            tfind = tofind[0]
#	    for j in range(1,m):
#		if tofind[j] == '_':
#		    tfind = tfind+'\\'
#                tfind = tfind+tofind[j]
	    mappedstring[tofind] = fl.group(2)
	    mappedlink[tofind]   = fl.group(3)

#
#   Read in file that is to be mapped
    lines = sys.stdin.read()
    lex.input(lines)

    text     = ''
    bracket  = 0
    vbracket = 0
    lstinline_bracket = 0
    lstlisting_bracket = 0 
    while 1:
        token = lex.token()       # Get a token
        if not token: break        # No more tokens
	if token.type == 'NEWLINE':
	    print text
	    text = ''
	else:
	    value = token.value
            # verbatim environment disables bracket count
Esempio n. 33
0
    def __init__(self, headerFileName, argType="file"):
        if (argType == "file"):
            self.headerFileName = os.path.expandvars(headerFileName)
            self.mainClass = os.path.split(self.headerFileName)[1][:-2]
            headerFileStr = ""
#            if headerFileName[-2:] != ".h":
#                raise Exception("file must be a header file and end with .h")
        elif argType == "string":
            self.headerFileName = ""
            self.mainClass = "???"
            headerFileStr = headerFileName
        else:
            raise Exception("Arg type must be either file or string")
        self.curClass = ""
        self.classes = {}
        self.enums = []
        self.nameStack = []
        self.nameSpaces = []
        self.curAccessSpecifier = 'private'

        if (len(self.headerFileName)):
            headerFileStr = "\n".join(open(self.headerFileName).readlines())
        self.braceDepth = 0
        lex.input(headerFileStr)
        curLine = 0
        curChar = 0

        #Add for Mediatek code change check
        global mtkChange
        mtkChange = False
        defs = ' '
        macro = "ANDROID_DEFAULT_CODE"
        ignorePreComp = 0
        try:
            while True:
                tok = lex.token()
                # Example: LexToken(COLON,';',1,373)
                # where (tok.name, tok.value, ?, ?)
                if not tok:
                    break
                curLine = tok.lineno
                curChar = tok.lexpos

                #For Mediatek code change check begin
                if (tok.type == 'PRECOMP_MACRO'):
                    if (tok.value.startswith("#ifndef")
                            or tok.value.startswith("#ifdef")
                            or tok.value.startswith("#if")):
                        if (macro in tok.value):
                            if (tok.value.startswith("#ifndef")
                                    or tok.value.startswith("#ifdef")):
                                defs = tok.value[:7].split()
                            else:
                                if ("!defined" in tok.value):
                                    defs = '#ifndef'
                                else:
                                    defs = '#ifdef'

                            if ('#ifndef' in defs):
                                mtkChange = True
                            else:
                                mtkChange = False
                        elif (defs != ' '):
                            ignorePreComp = ignorePreComp + 1

                    elif (not ignorePreComp and tok.value.startswith("#else")):
                        if ('#ifndef' in defs and mtkChange == True):
                            mtkChange = False
                        elif ('#ifdef' in defs and mtkChange == False):
                            mtkChange = True
                    elif (tok.value.startswith("#endif")):
                        if (ignorePreComp > 0):
                            ignorePreComp = ignorePreComp - 1
                        elif ('#ifndef' in defs or '#ifdef' in defs):
                            mtkChange = False
                            defs = ' '
                            ignorePreComp = 0
                #For Mediatek code change check end
                if (tok.type == 'OPEN_BRACE'):
                    if len(self.nameStack) and is_namespace(self.nameStack):
                        self.nameSpaces.append(self.nameStack[1])
                    if len(self.nameStack) and not is_enum_namestack(
                            self.nameStack):
                        self.evaluate_stack()
                    else:
                        self.nameStack.append(tok.value)
                    self.braceDepth += 1
                elif (tok.type == 'CLOSE_BRACE'):
                    if self.braceDepth == 0:
                        continue
                    if (self.braceDepth == len(self.nameSpaces)):
                        tmp = self.nameSpaces.pop()
                    if len(self.nameStack) and is_enum_namestack(
                            self.nameStack):
                        self.nameStack.append(tok.value)
                    elif self.braceDepth < 10:
                        self.evaluate_stack()
                    else:
                        self.nameStack = []
                    self.braceDepth -= 1
                    ######if (self.braceDepth == 0):
                    if self.braceDepth == 1:
                        self.curClass = ""

                if (tok.type == 'OPEN_PAREN'):
                    self.nameStack.append(tok.value)
                elif (tok.type == 'CLOSE_PAREN'):
                    self.nameStack.append(tok.value)
                elif (tok.type == 'EQUALS'):
                    self.nameStack.append(tok.value)
                elif (tok.type == 'COMMA'):
                    self.nameStack.append(tok.value)
                elif (tok.type == 'NUMBER'):
                    self.nameStack.append(tok.value)
                elif (tok.type == 'MINUS'):
                    self.nameStack.append(tok.value)
                elif (tok.type == 'PLUS'):
                    self.nameStack.append(tok.value)
                elif (tok.type == 'STRING_LITERAL'):
                    self.nameStack.append(tok.value)
                elif (tok.type == 'NAME' or tok.type == 'AMPERSTAND'
                      or tok.type == 'ASTERISK'):
                    if (tok.value == 'class' or tok.value == 'struct'):
                        self.nameStack.append(tok.value)
                    elif (tok.value in supportedAccessSpecifier
                          and self.braceDepth == len(self.nameSpaces) + 1):
                        self.curAccessSpecifier = tok.value
                    else:
                        self.nameStack.append(tok.value)
                elif (tok.type == 'COLON'):
                    #Dont want colon to be first in stack
                    if len(self.nameStack) == 0:
                        continue
                    self.nameStack.append(tok.value)
                elif (tok.type == 'SEMI_COLON'):
                    if (self.braceDepth < 10):
                        self.evaluate_stack()
        except:
            raise CppParseError(
                "Not able to parse %s on line %d evaluating \"%s\"\nError around: %s"
                % (self.headerFileName, tok.lineno, tok.value, " ".join(
                    self.nameStack)))