def __init__(self, module, decr_set, name, base_cls_type, gtp_name_list):
if gtp_name_list:
assert "native" in decr_set
self.module = module
self.decr_set = decr_set
self.name = name
self.base_cls_type = base_cls_type
self.gtp_name_list = gtp_name_list
self.construct_method = []
self.destruct_method = None
self.attr_map = cocc_common.OrderedDict()
self.method_map = cocc_common.OrderedDict()
def _parse_arg_map(token_list, dep_module_set):
arg_map = cocc_common.OrderedDict()
if token_list.peek().is_sym(")"):
return arg_map
while True:
if token_list.peek().is_reserved("ref"):
token_list.pop()
is_ref = True
else:
is_ref = False
type = cocc_type.parse_type(token_list, dep_module_set, is_ref = is_ref)
if type.name == "void":
type.token.syntax_err("参数类型不可为void")
t, name = token_list.pop_name()
if name in arg_map:
t.syntax_err("参数名重定义")
if name in dep_module_set:
t.syntax_err("参数名和导入模块名冲突")
arg_map[name] = type
t = token_list.peek()
if t.is_sym(","):
token_list.pop_sym(",")
continue
if t.is_sym(")"):
return arg_map
t.syntax_err("需要','或')'")
def __init__(self, gcls, gtp_list):
assert "native" in gcls.decr_set
assert gtp_list and len(gcls.gtp_name_list) == len(gtp_list)
self.gtp_map = dict(zip(gcls.gtp_name_list, gtp_list))
self.module = gcls.module
self.decr_set = gcls.decr_set
self.gcls = gcls
self.name = gcls.name + "<%s>" % ", ".join([str(gtp) for gtp in gtp_list])
self.base_cls_type = None if gcls.base_cls_type is None else gcls.base_cls_type.to_gcls_inst_type(self.gtp_map)
self.construct_method = [method.to_gcls_inst_method(self) for method in gcls.construct_method]
self.destruct_method = None if gcls.destruct_method is None else gcls.destruct_method.to_gcls_inst_method(self)
self.attr_map = cocc_common.OrderedDict()
for name, attr in gcls.attr_map.iteritems():
assert name == attr.name
self.attr_map[name] = attr.to_gcls_inst_attr(self)
self.method_map = cocc_common.OrderedDict()
for name, method_list in gcls.method_map.iteritems():
self.method_map[name] = ml = []
for method in method_list:
assert name == method.name
ml.append(method.to_gcls_inst_method(self))
def _parse_for_prefix(token_list, var_map_list, cls, module):
token_list.pop_sym("(")
for_var_map = cocc_common.OrderedDict()
tp = cocc_type.try_parse_type(token_list, module)
if tp is None:
#第一部分为表达式列表
init_expr_list = []
if not token_list.peek().is_sym(";"):
init_expr_list += _parse_expr_list_with_se(token_list, var_map_list + (for_var_map,), cls, module)
else:
#第一部分为若干变量定义
init_expr_list = []
while True:
t, name = token_list.pop_name()
if name in module.dep_module_set:
t.syntax_err("变量名和导入模块名重复")
token_list.pop_sym("=")
expr = cocc_expr.parse_expr(token_list, var_map_list + (for_var_map,), cls, module, tp)
for_var_map[name] = tp
init_expr_list.append(expr)
if token_list.peek().is_sym(";"):
break
token_list.pop_sym(",")
token_list.pop_sym(";")
if token_list.peek().is_sym(";"):
#没有第二部分
judge_expr = None
else:
judge_expr = cocc_expr.parse_expr(token_list, var_map_list + (for_var_map,), cls, module, cocc_type.BOOL_TYPE)
token_list.pop_sym(";")
loop_expr_list = []
if not token_list.peek().is_sym(")"):
loop_expr_list += _parse_expr_list_with_se(token_list, var_map_list + (for_var_map,), cls, module)
token_list.pop_sym(")")
return for_var_map, init_expr_list, judge_expr, loop_expr_list
def _parse_text(self, token_list):
self.dep_module_set = set()
import_end = False
self.class_map = cocc_common.OrderedDict()
self.gcls_inst_map = cocc_common.OrderedDict()
self.typedef_map = cocc_common.OrderedDict()
self.func_map = cocc_common.OrderedDict()
self.global_var_map = cocc_common.OrderedDict()
while token_list:
#解析import
t = token_list.peek()
if t.is_reserved("import"):
#import
if import_end:
t.syntax_err("import必须在模块代码最前面")
self._parse_import(token_list)
continue
import_end = True
#解析修饰
decr_set = _parse_decr_set(token_list)
#解析各种定义
t = token_list.peek()
if t.is_reserved("class"):
#解析类
if decr_set - set(["public", "native", "final"]):
t.syntax_err("类只能用public、native和final修饰")
self._parse_class(decr_set, token_list)
continue
if t.is_reserved("typedef"):
#解析typedef
if decr_set - set(["public"]):
t.syntax_err("typedef只能用public修饰")
self._parse_typedef(decr_set, token_list)
continue
#可能是函数或全局变量
type = cocc_type.parse_type(token_list, self.dep_module_set)
t, name = token_list.pop_name()
self._check_redefine(t, name, token_list.peek().is_sym("("))
t, sym = token_list.pop_sym()
if sym == "(":
#函数
if decr_set - set(["public", "native"]):
t.syntax_err("函数只能用public和native修饰")
self._parse_func(decr_set, type, name, token_list)
continue
if sym in (";", "=", ","):
#全局变量
if decr_set - set(["public", "native", "final"]):
t.syntax_err("全局变量只能用public、native和final修饰")
if type.name == "void":
t.syntax_err("变量类型不可为void")
while True:
if sym == "=":
if "native" in decr_set:
t.syntax_err("不能初始化native全局变量")
expr_token_list, sym = _parse_expr_token_list(token_list)
else:
if "native" not in decr_set:
t.syntax_err("非native全局变量必须显式初始化")
expr_token_list = None
self.global_var_map[name] = _GlobalVar(name, self, decr_set, type, expr_token_list)
if sym == ";":
break
#定义了多个变量，继续解析
assert sym == ","
t, name = token_list.pop_name()
self._check_redefine(t, name)
t, sym = token_list.pop_sym()
if sym not in (";", "=", ","):
t.syntax_err()
continue
t.syntax_err()
#coding=gbk
"""
编译模块
"""
import os
import cocc_common
import cocc_token
import cocc_type
import cocc_stmt
import cocc_expr
builtins_module = None
module_map = cocc_common.OrderedDict()
def _parse_decr_set(token_list):
decr_set = set()
while True:
t = token_list.peek()
for decr in "public", "protected", "private", "native", "final", "abstract":
if t.is_reserved(decr):
if decr in decr_set:
t.syntax_err("重复的修饰'%s'" % decr)
decr_set.add(decr)
if len(decr_set & set(["public", "protected", "private"])) > 1:
t.syntax_err("同时存在多个权限修饰")
token_list.pop()
break
else:
return decr_set
def parse_stmt_list(token_list, module, cls, var_map_list, loop_deep, ret_type):
assert var_map_list
stmt_list = _StmtList(var_map_list[-1])
while True:
if token_list.peek().is_sym("}"):
break
t = token_list.pop()
if t.is_sym(";"):
continue
if t.is_sym("{"):
#新代码块
stmt_list.append(_Stmt("block", stmt_list = parse_stmt_list(token_list, module, cls, var_map_list + (cocc_common.OrderedDict(),),
loop_deep, ret_type)))
token_list.pop_sym("}")
continue
if t.is_reserved and t.value in ("break", "continue"):
if loop_deep == 0:
t.syntax_err("循环外的'%s'" % t.value)
stmt_list.append(_Stmt(t.value))
continue
if t.is_reserved("return"):
expr = _parse_return(token_list, ret_type, var_map_list, cls, module)
stmt_list.append(_Stmt("return", expr = expr))
continue
if t.is_reserved("for"):
for_var_map, init_expr_list, judge_expr, loop_expr_list = _parse_for_prefix(token_list, var_map_list, cls, module)
token_list.pop_sym("{")
for_stmt_list = parse_stmt_list(token_list, module, cls, var_map_list + (for_var_map.copy(),), loop_deep + 1, ret_type)
token_list.pop_sym("}")
stmt_list.append(_Stmt("for", for_var_map = for_var_map, init_expr_list = init_expr_list, judge_expr = judge_expr,
loop_expr_list = loop_expr_list, stmt_list = for_stmt_list))
continue
if t.is_reserved("while"):
token_list.pop_sym("(")
expr = cocc_expr.parse_expr(token_list, var_map_list, cls, module, cocc_type.BOOL_TYPE)
token_list.pop_sym(")")
token_list.pop_sym("{")
while_stmt_list = parse_stmt_list(token_list, module, cls, var_map_list + (cocc_common.OrderedDict(),), loop_deep + 1, ret_type)
token_list.pop_sym("}")
stmt_list.append(_Stmt("while", expr = expr, stmt_list = while_stmt_list))
continue
if t.is_reserved("do"):
token_list.pop_sym("{")
do_stmt_list = parse_stmt_list(token_list, module, cls, var_map_list + (cocc_common.OrderedDict(),), loop_deep + 1, ret_type)
token_list.pop_sym("}")
t = token_list.pop()
if not t.is_reserved("while"):
t.syntax_err("需要'while'")
token_list.pop_sym("(")
expr = cocc_expr.parse_expr(token_list, var_map_list, cls, module, cocc_type.BOOL_TYPE)
token_list.pop_sym(")")
token_list.pop_sym(";")
stmt_list.append(_Stmt("do", expr = expr, stmt_list = do_stmt_list))
continue
if t.is_reserved("if"):
if_expr_list = []
if_stmt_list_list = []
else_stmt_list = None
while True:
token_list.pop_sym("(")
expr = cocc_expr.parse_expr(token_list, var_map_list, cls, module, cocc_type.BOOL_TYPE)
token_list.pop_sym(")")
token_list.pop_sym("{")
if_stmt_list = parse_stmt_list(token_list, module, cls, var_map_list + (cocc_common.OrderedDict(),), loop_deep, ret_type)
token_list.pop_sym("}")
if_expr_list.append(expr)
if_stmt_list_list.append(if_stmt_list)
if not token_list.peek().is_reserved("else"):
break
token_list.pop()
t = token_list.pop()
if t.is_reserved("if"):
continue
if not t.is_sym("{"):
t.syntax_err("需要'{'")
else_stmt_list = parse_stmt_list(token_list, module, cls, var_map_list + (cocc_common.OrderedDict(),), loop_deep, ret_type)
token_list.pop_sym("}")
break
stmt_list.append(_Stmt("if", if_expr_list = if_expr_list, if_stmt_list_list = if_stmt_list_list, else_stmt_list = else_stmt_list))
continue
token_list.revert()
t = token_list.peek()
tp = cocc_type.try_parse_type(token_list, module)
if tp is not None:
#变量定义
if tp.is_void:
t.syntax_err("变量类型不能为void")
while True:
t, name = token_list.pop_name()
if name in module.dep_module_set:
t.syntax_err("变量名和导入模块重名")
for var_map in var_map_list:
if name in var_map:
t.syntax_err("变量名重定义")
var_map_list[-1][name] = tp
token_list.pop_sym("=")
expr = cocc_expr.parse_expr(token_list, var_map_list, cls, module, tp)
stmt_list.append(_Stmt("var", name = name, expr = expr))
if token_list.peek().is_sym(";"):
break
token_list.pop_sym(",")
token_list.pop_sym(";")
continue
#表达式
expr = _parse_expr_with_se(token_list, var_map_list, cls, module)
stmt_list.append(_Stmt("expr", expr = expr))
token_list.pop_sym(";")
return stmt_list