def handleKey(row, key, mode, hnd):
if mode == MODE_ARRAY:
for k in input_format[key]:
if k in row and row[k] != '':
hnd(row[k])
return
ignore_missing = mode == MODE_DEFAULT
if key in input_format:
k = input_format[key]
if util.is_array(k):
found = False
for key in k:
if key in row and row[key] != '':
hnd(row[key])
found = True
break
if not found and ignore_missing:
hnd('')
else:
if k in row and row[k] != '':
hnd(row[k])
elif ignore_missing:
hnd('')
elif ignore_missing:
hnd('')
def handleKey(row, key, mode, hnd):
if mode == MODE_ARRAY:
for k in input_format[key]:
if k in row and row[k] != '':
hnd(row[k])
return
ignore_missing = mode == MODE_DEFAULT
if key in input_format:
k = input_format[key]
if util.is_array(k):
found = False
for key in k:
if key in row and row[key] != '':
hnd(row[key])
found = True
break
if not found and ignore_missing:
hnd('')
else:
if k in row and row[k] != '':
hnd(row[k])
elif ignore_missing:
hnd('')
elif ignore_missing:
hnd('')
def __contains__(self, x):
if util.is_map(x):
return all((self.__contains__(v) for v in x.values()))
if util.is_array(x):
return all((self.__contains__(v) for v in x))
if util.is_string(x):
k = util.safe_decode(x)
else:
k = unicode(x)
return k in self._elements
def gen_log_sk(sk_dir, pgr):
buf = cStringIO.StringIO()
buf.write("package log;\n")
buf.write(_const)
buf.write("""
// distinct hash values for runtime objects
int obj_cnt = 0;
int nonce () {
return obj_cnt++;
}
""")
# factory of Object
buf.write("""
// factory of Object
Object alloc(int ty) {{
Object {0} = new Object(hash=nonce(), __cid=ty);
return {0};
}}
""".format(C.SK.self))
global _ty;
_clss = []
for ty in _ty.keys():
if util.is_collection(ty): continue
if util.is_array(ty): continue
cls = class_lookup(ty)
if not cls: continue # to avoid None definition
# inner class may appear twice: w/ and w/o outer class name
if cls not in _clss: _clss.append(cls)
buf.write("\n// distinct class IDs\n")
for cls in _clss:
buf.write("int {cls!r} () {{ return {cls.id}; }}\n".format(**locals()))
buf.write("\n// distinct method IDs\n")
for cls in pgr.classes:
mtds = collect_decls(cls, "mtds")
if not mtds: continue
for mtd in mtds:
mname = sanitize_mname(unicode(repr(mtd)))
buf.write("""
int {mname}_ent () {{ return {mtd.id}; }}
int {mname}_ext () {{ return -{mtd.id}; }}
""".format(**locals()))
with open(os.path.join(sk_dir, "log.sk"), 'w') as f:
f.write(buf.getvalue())
logging.info("encoding " + f.name)
buf.close()
def __delitem__(self, key):
if util.is_map(key):
return self.__delitem__(key.values())
if util.is_array(key):
for k in key:
self.__delitem__(k)
return
if util.is_string(key):
k = util.safe_decode(key)
else:
k = unicode(key)
if k in self._elements:
del self._elements[k]
return
def __setitem__(self, key, value):
if util.is_map(key):
return self.__setitem__(key.values(), value)
if util.is_array(key):
for k in key:
self.__setitem__(k, value)
return
if value is None:
self.__delitem__(key)
return
if util.is_string(key):
k = util.safe_decode(key)
else:
k = unicode(key)
self._elements[k] = util.rec_decode(value)
return
def generate_dto_tostring(camel_case_dto_name, func):
tostring_fields = ""
for t in zip(func['types'], func['args']):
field_name = util.underscore_to_camelcase(t[1])
# for retval don't generate dto field in Reply
if util.is_retval_field(field_name):
continue
# handle array types
if util.is_array(util.jni_2_java_type_mapping[t[0]]):
tostring_fields += tostring_array_field_template.substitute(field_name=field_name)
else:
tostring_fields += tostring_field_template.substitute(field_name=field_name)
return tostring_template.substitute(cls_name=camel_case_dto_name,
fields_tostring=tostring_fields[:-8])
def generate_dto_equals(camel_case_dto_name, func):
equals_fields = ""
for t in zip(func['types'], func['args']):
field_name = util.underscore_to_camelcase(t[1])
# for retval don't generate dto field in Reply
if util.is_retval_field(field_name):
continue
# handle array types
if util.is_array(util.jni_2_java_type_mapping[t[0]]):
equals_fields += equals_array_field_template.substitute(field_name=field_name)
else:
equals_fields += equals_field_template.substitute(field_name=field_name)
if equals_fields != "":
equals_fields = equals_other_template.substitute(cls_name=camel_case_dto_name) + equals_fields
return equals_template.substitute(comparisons=equals_fields)
def __getitem__(self, key):
if util.is_map(key):
return util.cons_map(
((k, self.__getitem__(v)) for k, v in key.items()),
key.__class__
)
if isinstance(key, collections.Set):
return {k: self.__getitem__(k) for k in util.rec_decode(key)}
if util.is_array(key):
return util.cons_array(
(self.__getitem__(k) for k in key),
key.__class__
)
if util.is_string(key):
k = util.safe_decode(key)
else:
k = unicode(key)
return self._get(k)
def generate_dto_hash(func):
hash_fields = ""
# Special handling for hashCode in case just a single array field is present. Cannot use Objects.equals since the
# array is mistaken for a varargs parameter. Instead use Arrays.hashCode in such case.
if len(func['args']) == 1:
single_type = func['types'][0]
single_type_name = func['args'][0]
if util.is_array(util.jni_2_java_type_mapping[single_type]):
return hash_single_array_type_template.substitute(fields=util.underscore_to_camelcase(single_type_name))
for t in zip(func['types'], func['args']):
field_name = util.underscore_to_camelcase(t[1])
# for retval don't generate dto field in Reply
if util.is_retval_field(field_name):
continue
hash_fields += field_name + ", "
return hash_template.substitute(fields=hash_fields[:-2])
def gen_type_sk(sk_dir, bases):
buf = cStringIO.StringIO()
buf.write("package type;\n")
buf.write(_const)
cols, decls = util.partition(lambda c: util.is_collection(c.name), bases)
decls = filter(lambda c: not util.is_array(c.name), decls)
itfs, clss = util.partition(op.attrgetter("is_itf"), decls)
logging.debug("# interface(s): {}".format(len(itfs)))
logging.debug("# class(es): {}".format(len(clss)))
# convert interfaces first, then usual classes
buf.write('\n'.join(util.ffilter(map(to_struct, itfs))))
buf.write('\n'.join(util.ffilter(map(to_struct, clss))))
# convert collections at last
logging.debug("# collection(s): {}".format(len(cols)))
buf.write('\n'.join(map(col_to_struct, cols)))
# argument number of methods
arg_num = map(lambda mtd: len(mtd.params), methods())
buf.write("""
#define _{0} {{ {1} }}
int {0}(int id) {{
return _{0}[id];
}}
""".format(C.typ.argNum, ", ".join(map(str, arg_num))))
# argument types of methods
def get_args_typ(mtd):
def get_arg_typ(param): return str(class_lookup(param[0]).id)
return '{' + ", ".join(map(get_arg_typ, mtd.params)) + '}'
args_typ = map(get_args_typ, methods())
buf.write("""
#define _{0} {{ {1} }}
int {0}(int id, int idx) {{
return _{0}[id][idx];
}}
""".format(C.typ.argType, ", ".join(args_typ)))
# return type of methods
def get_ret_typ(mtd):
cls = class_lookup(mtd.typ)
if cls: return cls.id
else: return -1
ret_typ = map(get_ret_typ, methods())
buf.write("""
#define _{0} {{ {1} }}
int {0}(int id) {{
return _{0}[id];
}}
""".format(C.typ.retType, ", ".join(map(str, ret_typ))))
# belonging class of methods
belongs = map(lambda mtd: mtd.clazz.id, methods())
buf.write("""
#define _{0} {{ {1} }}
int {0}(int id) {{
return _{0}[id];
}}
""".format(C.typ.belongsTo, ", ".join(map(str, belongs))))
subcls = \
map(lambda cls_i: '{' + ", ".join( \
map(lambda cls_j: str(cls_i <= cls_j).lower(), classes()) \
) + '}', classes())
buf.write("""
#define _{0} {{ {1} }}
bit {0}(int i, int j) {{
return _{0}[i][j];
}}
""".format(C.typ.subcls, ", ".join(subcls)))
## sub type relations
#subcls = []
#for cls_i in classes():
# row = []
# for cls_j in classes():
# row.append(int(cls_i <= cls_j))
# subcls.append(row)
## sub type relations in yale format
#_, IA, JA = util.yale_format(subcls)
#li, lj = len(IA), len(JA)
#si = ", ".join(map(str, IA))
#sj = ", ".join(map(str, JA))
#buf.write("""
# #define _iA {{ {si} }}
# #define _jA {{ {sj} }}
# int iA(int i) {{
# return _iA[i];
# }}
# int jA(int j) {{
# return _jA[j];
# }}
# bit subcls(int i, int j) {{
# int col_i = iA(i);
# int col_j = iA(i+1);
# for (int col = col_i; col < col_j; col++) {{
# if (j == jA(col)) return true;
# }}
# return false;
# }}
#""".format(**locals()))
with open(os.path.join(sk_dir, "type.sk"), 'w') as f:
f.write(buf.getvalue())
logging.info("encoding " + f.name)
buf.close()
def gen_type_sk(sk_dir, bases):
buf = cStringIO.StringIO()
buf.write("package type;\n")
buf.write(_const)
buf.write(trans_lib())
buf.write('\n')
cols, decls = util.partition(lambda c: util.is_collection(c.name), bases)
decls = filter(lambda c: not util.is_array(c.name), decls)
itfs, clss = util.partition(op.attrgetter("is_itf"), decls)
logging.debug("# interface(s): {}".format(len(itfs)))
logging.debug("# class(es): {}".format(len(clss)))
# convert interfaces first, then usual classes
buf.write('\n'.join(util.ffilter(map(to_struct, itfs))))
buf.write('\n'.join(util.ffilter(map(to_struct, clss))))
# convert collections at last
logging.debug("# collection(s): {}".format(len(cols)))
buf.write('\n'.join(map(col_to_struct, cols)))
# argument number of methods
arg_num = map(lambda mtd: len(mtd.params), methods())
buf.write("""
#define _{0} {{ {1} }}
int {0}(int id) {{
return _{0}[id];
}}
""".format(C.typ.argNum, ", ".join(map(str, arg_num))))
# argument types of methods
def get_args_typ(mtd):
def get_arg_typ(param): return str(class_lookup(param[0]).id)
return '{' + ", ".join(map(get_arg_typ, mtd.params)) + '}'
args_typ = map(get_args_typ, methods())
buf.write("""
#define _{0} {{ {1} }}
int {0}(int id, int idx) {{
return _{0}[id][idx];
}}
""".format(C.typ.argType, ", ".join(args_typ)))
# return type of methods
def get_ret_typ(mtd):
cls = class_lookup(mtd.typ)
if cls: return cls.id
else: return -1
ret_typ = map(get_ret_typ, methods())
buf.write("""
#define _{0} {{ {1} }}
int {0}(int id) {{
return _{0}[id];
}}
""".format(C.typ.retType, ", ".join(map(str, ret_typ))))
# belonging class of methods
belongs = map(lambda mtd: mtd.clazz.id, methods())
buf.write("""
#define _{0} {{ {1} }}
int {0}(int id) {{
return _{0}[id];
}}
""".format(C.typ.belongsTo, ", ".join(map(str, belongs))))
subcls = \
map(lambda cls_i: '{' + ", ".join( \
map(lambda cls_j: str(cls_i <= cls_j).lower(), classes()) \
) + '}', classes())
buf.write("""
#define _{0} {{ {1} }}
bit {0}(int i, int j) {{
return _{0}[i][j];
}}
""".format(C.typ.subcls, ", ".join(subcls)))
## sub type relations
#subcls = []
#for cls_i in classes():
# row = []
# for cls_j in classes():
# row.append(int(cls_i <= cls_j))
# subcls.append(row)
## sub type relations in yale format
#_, IA, JA = util.yale_format(subcls)
#li, lj = len(IA), len(JA)
#si = ", ".join(map(str, IA))
#sj = ", ".join(map(str, JA))
#buf.write("""
# #define _iA {{ {si} }}
# #define _jA {{ {sj} }}
# int iA(int i) {{
# return _iA[i];
# }}
# int jA(int j) {{
# return _jA[j];
# }}
# bit subcls(int i, int j) {{
# int col_i = iA(i);
# int col_j = iA(i+1);
# for (int col = col_i; col < col_j; col++) {{
# if (j == jA(col)) return true;
# }}
# return false;
# }}
#""".format(**locals()))
with open(os.path.join(sk_dir, "type.sk"), 'w') as f:
f.write(buf.getvalue())
logging.info("encoding " + f.name)
buf.close()
def gen_log_sk(sk_dir, tmpl):
buf = cStringIO.StringIO()
buf.write("package log;\n")
buf.write(_const)
global max_objs
buf.write("int O = {}; // # of objects\n".format(max_objs + 1))
buf.write("""
int log_cnt = 0;
int[P][N] ev;
int[O] obj;
// to enforce the length of logs
int get_log_cnt() {
return log_cnt;
}
// after writing logs, reset the cursor in order to check logs in order
void reset_log_cnt() {
log_cnt = 0;
}
// to clean up the logs totally
void clear_log() {
reset_log_cnt();
ev = {};
obj = {};
}
// to write the log from samples
void write_log (int[P] params) {
ev[log_cnt++] = params;
}
// to check whether control-flow conforms to the samples
@Native("{ std::cout << \\\"log::check_log::\\\" << params[0] << std::endl; }")
void check_log (int[P] params) {
assert params[0] == ev[log_cnt][0]; // check mid
for (int i = 1; i < P; i++) {
if (ev[log_cnt][i] != 0) {
if (obj[ev[log_cnt][i]] == 0) { // not set yet
obj[ev[log_cnt][i]] = params[i];
}
else { // o.w. check obj eq.
assert obj[ev[log_cnt][i]] == params[i];
}
}
}
log_cnt++; // advance
}
// distinct hash values for runtime objects
int obj_cnt = 0;
int nonce () {
return obj_cnt++;
}
""")
global _inits
reg_codes = []
for ty in _inits:
cls = class_lookup(ty)
if not cls: continue
buf.write("""
int obj_{0}_cnt = 0;
{1}[O] obj_{0};
// to register runtime instances of {0}
void register_{0} ({1} {2}) {{
if (obj_{0}_cnt < O) {{
obj_{0}[obj_{0}_cnt++] = {2};
}}
}}
// to access to a certain instance of {0}
{1} retrieve_{0} (int idx) {{
if (0 <= idx && idx < obj_{0}_cnt) {{
return obj_{0}[idx];
}}
else {{
return null;
}}
}}
""".format(ty, trans_ty(ty), ty.lower()))
reg_code = "if (ty == {0}) register_{1}@log({2});".format(cls.id, repr(cls), C.SK.self)
reg_codes.append(reg_code)
# factory of Object
buf.write("""
// factory of Object
Object alloc(int ty) {{
Object {0} = new Object(hash=nonce(), __cid=ty);
{1}
return {0};
}}
""".format(C.SK.self, "\nelse ".join(reg_codes)))
global _ty;
_clss = []
for ty in _ty.keys():
if util.is_collection(ty): continue
if util.is_array(ty): continue
cls = class_lookup(ty)
if not cls: continue # to avoid None definition
# inner class may appear twice: w/ and w/o outer class name
if cls not in _clss: _clss.append(cls)
buf.write("\n// distinct class IDs\n")
for cls in _clss:
buf.write("int {cls!r} () {{ return {cls.id}; }}\n".format(**locals()))
buf.write("\n// distinct method IDs\n")
for cls in tmpl.classes:
mtds = collect_decls(cls, "mtds")
if not mtds: continue
for mtd in mtds:
mname = sanitize_mname(unicode(repr(mtd)))
buf.write("""
int {mname}_ent () {{ return {mtd.id}; }}
int {mname}_ext () {{ return -{mtd.id}; }}
""".format(**locals()))
with open(os.path.join(sk_dir, "log.sk"), 'w') as f:
f.write(buf.getvalue())
logging.info("encoding " + f.name)
buf.close()
