Python SymbolTable.SymbolTable类代码示例

def main():
	"output file is the file where output will be written to"
	filename = sys.argv[1].split('.')[0]
	outputfile = open( filename + ".hack", "a" )

	"input file is the file where input will come from"
	inputfile = Parser( sys.argv[1] )

	lines = inputfile.commandLines()

	for line in lines:
		if( ParserComd( line ).commandType() == 'A_command' ):
			symbol_line = ParserComd( line ).symbol( )
			symbol_a = SymbolTable( )
			symbol_a.addEntry( symbol_line )
			f = symbol_a.GetAddress( symbol_line )
			outputfile.write( f )
			outputfile.write( '\n' )

		elif( ParserComd( line ).commandType() == 'C_command_a' or ParserComd( line ).commandType() == 'C_command_b'):
			dest_line = ParserComd( line ).dest()
			comp_line = ParserComd( line ).comp()
			jump_line = ParserComd( line ).jump()
			cbinary = Code( dest_line, comp_line, jump_line ).cinstruction()
			outputfile.write( cbinary )
			outputfile.write( '\n' )
		elif( ParserComd( line ).commandType() == 'L_command' ):
			outputfile.write( 'This line is going to delete\n' )

	outputfile.close()

class symboltabletests(unittest.TestCase):

    def setUp(self):
        self.st = SymbolTable()

    def testContains(self):
        self.st.addEntry("loop", 100)
        self.assertTrue(self.st.contains("loop"))
        self.assertFalse(self.st.contains("bobby"))

def first_pass(path):
    p = Parser(path)

    symbol_table = SymbolTable()
    n = 0
    while(p.hasMoreCommands()):
        command_type = p.commandType()
        if(command_type == CommandType.L):
            symbol_table.add_entry(p.symbol(), n)
        else:
            n += 1
        p.advance()
    return symbol_table

 def visit_Fundef(self, node):
     node.Functions.putNewFun(node.id, node.type) 
     Functions = FunctionsTable(node.Functions, "Functions")
     Variables = SymbolTable(node.Variables, "Variables")
     node.argList.Functions = Functions
     node.argList.Variables = Variables
     listOfArguments = node.argList.accept(self)
     for element in listOfArguments:
         if element!= None:
             node.Functions.put(node.id, element[1])
             if Variables.put(element[0], element[1])==-1:
                 self.errors.append("In line "+ str(node.lineno) + ": variable "+ element.name + " was initialized")
     node.compoundInstr.Functions = Functions
     node.compoundInstr.Variables = Variables
     node.compoundInstr.accept(self)

    def setUp(self):
        self.assembler = Assembler()
        parser = Parser()
        self.symbolTable = SymbolTable()

        self.assembler.setSymbolTable(self.symbolTable)
        self.assembler.setParser(parser)

 def visit_FunDef(self,node):
     # print "visiting FunDef"
     self.symbolTable = SymbolTable(self.symbolTable,node.id.value)
     self.symbolTable.getParentScope().put(node.id.value,FunSymbol(node.typeOrId, node.id.value, map(lambda x: x.accept(self),node.argList.list)))
     node.compoundInstr.accept(self)
     self.symbolTable = self.symbolTable.getParentScope()
     return node.id.value

 def visit_ClassDef(self,node):
     # print "visiting ClassDef"
     self.symbolTable = SymbolTable(self.symbolTable if node.parentId == None else self.classTables[node.parentId.value], node.id.value)
     classSymbol = ClassSymbol(node.accessmodificator, node.id.value, node.parentId if node.parentId == None else node.parentId.accept(self),node.classcontent.accept(self))
     self.classTables[node.id.value]=self.symbolTable
     while self.symbolTable.parent!=None:
         self.symbolTable = self.symbolTable.getParentScope()
     self.symbolTable.put(node.id.value,classSymbol)

 def __init__(self, inputFile, outputFile):
     self.tokenizer = JackTokenizer(inputFile)
     self.vmWriter = VMWriter(outputFile)
     self.symbolTable = SymbolTable()
     self.classname = ""
     self.CompileClass()
     self.whilecounter = 0
     self.ifcounter = 0

 def visit_Program(self,node):
     try:
         #print "visiting Program"
         self.symbolTable=SymbolTable(None,'main')
         node.declarations.accept(self)
         node.fundefs.accept(self)
         node.instructions.accept(self)
     except:
         self.error("could not continue parsing, correct errors first",0)

 def __init__(self, tokenizer, outputFile, vmFile):
     from SymbolTable import SymbolTable
     from VMWriter import VMWriter
     self.tokenizer = tokenizer
     self.outputFile = outputFile
     self.symbolTable = SymbolTable()
     self.vmWriter = VMWriter(vmFile)
     self.labelNum = 0
     print(outputFile)

 def __init__(self,tokens,vmwriter):
     try:
         tokens[0].value
         tokens[0].type
     except:
         sys.exit("Parser did not take in a list of tokens!")
     self.tokens=tokens
     self.vmwriter=vmwriter
     self.symTable=SymbolTable()

    def visit_CompoundInstruction(self, node):
        self.scope = SymbolTable(self.scope, "compound")

        for declaration in node.decls:
            declaration.accept(self)
        for instruction in node.instrs:
            instruction.accept(self)

        # Get the hell out of function scope, after its done
        self.scope = self.scope.parent

 def __init__(self, tokenizer, out_file_name):
     """
     Constructor
     """
     self._tokenizer = tokenizer
     self._vm_writer = VMWriter(out_file_name)
     self._class_name = None
     self._symbol_table = SymbolTable()
     self._counter = 0
     self._subroutine_name = None

 def __init__(self, input_file, output_file):
     self.jack_tokenizer = JackTokenizer(input_file)
     self.symbol_table = SymbolTable()
     self.writer = VMWriter(output_file)
     self.class_name = ""
     self.subroutine_name = ""
     self.return_type = ""
     self.label_counter_if = 0
     self.label_counter_while = 0
     self.num_args_called_function = 0
     self.is_unary = False
     self.dic_arithmetic = {"+" : "add" , "-" : "sub", "*" : "call Math.multiply 2",
                            "/" : "call Math.divide 2", "&" : "and", "|" : "or", "<" : "lt", ">" : "gt", "=" : "eq"}

    def __init__(self, input_file_path):
        self.output_file = open(input_file_path.replace('.asm', '.hack'), 'w')

        """
        The ROM address is the address of the current instruction written in the
        .hack file. The first instruction is 0, second is 1, etc. Label is not a instruction.
        """
        self.current_rom_address = ROM_BASE_ADRESS

        self.parser = Parser(input_file_path)
        self.symbol_table = SymbolTable()

        """
        The RAM address of the next free memory that a new variable
        should be at.
        """
        self.next_free_var_address = VARIABLES_BASE_ADDRESS