Python interpreter.check_one_val函数代码示例

def equal_vec_done_cont(a, b, idx, info, env, cont, _vals):
    from pycket.interpreter import check_one_val, return_value
    eq = check_one_val(_vals)
    if eq is values.w_false:
        return return_value(values.w_false, env, cont)
    inc = idx + 1
    return equal_vec_func(a, b, inc, info, env, cont)

def get_port_cont(prop, typ, env, cont, _vals):
    from pycket.interpreter import return_value, check_one_val
    val = check_one_val(_vals)
    if isinstance(val, values_struct.W_RootStruct):
        return get_port(val, prop, typ, env, cont)
    else:
        return return_value(val, env, cont)

def proc_arity_cont(arity, env, cont, _vals):
    from pycket.interpreter import check_one_val, return_value
    val = check_one_val(_vals)
    if not arity.arity_list:
        return return_value(val, env, cont)
    result = make_arity_list(arity, val)
    return return_value(result, env, cont)

def catch_set_is_equal_cont(data, idx, key, val, env, cont, _vals):
    from pycket.interpreter import check_one_val, return_value
    cmp = check_one_val(_vals)
    if cmp is not values.w_false:
        data[idx] = (key, val)
        return return_value(values.w_void, env, cont)
    return equal_hash_set_loop(data, idx + 1, key, val, env, cont)

def imp_struct_set_cont(orig_struct, setter, field, app, env, cont, _vals):
    from pycket.interpreter import check_one_val

    val = check_one_val(_vals)
    if setter is values.w_false:
        return orig_struct.set_with_extra_info(field, val, app, env, cont)
    return setter.call_with_extra_info([orig_struct, val], env, cont, app)

def catch_equal_cont(vals, args, idx, env, cont, _vals):
    from pycket.interpreter import check_one_val

    val = check_one_val(_vals)
    if val is values.w_false:
        raise SchemeException("Expecting original value or chaperone")
    return check_chaperone_results_loop(vals, args, idx + 1, env, cont)

def equal_ht_done_cont(hash_1_items, hash_2, idx, info, env, cont, _vals):
    from pycket.interpreter import check_one_val, return_value
    eq = check_one_val(_vals)
    if eq is values.w_false:
        return return_value(values.w_false, env, cont)
    inc = idx + 1
    return equal_ht_func(hash_1_items, hash_2, inc, info, env, cont)

def hash_keys_subset_huh_cont(keys_vals, hash_2, idx, env, cont, _vals):
    from pycket.interpreter import return_value, check_one_val
    val = check_one_val(_vals)
    if val is values.w_false:
        return return_value(values.w_false, env, cont)
    else:
        return hash_keys_subset_huh_loop(keys_vals, hash_2, idx + 1, env, cont)

def imp_hash_table_post_ref_cont(post, ht, old, env, cont, _vals):
    from pycket.interpreter import check_one_val, return_multi_vals
    val = check_one_val(_vals)
    if val is None:
        # XXX this looks wrong, check_one_val raises if there are multiple
        # values
        return return_multi_vals(_vals, env, cont)
    return post.call([ht, old, val], env, cont)

def equal_ht_cont(hash_1_items, hash_2, idx, info, env, cont, _vals):
    from pycket.interpreter import return_value, check_one_val
    hash_2_val = check_one_val(_vals)
    if hash_2_val is values.w_false:
        return return_value(values.w_false, env, cont)
    else:
        return equal_func(hash_1_items[idx][1], hash_2_val, info, env,
                          equal_ht_done_cont(hash_1_items, hash_2, idx, info, env, cont))

def vec2val_cont(vals, vec, n, s, l, env, cont, new_vals):
    from pycket.interpreter import return_multi_vals, check_one_val
    new  = check_one_val(new_vals)
    vals[n] = new
    if s+n+1 == l:
        return return_multi_vals(values.Values.make(vals), env, cont)
    else:
        return vec.vector_ref(values.W_Fixnum.make(s+n+1), env, vec2val_cont(vals, vec, n+1, s, l, env, cont))

def vector_copy_cont_get(src, src_start, src_end, dest, dest_start, i, env, cont, _vals):
    from pycket.interpreter import check_one_val
    val  = check_one_val(_vals)
    idx  = values.W_Fixnum(i.value + dest_start)
    next = values.W_Fixnum(i.value + 1)
    return dest.vector_set(idx, val, env,
                goto_vector_copy_loop(src, src_start, src_end,
                    dest, dest_start, next, env, cont))

def display_escape_cont(exn, env, cont, _vals):
    from pycket.interpreter import check_one_val
    message = check_one_val(_vals)

    display_handler = error_display_handler_param.get(cont) # parameterize this to default first
    escape_handler = error_escape_handler_param.get(cont) # this one too

    # display, then escape
    return display_handler.call([message, exn], env, call_handler_cont(escape_handler, [], env, cont))

def read_stream_cont(env, cont, _vals):
    from pycket.interpreter import check_one_val, return_value
    port = check_one_val(_vals)
    rt = current_readtable_param.get(cont)
    if rt is values.w_false:
        rt = None
    else:
        assert isinstance(rt, values.W_ReadTable)
    return read_stream_rt(port, rt, env, cont)

def hash_ref_cont(default, env, cont, _vals):
    from pycket.interpreter import return_value, check_one_val
    val = check_one_val(_vals)
    if val is not w_missing:
        return return_value(val, env, cont)
    if default is None:
        raise SchemeException("key not found")
    if default.iscallable():
        return default.call([], env, cont)
    return return_value(default, env, cont)