Code write_stat(Pnode p)
{
/*
WRITE_STAT
/
/
N_SPECIFIER --> expr
/
/
[expr-filename]
*/
Value format;
int op;
Schema exprschema;
Code code = expr(p->child->brother, &exprschema);
if (p->child->child != NULL)
{
// Con specifier
code = appcode(code, specifier(p->child));
op = T_FPRINT;
}
else
{
// Senza specifier
op = T_PRINT;
}
format.sval = get_format(&exprschema);
free_schema(exprschema.next);
return concode(
code,
makecode1(op, format),
endcode()
);
}
Code tuple_const(Pnode p, Pschema s)
{
Pschema schema;
// Scorro tutti gli elementi della tupla
Code result = endcode();
Pnode elem;
for (elem = p->child; elem != NULL; elem = elem->brother)
{
Code elemcode;
switch (elem->type)
{
case N_INTCONST:
case N_BOOLCONST:
elemcode = makecode1(T_IATTR, elem->value); break;
case N_STRCONST:
elemcode = makecode1(T_SATTR, elem->value); break;
default: noderror(elem);
}
if (result.head == NULL)
result = elemcode;
else
result = appcode(result, elemcode);
}
// Type checking
schema = tuple_to_schema(p);
if (!type_equal(schema, s))
semerror(p, "Incompatible tuples in table constant");
free_schema(schema);
return result;
}
Code assign_stat(Pnode p)
{
Psymbol symbol;
Code exprcode;
Schema exprschema;
/*
assign_stat
/
/
ID ---> expr
*/
// Semantica: Carico gli schemi di ID e expr
symbol = lookup(valname(p->child));
if (symbol == NULL)
semerror(p->child, "Undefined identifier in assignment");
exprcode = expr(p->child->brother, &exprschema);
// Type checking:
if (!type_equal(symbol->schema, &exprschema))
semerror(p->child->brother, "Incompatible types in assignment");
if (exprschema.next != NULL)
free_schema(exprschema.next);
Value v1; v1.ival = symbol->oid;
return concode(
exprcode,
makecode1(T_STO, v1),
endcode());
}
void free_schema(Pschema schema){
Pschema p = schema;
while (p != NULL){
if(p->child != NULL){
free_schema(p->child);
}
Pschema temp = p;
p = p->brother;
freemem((char *)temp, sizeof(Schema));
}
}
void eliminate(char *name)
{
int index;
Psymbol psymb, prec;
index = hash_function(name);
prec = psymb = symtab[index];
while(psymb != NULL)
{
if(psymb->schema->name == name)
{
if(psymb == prec)
symtab[index] = psymb->next;
else
prec->next = psymb->next;
free_schema(psymb->schema);
freemem(psymb, (int)sizeof(Symbol));
return;
}
prec = psymb;
psymb = psymb->next;
}
syserror("No name to be removed from symbol table");
}
void exec_rd(char* format, int pretty, FILE *in_file){
Pschema s = parse_schema(format);
input_schema(s, NULL, 0, pretty, in_file);
free_schema(last_parsed_format);
}
void exec_wr(char* format, int pretty, FILE *out){
Pschema s = parse_schema(format);
Odescr *op = top_tstack();
print_instance(op->inst.sval, s, NULL, 0, op->mode, pretty, out); // use the raw instance information
free_schema(last_parsed_format);
}
int
main(int argc, char **argv) {
// Parse options.
static struct option long_options[] = {
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
const char *options = "h";
char opt;
while ((opt = getopt_long(argc, argv, options, long_options, NULL)) != -1) {
switch (opt) {
case 'h':
usage(argv[0], EXIT_SUCCESS);
break;
default:
perr(argv[0], "unrecognized option '%c'\n", opt);
usage(argv[0], EXIT_FAILURE);
break;
}
}
int nargs = argc - optind;
if (nargs == 0 || nargs % 2 != 0) {
// Expected at least one column name, ACL path pair.
perr(argv[0], "missing required arguments\n");
exit(EXIT_FAILURE);
}
// Parse the input #db header and replay it.
char *header = read_header(stdin);
schema_t schema;
if (parse_header(header, &schema) != 0) {
perr(argv[0], "error parsing #db header\n");
exit(EXIT_FAILURE);
}
printf("%s\n", header);
int i;
// Initialize ACLs.
acls_t acls = {calloc(sizeof (netacl_t *), schema.ncols), 0};
for (i = optind; i < argc; i += 2) {
char *name = argv[i];
char *acl_path = argv[i+1];
column_t *column = get_column(&schema, name);
if (!column) {
fprintf(stderr, "column '%s' is not present\n", name);
exit(EXIT_FAILURE);
}
// Determine the maximum column index for which an ACL exists, so that we
// can short circuit tokenization later.
acls.size = MAX(column->index, acls.size);
int ret;
netacl_t *acl = malloc(sizeof (netacl_t));
if ((ret = netacl_from_path(acl_path, acl)) != 0) {
fprintf(stderr, "could not initialize ACL from path '%s'\n", acl_path);
exit(EXIT_FAILURE);
}
acls.acls[column->index - 1] = acl;
}
// Apply the ACLs to the input data.
filter(&acls);
#ifdef DEBUG
// Free things.
for (i = 0; i < acls.size; i++) {
if (acls.acls[i]) {
netacl_destroy(acls.acls[i]);
}
}
free(acls.acls);
free_schema(&schema);
free(header);
#endif
return 0;
}
