Esempio n. 1
0
def pretty_type(d):
    if cc.is_type_any(d):
        return "any"
    if cc.is_type_atom(d):
        return "atom"
    if cc.is_type_atomlit(d):
        return pretty(cc.get_literal_from_atomlit(d))
    if cc.is_type_float(d):
        return "float"
    if cc.is_type_integer(d):
        return "integer"
    if cc.is_type_integerlit(d):
        return pretty(cc.get_literal_from_integerlit(d))
    if cc.is_type_list(d):
        return "[%s]" % pretty_type(cc.get_inner_type_from_list(d))
    if cc.is_type_nil(d):
        return "[]"
    if cc.is_type_tuple(d):
        return "tuple"
    if cc.is_type_tupledet(d):
        return "{%s}" % ", ".join(
            map(pretty_type, cc.get_inner_types_from_tupledet(d)))
    if cc.is_type_union(d):
        return "|".join(map(pretty_type, cc.get_inner_types_from_union(d)))
    if cc.is_type_range(d):
        bs = cc.get_range_bounds_from_range(d)
        return "%s..%s" % (cc.get_lower_bound(bs), cc.get_upper_bound(bs))
    if cc.is_type_generic_fun(d):
        return "fun()"
    if cc.is_type_complete_fun(d):
        args, ret = d["a"][:-1], d["a"][-1]
        args = cc.get_parameters_from_complete_fun(d)
        ret = cc.get_rettype_from_fun(d)
        return "fun(({}) -> {})".format(", ".join(map(pretty_type, args)),
                                        pretty_type(ret))
Esempio n. 2
0
def pretty_type(d):
    if cc.is_type_any(d):
        return "any"
    if cc.is_type_atom(d):
        return "atom"
    if cc.is_type_atomlit(d):
        return pretty(cc.get_literal_from_atomlit(d))
    if cc.is_type_float(d):
        return "float"
    if cc.is_type_integer(d):
        return "integer"
    if cc.is_type_integerlit(d):
        return pretty(cc.get_literal_from_integerlit(d))
    if cc.is_type_list(d):
        return "[%s]" % pretty_type(cc.get_inner_type_from_list(d))
    if cc.is_type_nil(d):
        return "[]"
    if cc.is_type_tuple(d):
        return "tuple"
    if cc.is_type_tupledet(d):
        return "{%s}" % ", ".join(map(pretty_type, cc.get_inner_types_from_tupledet(d)))
    if cc.is_type_union(d):
        return "|".join(map(pretty_type, cc.get_inner_types_from_union(d)))
    if cc.is_type_range(d):
        bs = cc.get_range_bounds_from_range(d)
        return "%s..%s" % (cc.get_lower_bound(bs), cc.get_upper_bound(bs))
    if cc.is_type_generic_fun(d):
        return "fun()"
    if cc.is_type_complete_fun(d):
        args, ret = d["a"][:-1], d["a"][-1]
        args = cc.get_parameters_from_complete_fun(d)
        ret = cc.get_rettype_from_fun(d)
        return "fun(({}) -> {})".format(", ".join(map(pretty_type, args)), pretty_type(ret))
Esempio n. 3
0
 def build_spec(self, spec, var):
     if cc.is_type_any(spec):
         return "true"
     elif cc.is_type_float(spec):
         return ["is-real", var]
     elif cc.is_type_integer(spec):
         return ["is-int", var]
     elif cc.is_type_list(spec):
         inner_spec = cc.get_inner_type_from_list(spec)
         name = self.fun_rec_tlist(inner_spec)
         return [
             "and",
             ["is-list", var],
             [name, ["lv", var]],
         ]
     elif cc.is_type_nonempty_list(spec):
         inner_spec = cc.get_inner_type_from_nonempty_list(spec)
         name = self.fun_rec_tlist(inner_spec)
         return [
             "and",
             ["is-list", var],
             ["is-tc", ["lv", var]],
             [name, ["lv", var]],
         ]
     elif cc.is_type_tupledet(spec):
         body = ["and", ["is-tuple", var]]
         tlist = ["tv", var]
         for inner_type in cc.get_inner_types_from_tupledet(spec):
             body.append(["is-tc", tlist])
             body.append(self.build_spec(inner_type, ["th", tlist]))
             tlist = ["tt", tlist]
         body.append(["is-tn", tlist])
         return body
     elif cc.is_type_tuple(spec):
         return ["is-tuple", var]
     elif cc.is_type_union(spec):
         ret = ["or"]
         for inner_type in cc.get_inner_types_from_union(spec):
             ret.append(self.build_spec(inner_type, var))
         return ret
     elif cc.is_type_range(spec):
         ret = ["and", ["is-int", var]]
         limits = cc.get_range_bounds_from_range(spec)
         if cc.has_lower_bound(limits):
             ret.append(
                 [">=", ["iv", var],
                  build_int(cc.get_lower_bound(limits))])
         if cc.has_upper_bound(limits):
             ret.append(
                 ["<=", ["iv", var],
                  build_int(cc.get_upper_bound(limits))])
         return ret
     elif cc.is_type_atom(spec):
         return ["is-atom", var]
     elif cc.is_type_bitstring(spec):
         segment_size = cc.get_segment_size_from_bitstring(spec)
         m = int(segment_size.m)
         n = int(segment_size.n)
         slist = ["sv", var]
         axioms = ["and"]
         axioms.append(["is-str", var])
         while m > 0:
             axioms.append(["is-sc", slist])
             slist = ["st", slist]
             m -= 1
         if n == 0:
             axioms.append(["is-sn", slist])
         elif n > 1:
             axioms.append(SListSpec(slist, build_int(n), self))
         return axioms
     elif cc.is_type_complete_fun(spec):
         # TODO if a function is to be called with wrong arguments, program must crash
         par_spec = cc.get_parameters_from_complete_fun(spec)
         ret_spec = cc.get_rettype_from_fun(spec)
         name = self.fun_rec_flist(par_spec, ret_spec)
         return [
             "and", ["is-fun", var],
             ["=", ["fa", ["fv", var]],
              build_int(len(par_spec))], [name, ["fm", ["fv", var]]],
             ["not", ["=", ["fm", ["fv", var]], "fn"]]
         ]
     elif cc.is_type_generic_fun(spec):
         par_spec = None
         ret_spec = cc.get_rettype_from_fun(spec)
         name = self.fun_rec_flist(par_spec, ret_spec)
         return [
             "and", ["is-fun", var], [name, ["fm", ["fv", var]]],
             ["not", ["=", ["fm", ["fv", var]], "fn"]]
         ]
     elif cc.is_type_atomlit(spec):
         return ["=", var, self.decode(cc.get_literal_from_atomlit(spec))]
     elif cc.is_type_integerlit(spec):
         return [
             "=", var,
             self.decode(cc.get_literal_from_integerlit(spec))
         ]
     elif cc.is_type_userdef(spec):
         type_name = cc.get_type_name_of_userdef(spec)
         return ["|{}|".format(type_name), var]
     clg.debug_info("unknown spec: " + str(spec))
     assert False
Esempio n. 4
0
 def isUnion(cls, typ):
     return cc.is_type_union(typ)