Python G.G类代码示例

def main():
	if len(sys.argv) < 2:
		print "usage:"
		print "  java Oodle filename"
		return

	#HACK - add readint() and writeint() declarations
	G.typeMap().addExtern(ExternDecl('readint', 'int'))
	G.typeMap().addExtern(ExternDecl('writeint')).addParam(LocalVarDecl('i', 'int'))

	G.options().parseArgs(sys.argv[1:])

	flist = G.fileConcat ()
	for f in G.options().getFileList():
		flist.appendFile(f)

	st_node = None
	print 'Lexing...'
	lex = Lexer(flist.getConcatFile().getAbsolutePath())
	print 'Parsing...'
	par = Parser(lex)
	try:
		st_node = par.parse()
	except ParserException, e:
		G.errors().syntax().add(e.getMessage())

	def outACall(self, node):
		'''Generate method 'call' code
		   Error Conditions
			* NONE'''
		self.printFunc(self.outACall, node)
		src = node.toString().strip()
		ln = node.getId().getLine()
		nm = node.getId().getText()
		klass = None
		if node.getExpr():
			pass
			#id_nm = node.getExpr().getId().getText()
			#klass = self.typeMap[node.getExpr()]
		if klass:
			klass = klass.typeName()
		else:
			klass = self.curClass()
		decl = G.typeMap().method(klass, nm) #FIXME - only allows calls to methods within the same class
		if not decl:
			decl = G.typeMap().func(nm)
		if not decl:
			decl = G.typeMap().extern(nm)
		self.writeAsmTextComment(src, ln)
		self.writeAsmText('call ' + nm)
		
		#FIXME - HACK FOR REMOVING/NOT REMOVING PARAMETERS
		if len(decl.params()) == 1 and decl.typeName()[0] == Type.VOID.typeName():
			pass 
		else: 
			self.writeAsmText('addl $' + str(len(decl.params()) * 4 ) + ', %esp')

	def outAVar(self, node):
		'''Manage 'var' declarations
		   Error Conditions:
		    * var type is not declared
		    * var type is mismatched'''
		self.printFunc(self.outAVar, node)
		err = False #set if error is detected
		id = node.getId() #TId node
		nm = id.getText() #variable name
		ln = id.getLine() #line number
		
		#check assignment type
		tp_assign = Type.NONE
		if node.getExpr() != None:
			tp_assign = self.typeMap[node.getExpr()]
			
		
		#check declared type
		tp_decl = Type.NONE
		if node.getTp() == None:
			G.errors().semantic().add("variable '" + nm + "' must have a type", ln)
		else:
			tp_decl = self.typeMap[node.getTp()] #get the variable type from the child node
		
		#compare declared and assigned types
		if tp_assign != Type.NONE and tp_decl != Type.NONE and tp_assign != tp_decl:
			G.errors().semantic().add("type mismatch '" + tp_decl.name() +
									  "' := '" + tp_assign.name(), ln)
		#store this nodes type
		self.typeMap[node] = tp_decl

	def inAKlassInherits(self, node):
		'''Manage inheritance
		   Error Conditions:
		    * HACK MiniOodle: inheritance is an unsupported feature'''
		self.printFunc(self.inAKlassInherits, node)
		ln = node.getKwFrom().getLine() #get the line number
		G.errors().semantic().addUnsupportedFeature("'inherits from'", ln)

	def inAXtern(self, node):
		''''''
		self.printFunc(self.inAXtern, node)

		ln = node.getId().getLine()
		nm = node.getId().getText()
		tp_map = G.typeMap()
		if tp_map.externExists(nm):
			G.errors().semantic().add("extern '" + nm + "' already exists", ln)
		else:
			tp_map.addExtern(ExternDecl(nm))

		ex = tp_map.extern(nm)
		if node.getRet():
			tp = node.getRet().getTp().getText()
			ex.setTypeName(tp) #set the return type name
		
		args = node.getArgs()
		for a in args:
			ln = a.getId().getLine()
			nm = a.getId().getText()
			tp = ""
			if a.getTp():
				tp = a.getTp().getTp().getText()
			if ex.exists(nm):
				G.errors().semantic().add("parameter '" + nm + "' already exists", ln)
			else:
				par_decl = LocalVarDecl(nm, tp)
				ex.addParam(par_decl) #add param to TypeMap

	def outAArrayType(self, node):
		'''Manage 'array' type
		   Error Conditions:
		    * Unsupported Feature'''
		self.printFunc(self.outAArrayType, node)
		ln = node.getLBrack().getLine()
		G.errors().semantic().addUnsupportedFeature('array', ln)
		self.typeMap[node] = Type.NONE

	def outAArrayExpr(self, node):
		'''Manage 'array' expression
		   Error Conditions
		    * HACK MiniOodle: me is unsupported'''
		self.printFunc(self.outAArrayExpr, node)
		ln = node.getId().getLine()
		G.errors().semantic().addUnsupportedFeature('array', ln)
		self.typeMap[node] = Type.NONE

	def outAStrExpr(self, node):
		'''Manage 'string' expr9 expression
		   Error Conditions
		    * HACK MiniOodle: string is unsupported'''
		self.printFunc(self.outAStrExpr, node)
		ln = node.getValue().getLine()
		G.errors().semantic().addUnsupportedFeature("string", ln)
		self.typeMap[node] = Type.STRING

	def isVarNameUsed(self, nm):
		'''Check whether var name is already used'''
		ret = False
		sym = G.symTab().lookup(nm)
		if sym != None:
			ret = ret or isinstance(sym.decl(), ClassDecl)
			#ret = ret or isinstance(sym.decl(), MethodDecl) #FIXME - probably need this
			ret = ret or (isinstance(sym.decl(), VarDecl) and sym.scope() == G.symTab().getScope())
		return ret

	def outALoopStmt(self, node):
		'''Manage 'loop while' statement
		   Error Conditions:
		    * expr type != Type.BOOLEAN'''
		self.printFunc(self.outALoopStmt)
		ln = node.getWhile().getLine()
		tp = self.typeMap[node.getExpr()]
		if tp != Type.BOOLEAN:
			G.errors().semantic().add("loops must evaluate on type " +
									  Type.BOOLEAN.name(), ln)

	def inAKlassBody(self, node):
		'''Manage class variables
		   Error Conditions:
		    * HACK MiniOodle: no class variable initialization'''
		self.printFunc(self.inAKlassBody)
		vars = node.getVars()

		#class variable init is unsupported in MiniOodle
		for v in vars:
			if v.getExpr() != None:
				ln = v.getId().getLine() #line number
				G.errors().semantic().addUnsupportedFeature("class variable initialization", ln)

	def outAFunc(self, node):
		''''''
		self.printFunc(self.outAFunc)
		vars = node.getVars()
		
		#HACK - local variable init is unsupported in MiniOodle
		sloc = -8
		for v in vars:
			ln = v.getId().getLine() #line number
			if v.getExpr() != None:
				G.errors().semantic().addUnsupportedFeature("local variable initialization", ln)
		self.setCurMethod("")

	def inAVarToplevel(self, node):
		''''''
		self.printFunc(self.inAVarToplevel, node)
		ln = node.getVar().getId().getLine()
		
		tp_map = G.typeMap()
		nm = node.getVar().getId().getText()
		tp = node.getVar().getTp().getTp().getText()
		if tp_map.glbVarExists(nm):
			G.errors().semantic().add("global variable '" + nm + "' already exists", ln)
		else:
			var_decl = GlobalVarDecl(nm, tp)
			tp_map.addGlbVar(var_decl) #add var to TypeMap

	def inAFuncArg(self, node):
		''''''
		self.printFunc(self.inAFuncArg, node)
		ln = node.getId().getLine()
		tp_map = G.typeMap()
		func = tp_map.func(self.curMethod())
		nm = node.getId().getText()
		tp = node.getTp().getTp().getText()
		if func.exists(nm):
			G.errors().semantic().add("variable '" + nm + "' already exists", ln)
		else:
			var_decl = LocalVarDecl(nm, tp)
			func.addParam(var_decl) #add var to TypeMap

	def outANotExpr(self, node):
		'''Manage 'not' expression
		   Error Conditions
		    * expression type not boolean'''
		self.printFunc(self.outANotExpr, node)
		ln = node.getOp().getLine()
		tp = self.typeMap[node.getExpr()]
		tp_ret = Type.BOOLEAN
		if tp != Type.BOOLEAN:
			tp_ret = Type.NONE
			G.errors().semantic().add("'" + node.toString().strip() +
									  "' operation requires type " +
									  Type.BOOLEAN.name(), ln)
		self.typeMap[node] = tp_ret