/* expand -- expand a type abbreviation */
PUBLIC type expand(type t, frame f)
{
def d = t->t_def;
frame p = t->t_params;
frame pp;
int i;
if (f == arid) {
/* Special case: parameters are already absolute */
pp = p;
} else {
pp = mk_frame(d->d_nparams);
for (i = 0; i < d->d_nparams; i++)
pp->f_var[i] = seal(p->f_var[i], f);
}
if (d->d_kind == SCHEMA)
return seal(mk_sproduct(d->d_schema), pp);
else {
type base;
if (! anal_power(seal(d->d_type, pp), &base, nil))
panic("expand");
return base;
}
}
bool ValidateSEAL()
{
byte input[] = {0x37,0xa0,0x05,0x95,0x9b,0x84,0xc4,0x9c,0xa4,0xbe,0x1e,0x05,0x06,0x73,0x53,0x0f,0x5f,0xb0,0x97,0xfd,0xf6,0xa1,0x3f,0xbd,0x6c,0x2c,0xde,0xcd,0x81,0xfd,0xee,0x7c};
byte output[32];
byte key[] = {0x67, 0x45, 0x23, 0x01, 0xef, 0xcd, 0xab, 0x89, 0x98, 0xba, 0xdc, 0xfe, 0x10, 0x32, 0x54, 0x76, 0xc3, 0xd2, 0xe1, 0xf0};
byte iv[] = {0x01, 0x35, 0x77, 0xaf};
cout << "\nSEAL validation suite running...\n\n";
SEAL<>::Encryption seal(key, sizeof(key), iv);
unsigned int size = sizeof(input);
bool pass = true;
memset(output, 1, size);
seal.ProcessString(output, input, size);
for (unsigned int i=0; i<size; i++)
if (output[i] != 0)
pass = false;
seal.Seek(1);
output[1] = seal.ProcessByte(output[1]);
seal.ProcessString(output+2, size-2);
pass = pass && memcmp(output+1, input+1, size-1) == 0;
cout << (pass ? "passed" : "FAILED") << endl;
return pass;
}
/* anal_power -- try to view a type as (P base) */
PUBLIC bool anal_power(type t, type *base, tree cxt)
{
/* The common case (where t is simply a set type) accounts for a big
fraction of the frames and type variables allocated if done by
unification -- so it's just about worth doing directly. */
frame f = arid;
unpack(&t, &f, TRUE);
switch (t->t_kind) {
case POWERT:
*base = seal(t->t_base, f);
return TRUE;
case TYPEVAR:
if (f == arid) return FALSE;
tv_val(t, f) = mk_power(*base = new_typevar(cxt));
return TRUE;
default:
*base = err_type;
mark_error();
return (t == err_type);
}
}
void DecomposeTable<DCP_CABDOOR_BOARD_TYPE>::PostDecompose(soci::session& sql, soci::session& sqlInsert)
{
DecomposeTable<DCP_CABDOOR_BOARD_SEAL_TYPE> seal(StatusInfo_, InfoSPtr_, JD_BoardSealInfo, VerCode_);
seal.Decompose(sql,sqlInsert);
DecomposeTable<DCP_CABDOOR_BOARD_GAP_TYPE> gap(StatusInfo_, InfoSPtr_, JD_BoardGapInfo, VerCode_);
gap.Decompose(sql,sqlInsert);
}
/* anal_rel_type -- View a type as P (dom x ran) */
PUBLIC bool anal_rel_type(type t, type *dom, type *ran, tree cxt)
{
frame f = arid;
unpack(&t, &f, TRUE);
switch (t->t_kind) {
case POWERT:
t = t->t_base;
unpack(&t, &f, TRUE);
switch (t->t_kind) {
case CPRODUCT: {
if (t->t_nfields != 2)
return FALSE;
*dom = seal(t->t_field[0], f);
*ran = seal(t->t_field[1], f);
return TRUE;
}
case TYPEVAR:
if (f == arid)
return FALSE;
else {
frame ff = new_frame(2, cxt);
tv_val(t, f) = mk_binprod(*dom = tv_ref(0, ff),
*ran = tv_ref(1, ff));
return TRUE;
}
default:
return FALSE;
}
case TYPEVAR:
if (f == arid)
return FALSE;
else {
frame ff = new_frame(2, cxt);
tv_val(t, f) = mk_power(mk_binprod(*dom = tv_ref(0, ff),
*ran = tv_ref(1, ff)));
return TRUE;
}
default:
return FALSE;
}
}
message::message()
{
_reader = nullptr;
_writer = new binary_writer();
memset(&_msg_header, 0, message_header::serialized_size());
_msg_header.local_rpc_code = 0;
seal(false, true);
}
message::message()
{
_reader = nullptr;
_writer = new binary_writer();
memset(&_msg_header, 0, MSG_HDR_SERIALIZED_SIZE);
_msg_header.hdr_crc32 = _msg_header.body_crc32 = CRC_INVALID;
_msg_header.local_rpc_code = 0;
seal(false, true);
}
/* anal_cproduct - test if a type is a product and get its components */
PUBLIC bool anal_cproduct(type t, type a[], int *n)
{
frame f = arid;
int i;
unpack(&t, &f, TRUE);
if (t->t_kind != CPRODUCT)
return FALSE;
*n = t->t_nfields;
for (i = 0; i < *n; i++)
a[i] = seal(t->t_field[i], f);
return TRUE;
}
/* ref_type -- find type of a reference */
PUBLIC type ref_type(sym x, tree p, env e, tree cxt)
{
def d = find_def(x, e);
frame f;
if (d == NULL) {
#ifdef ASSUME
type t;
if (qflag && p == nil && (t = assume_type(x)) != NULL)
return t;
#endif
if (! partial_env(e)) {
tc_error(cxt->x_loc, "Identifier %n is not declared", x);
if (cxt->x_kind != REF)
tc_e_etc("Expression: %z", cxt);
tc_e_end();
}
return err_type;
}
f = new_frame(d->d_nparams, cxt);
if (p != nil)
switch (d->d_kind) {
case GSET:
case VAR:
tc_error(cxt->x_loc, "%s %n cannot have parameters",
d->d_kind == GSET ? "Basic type" : "Variable", x);
tc_e_etc("Expression: %z", cxt);
tc_e_end();
return err_type;
case GENCONST:
get_params("Generic constant", x, p, e, f, cxt->x_loc);
break;
default:
bad_tag("ref_type", d->d_kind);
}
if (! aflag && d->d_abbrev)
return mk_power(mk_abbrev(d, (p != nil ? f : alias(f))));
else
return seal(d->d_type, f);
}
File* Fs::create(const char *name, uint32_t size){
toc_item_t ti;
int id = -1;
size_t file_cnt;
osalDbgAssert(this->files_opened > 0, "FS not mounted");
/* zero size forbidden */
if (0 == size)
return nullptr;
file_cnt = get_file_cnt();
/* check are we have spare slot for file */
if (NVRAM_FS_MAX_FILE_CNT == file_cnt)
return nullptr;
id = find(name, &ti);
if (-1 != id)
return nullptr; /* such file already exists */
/* check for name length */
if (strlen(name) >= NVRAM_FS_MAX_FILE_NAME_LEN)
return nullptr;
/* there is no such file. Lets create it*/
strncpy(ti.name, name, NVRAM_FS_MAX_FILE_NAME_LEN);
ti.size = size;
if (0 != file_cnt){
toc_item_t tiprev;
read_toc_item(&tiprev, file_cnt - 1);
ti.start = tiprev.start + tiprev.size;
}
else
ti.start = super.size + super.start;
if ((ti.size + ti.start) > mtd.capacity())
return nullptr;
/* */
write_toc_item(&ti, file_cnt);
seal();
return open(name);
}
/* do_sref -- add the variables of a schema reference to an env */
PUBLIC void do_sref(tree t, env e, env v)
{
tok dec = (tok) t->x_sref_decor;
tree renames = t->x_sref_renames;
def d;
schema s;
frame params;
int i;
if (t->x_kind != SREF) bad_tag("do_sref", t->x_kind);
if (! open_sref(t, e, &d, ¶ms)) {
v->e_partial = TRUE;
return;
}
s = d->d_schema;
check_rename(d->d_schema, dec, renames, t);
for (i = 0; i < s->z_ncomps; i++)
merge_def(VAR, get_rename(s->z_comp[i].z_name, dec, renames),
seal(s->z_comp[i].z_type, params), v, t, t->x_loc);
}
/* comp_type -- get component type in a schema */
PUBLIC type comp_type(type t, sym x, tree cxt, int loc)
{
type tt = t;
frame f = arid;
schema s;
int i;
unpack(&t, &f, TRUE);
if (t->t_kind != SPRODUCT) panic("comp_type");
s = t->t_schema;
for (i = 0; i < s->z_ncomps; i++)
if (s->z_comp[i].z_name == x)
return seal(s->z_comp[i].z_type, f);
tc_error(loc, "Selecting non-existent component %z", x);
if (cxt != nil) {
tc_e_etc("Expression: %z", cxt);
tc_e_etc("Arg type: %t", tt);
}
tc_e_end();
mark_error();
return err_type;
}
/* Added call to refill ks_buf and reset counter and ks_pos. */
void seal_refill_buffer(seal_ctx *c)
{
seal(c,c->counter,c->ks_buf);
c->counter++;
c->ks_pos = 0;
}
/* tc_apply -- check a function application */
PRIVATE type tc_apply(int kind, tree t, tree fun, tree arg, env e)
{
type actual = tc_expr(arg, e);
type fun_type, formal, result;
type formarg[MAX_ARGS], actarg[MAX_ARGS];
int n_formals, n_actuals, i;
frame param = arid;
def d;
if (! aflag && fun->x_kind == REF
&& (d = find_def((sym) fun->x_tag, e)) != NULL
&& d->d_tame && fun->x_params == nil)
/* A tame function */
fun_type = seal(d->d_type,
param = new_frame(d->d_nparams, fun));
else
fun_type = tc_expr(fun, e);
if (! anal_rel_type(fun_type, &formal, &result, fun)) {
if (fun_type != err_type) {
if (kind == APPLY)
tc_error(t->x_loc, "Application of a non-function");
else
tc_error(t->x_loc, "%s operator %n is not a function",
(kind == INOP ? "Infix" : "Postfix"),
fun->x_tag);
tc_e_etc("Expression: %z", t);
tc_e_etc("Found type: %t", fun_type);
tc_e_end();
}
mark_error();
return err_type;
}
if (arg->x_kind == TUPLE
&& anal_cproduct(formal, formarg, &n_formals)) {
/* Special case: actual parameter is a tuple, and formal
parameter type is a cproduct. Check args one by one. */
if (! anal_cproduct(actual, actarg, &n_actuals))
panic("tc_apply");
if (n_actuals != n_formals) {
tc_error(t->x_loc, "Function expects %d arguments",
n_formals);
tc_e_etc("Expression: %z", t);
tc_e_end();
mark_error();
return err_type;
}
for (i = 0; i < n_actuals; i++) {
if (param_unify(actarg[i], formarg[i], param))
continue;
if (kind == INOP)
tc_error(t->x_loc,
"%s argument of operator %n has wrong type",
(i == 0 ? "Left" : "Right"), fun->x_tag);
else
tc_error(t->x_loc, "Argument %d has wrong type", i+1);
tc_e_etc("Expression: %z", t);
tc_e_etc("Arg type: %t", actarg[i]);
tc_e_etc("Expected: %t", formarg[i]);
tc_e_end();
}
}
else if (! param_unify(actual, formal, param)) {
/* General case: check the single arg as a whole. */
tc_error(t->x_loc, "Argument of %s has wrong type",
(kind == POSTOP ? "postfix operator" : "application"));
tc_e_etc("Expression: %z", t);
tc_e_etc("Arg type: %t", actual);
tc_e_etc("Expected: %t", formal);
tc_e_end();
}
return result;
}
PUBLIC type tc_expr(tree t, env e)
#endif
{
switch (t->x_kind) {
case REF:
return ref_type((sym) t->x_tag, t->x_params, e, t);
case INGEN:
return ref_type((sym) t->x_tag,
list2(t->x_param1, t->x_param2), e, t);
case PREGEN:
return ref_type((sym) t->x_tag, list1(t->x_param), e, t);
case NUMBER:
return nat_type;
case SEXPR: {
def d;
frame params;
if (! open_sref(t->x_ref, e, &d, ¶ms))
return err_type;
if ((tok) t->x_ref->x_sref_decor != empty) {
tc_error(t->x_loc, "Decoration ignored in schema reference");
tc_e_etc("Expression: %z", t);
tc_e_end();
}
if (t->x_ref->x_sref_renames != nil) {
tc_error(t->x_loc, "Renaming ignored in schema reference");
tc_e_etc("Expression: %z", t);
tc_e_end();
}
if (! aflag && d->d_abbrev)
return mk_power(mk_abbrev(d, params));
else
return mk_power(seal(mk_sproduct(d->d_schema), params));
}
case POWER: {
type tt1, tt2;
if (! anal_power(tt1 = tc_expr(t->x_arg, e), &tt2, t->x_arg)) {
tc_error(t->x_loc, "Argument of \\power must be a set");
tc_e_etc("Expression: %z", t);
tc_e_etc("Arg type: %t", tt1);
tc_e_end();
}
return mk_power(mk_power(tt2));
}
case TUPLE : {
type a[MAX_ARGS];
int n = 0;
tree u;
for (u = t->x_elements; u != nil; u = cdr(u)) {
if (n >= MAX_ARGS)
panic("tc_expr - tuple too big");
a[n++] = tc_expr(car(u), e);
}
return mk_cproduct(n, a);
}
case CROSS: {
type a[MAX_ARGS];
type tt1, tt2;
int n = 0;
tree u;
for (u = t->x_factors; u != nil; u = cdr(u)) {
if (n >= MAX_ARGS)
panic("tc_expr - product too big");
tt1 = tc_expr(car(u), e);
if (! anal_power(tt1, &tt2, car(u))) {
tc_error(t->x_loc,
"Argument %d of \\cross must be a set", n+1);
tc_e_etc("Expression: %z", t);
tc_e_etc("Arg %d type: %t", n+1, tt1);
tc_e_end();
}
a[n++] = tt2;
}
return mk_power(mk_cproduct(n, a));
}
case EXT:
case SEQ:
case BAG: {
type elem_type;
type tt;
tree u;
if (t->x_elements == nil)
elem_type = new_typevar(t);
else {
elem_type = tc_expr(car(t->x_elements), e);
for (u = cdr(t->x_elements); u != nil; u = cdr(u)) {
if (unify(elem_type, tt = tc_expr(car(u), e)))
elem_type = type_union(elem_type, arid, tt, arid);
else {
tc_error(t->x_loc, "Type mismatch in %s display",
(t->x_kind == EXT ? "set" :
t->x_kind == SEQ ? "sequence" : "bag"));
tc_e_etc("Expression: %z", car(u));
tc_e_etc("Has type: %t", tt);
tc_e_etc("Expected: %t", elem_type);
tc_e_end();
}
}
}
switch (t->x_kind) {
case EXT:
return mk_power(elem_type);
case SEQ:
return (aflag ? rel_type(num_type, elem_type)
: mk_seq(elem_type));
case BAG:
return (aflag ? rel_type(elem_type, num_type)
: mk_bag(elem_type));
}
}
case THETA:
return theta_type(t, e, (type) NULL, t);
case BINDING: {
tree u;
env e1 = new_env(e);
for (u = t->x_elements; u != nil; u = cdr(u))
add_def(VAR, (sym) car(u)->x_lhs,
tc_expr(car(u)->x_rhs, e), e1);
return mk_sproduct(mk_schema(e1));
}
case SELECT: {
type a = tc_expr(t->x_arg, e);
if (type_kind(a) != SPRODUCT) {
tc_error(t->x_loc,
"Argument of selection must have schema type");
tc_e_etc("Expression: %z", t);
tc_e_etc("Arg type: %t", a);
tc_e_end();
mark_error();
return err_type;
}
switch (t->x_field->x_kind) {
case IDENT:
return (comp_type(a, (sym) t->x_field, t, t->x_loc));
case THETA:
return (theta_type(t->x_field, e, a, t));
default:
bad_tag("tc_expr.SELECT", t->x_field->x_kind);
return (type) NULL;
}
}
case APPLY:
return tc_apply(APPLY, t, t->x_arg1, t->x_arg2, e);
case INOP:
return tc_apply(INOP, t, simply(t->x_op, t->x_loc),
pair(t->x_rand1, t->x_rand2), e);
case POSTOP:
return tc_apply(POSTOP, t, simply(t->x_op, t->x_loc),
t->x_rand, e);
case LAMBDA: {
env e1 = tc_schema(t->x_bvar, e);
type dom = tc_expr(char_tuple(t->x_bvar), e1);
type ran = tc_expr(t->x_body, e1);
return (aflag ? rel_type(dom, ran) : mk_pfun(dom, ran));
}
case COMP:
case MU: {
env e1 = tc_schema(t->x_bvar, e);
type a = tc_expr(exists(t->x_body) ? the(t->x_body) :
char_tuple(t->x_bvar), e1);
return (t->x_kind == COMP ? mk_power(a) : a);
}
case LETEXPR:
return tc_expr(t->x_body, tc_letdefs(t->x_defs, e));
case IF: {
type a, b;
tc_pred(t->x_if, e);
a = tc_expr(t->x_then, e);
b = tc_expr(t->x_else, e);
if (unify(a, b))
return type_union(a, arid, b, arid);
else {
tc_error(t->x_loc,
"Type mismatch in conditional expression");
tc_e_etc("Expression: %z", t);
tc_e_etc("Then type: %t", a);
tc_e_etc("Else type: %t", b);
tc_e_end();
return err_type;
}
}
default:
bad_tag("tc_expr", t->x_kind);
/* dummy */ return (type) NULL;
}
}
