// open that puppy!!! gets the file opened and the data structs read for use
bool upkg::open(file_reader * p_reader)
{
if (pkg_opened) // is there a pkg opened already?
return false; // if so, don't try to open another one!
if (p_reader == NULL)
return false;
reader = p_reader;
if (reader->read(header, 4096) < 4096) {
return false;
}
if (load_upkg() != 0) {
return false;
}
pkg_opened = 1;
get_names(); // this order is important.
get_imports();
get_exports();
get_types();
return true;
}
int synthaxe_error(char *str)
{
char *tab_synthaxe[20];
int i;
int alright;
alright = 0;
i = 0;
init_types(tab_synthaxe);
early_space(str);
while (tab_synthaxe[i] != NULL)
{
if (strncmp(str, tab_synthaxe[i], strlen(tab_synthaxe[i])) == 0)
{
alright = 1;
printf("Déclaration de la %s %s de type %s\n",
get_parenthesis(get_name(str)) ? "variable" : "fonction",
get_name(str), get_types(str,tab_synthaxe));
break;
}
i++;
}
if (alright == 0)
return (fprintf(stderr, "%s n'est pas un type valide \n", str));
return (check_integrity(str, strlen(tab_synthaxe[i])));
}
PyObject* info( int type, const char *name)
{
PyObject* output = NULL;
switch(type) {
/* display requested info */
case TYPE:
output = get_types(name, policy);
break;
case ATTRIBUTE:
output = get_attribs(name, policy);
break;
case ROLE:
output = get_roles(name, policy);
break;
case USER:
output = get_users(name, policy);
break;
case CLASS:
output = get_classes(name, policy);
break;
case BOOLEAN:
output = get_booleans(name, policy);
break;
case PORT:
output = get_ports(name, policy);
break;
default:
errno = EINVAL;
PyErr_SetString(PyExc_RuntimeError,strerror(errno));
break;
}
return output;
}
format unification_app_mismatch_exception::pp(formatter const & fmt, options const & opts) const {
unsigned indent = get_pp_indent(opts);
auto const & ctx = get_context();
expr const & app = get_expr();
auto args_it = get_args().begin();
auto args_end = get_args().end();
auto types_it = get_types().begin();
format app_fmt = fmt(ctx, app, false, opts);
format r = format{format(what()), nest(indent, compose(line(), app_fmt))};
format fun_type_fmt = fmt(ctx, *types_it, false, opts);
r += compose(line(), format("Function type:"));
r += nest(indent, compose(line(), fun_type_fmt));
++args_it;
++types_it;
if (get_args().size() > 2)
r += compose(line(), format("Arguments types:"));
else
r += compose(line(), format("Argument type:"));
for (; args_it != args_end; ++args_it, ++types_it) {
format arg_fmt = fmt(ctx, *args_it, false, opts);
format type_fmt = fmt(ctx, *types_it, false, opts);
r += nest(indent, compose(line(), group(format{arg_fmt, space(), colon(), nest(indent, format{line(), type_fmt})})));
}
r += pp_elaborator_state(fmt, get_elaborator(), opts);
return r;
}
int get_rule(Resources *res, TStack *stack) {
args_assert(res != NULL && stack != NULL, INTERNAL_ERROR);
int values [MAX_RULE_LENGTH + 1];
int i;
int err = get_types(&res->struct_buff, stack, values);
catch_internal_error(err, INTERNAL_ERROR, "Failed to get types of token");
catch_syntax_error(err, SYNTAX_ERROR, "Failed to get types of token", 1);
#if DEBUG
char *short_rule_symbol[2];
short_rule_symbol[0] = "id";
short_rule_symbol[1] = "li";
char * long_rule_symbol[11];
long_rule_symbol[0] = "RVALUE == RVALUE -> RVALUE";
long_rule_symbol[1] = "RVALUE > RVALUE -> RVALUE";
long_rule_symbol[2] = "RVALUE < RVALUE -> RVALUE";
long_rule_symbol[3] = "RVALUE >= RVALUE -> RVALUE";
long_rule_symbol[4] = "RVALUE <= RVALUE -> RVALUE";
long_rule_symbol[5] = "RVALUE != RVALUE -> RVALUE";
long_rule_symbol[6] = "RVALUE + RVALUE -> RVALUE";
long_rule_symbol[7] = "RVALUE - RVALUE -> RVALUE";
long_rule_symbol[8] = "RVALUE * RVALUE -> RVALUE";
long_rule_symbol[9] = "RVALUE / RVALUE -> RVALUE";
long_rule_symbol[10] = "( RVALUE ) -> RVALUE";
#endif
if (values[0] == 1) {
for (i = 0; i < 2; i++) {
if (short_rules[i] == values[1]) {
#if DEBUG
debug_print("%s %s %s\n", "APPLIED RULE:", short_rule_symbol[i], "-> RVALUE");
#endif
return short_reduction(res, stack);
}
}
return SYNTAX_ERROR;
} else if (values[0] == 3) {
for (i = 0; i < 11; i++) {
if (!(memcmp(long_rules[i], &values[1], sizeof(long_rules[i])))) {
#if DEBUG
debug_print("%s %s\n", "APPLIED RULE:", long_rule_symbol[i]);
#endif
return long_reduction(res, stack, i);
}
}
return SYNTAX_ERROR;
} else
return SYNTAX_ERROR;
}
foreign_t del_handler(term_t server, term_t msg, term_t types)
{
my_server_thread s;
char *pattern, *typespec;
char buffer[256]; // !! space for up to 255 arguments
int rc;
rc = get_server(server,&s)
&& get_msg(msg,&pattern)
&& get_types(types,buffer,256,&typespec);
if (rc) lo_server_del_method(s->s,pattern,typespec);
return rc;
}
foreign_t add_handler(term_t server, term_t msg, term_t types, term_t goal)
{
my_server_thread s;
lo_method method;
char *pattern, *typespec;
char buffer[256]; // !! space for up to 255 arguments
int rc;
rc = get_server(server,&s)
&& get_msg(msg,&pattern)
&& get_types(types,buffer,256,&typespec);
if (rc) {
record_t goal_record=PL_record(goal);
method = lo_server_add_method(s->s, pattern, typespec, prolog_handler, (void *)goal_record);
}
return rc;
}
void tab_fill(t_argtab *tab, int argc, char *argv[])
{
int i;
int get;
i = 0;
while (i < argc)
{
get = get_types(argv[i]);
tab_distrib(tab, get, argv[i]);
if (get == 3)
tab->error.data[tab->error.size++] = argv[i];
i++;
}
i = 0;
while (i++ < tab->file.size)
tab->file.ptr[i - 1] = &tab->file.data[i - 1];
i = 0;
while (i++ < tab->dir.size)
tab->dir.ptr[i - 1] = &tab->dir.data[i - 1];
}
static QStringList supportedHashTypes(const QString &provider)
{
return get_types(get_hash_types, provider);
}
static QStringList supportedMACTypes(const QString &provider)
{
return get_types(get_mac_types, provider);
}
static QStringList supportedCipherTypes(const QString &provider)
{
return get_types(get_cipher_types, provider);
}
int pg_cmd(db_cmd_t* cmd)
{
struct pg_cmd* pcmd;
pcmd = (struct pg_cmd*)pkg_malloc(sizeof(struct pg_cmd));
if (pcmd == NULL) {
ERR("postgres: No memory left\n");
goto error;
}
memset(pcmd, '\0', sizeof(struct pg_cmd));
if (db_drv_init(&pcmd->gen, pg_cmd_free) < 0) goto error;
switch(cmd->type) {
case DB_PUT:
if (build_insert_sql(&pcmd->sql_cmd, cmd) < 0) goto error;
break;
case DB_DEL:
if (build_delete_sql(&pcmd->sql_cmd, cmd) < 0) goto error;
break;
case DB_GET:
if (build_select_sql(&pcmd->sql_cmd, cmd) < 0) goto error;
break;
case DB_UPD:
if (build_update_sql(&pcmd->sql_cmd, cmd) < 0) goto error;
break;
case DB_SQL:
pcmd->sql_cmd.s = (char*)pkg_malloc(cmd->table.len + 1);
if (pcmd->sql_cmd.s == NULL) {
ERR("postgres: Out of private memory\n");
goto error;
}
memcpy(pcmd->sql_cmd.s,cmd->table.s, cmd->table.len);
pcmd->sql_cmd.s[cmd->table.len] = '\0';
pcmd->sql_cmd.len = cmd->table.len;
break;
}
DB_SET_PAYLOAD(cmd, pcmd);
/* Create parameter arrays for PostgreSQL API functions */
if (create_pg_params(cmd) < 0) goto error;
/* Generate a unique name for the command on the server */
if (gen_cmd_name(cmd) != 0) goto error;
/* Upload the command to the server */
if (upload_cmd(cmd) != 0) goto error;
/* Obtain the description of the uploaded command, this includes
* information about result and parameter fields */
if (get_types(cmd) != 0) goto error;
/* Update fields based on the information retrieved from the */
if (pg_resolve_param_oids(cmd->vals, cmd->match,
cmd->vals_count, cmd->match_count,
pcmd->types))
goto error;
if (pg_resolve_result_oids(cmd->result, cmd->result_count, pcmd->types))
goto error;
if (check_types(cmd)) goto error;
return 0;
error:
if (pcmd) {
DB_SET_PAYLOAD(cmd, NULL);
free_pg_params(&pcmd->params);
if (pcmd->types) PQclear(pcmd->types);
if (pcmd->name) pkg_free(pcmd->name);
if (pcmd->sql_cmd.s) pkg_free(pcmd->sql_cmd.s);
db_drv_free(&pcmd->gen);
pkg_free(pcmd);
}
return -1;
}
/* get all the data in .debug_types */
extern void
print_types(Dwarf_Debug dbg, enum type_type_e type_type)
{
Dwarf_Type *typebuf = NULL;
Dwarf_Signed count = 0;
Dwarf_Signed i = 0;
char *name = NULL;
int gtres = 0;
char *section_name = NULL;
char *offset_err_name = NULL;
char *section_open_name = NULL;
char *print_name_prefix = NULL;
int (*get_types) (Dwarf_Debug, Dwarf_Type **, Dwarf_Signed *,
Dwarf_Error *) = 0;
int (*get_offset) (Dwarf_Type, char **, Dwarf_Off *, Dwarf_Off *,
Dwarf_Error *) = NULL;
int (*get_cu_offset) (Dwarf_Type, Dwarf_Off *, Dwarf_Error *) =
NULL;
void (*dealloctype) (Dwarf_Debug, Dwarf_Type *, Dwarf_Signed) =
NULL;
/* Do nothing if in check mode */
if (!do_print_dwarf) {
return;
}
if (type_type == DWARF_PUBTYPES) {
section_name = ".debug_pubtypes";
offset_err_name = "dwarf_pubtype_name_offsets";
section_open_name = "dwarf_get_pubtypes";
print_name_prefix = "pubtype";
get_types = dwarf_get_pubtypes;
get_offset = dwarf_pubtype_name_offsets;
get_cu_offset = dwarf_pubtype_cu_offset;
dealloctype = dwarf_pubtypes_dealloc;
} else {
/* SGI_TYPENAME */
section_name = ".debug_typenames";
offset_err_name = "dwarf_type_name_offsets";
section_open_name = "dwarf_get_types";
print_name_prefix = "type";
get_types = dwarf_get_types;
get_offset = dwarf_type_name_offsets;
get_cu_offset = dwarf_type_cu_offset;
dealloctype = dwarf_types_dealloc;
}
gtres = get_types(dbg, &typebuf, &count, &err);
if (gtres == DW_DLV_ERROR) {
print_error(dbg, section_open_name, gtres, err);
} else if (gtres == DW_DLV_NO_ENTRY) {
/* no types */
} else {
Dwarf_Unsigned maxoff = get_info_max_offset(dbg);
/* Before July 2005, the section name was printed
unconditionally, now only prints if non-empty section really
exists. */
printf("\n%s\n", section_name);
for (i = 0; i < count; i++) {
int tnres = 0;
int cures3 = 0;
Dwarf_Off die_off = 0;
Dwarf_Off cu_off = 0;
Dwarf_Off global_cu_off = 0;
tnres =
get_offset(typebuf[i], &name, &die_off, &cu_off, &err);
deal_with_name_offset_err(dbg, offset_err_name, name,
die_off, tnres, err);
cures3 = get_cu_offset(typebuf[i], &global_cu_off, &err);
if (cures3 != DW_DLV_OK) {
print_error(dbg, "dwarf_var_cu_offset", cures3, err);
}
print_pubname_style_entry(dbg,
print_name_prefix,
name, die_off, cu_off,
global_cu_off, maxoff);
/* print associated die too? */
}
dealloctype(dbg, typebuf, count);
}
} /* print_types() */
int main(int argc, char **argv){
type_info tinfo;
int flag = 1;
int file_counter=0;
int nsample = 0;
if ( argc != 4 ){
fprintf(stderr, "Arguments: <type> <numb. of blocks per sample> <dir>\n");
exit(EXIT_FAILURE);
}
char type = argv[1][0];
int num_blocks_per_sample = atoi(argv[2]);
int dir = atoi(argv[3]);
double dt = get_types(&tinfo, type, "00001_mol.conf");
double **omega = sep_matrix(num_blocks_per_sample, tinfo.nmols_type);
double *acf = sep_vector(num_blocks_per_sample);
while (1) {
printf("\r");
printf("Processing sample %d ", nsample);
fflush(stdout);
for ( int n=0; n<num_blocks_per_sample; n++ ){
char file[256];
sprintf(file, "%05d_mol.conf", file_counter);
file_counter++;
if ( file_exists(file) == 1 ){
read_entry_from_file(omega, n, file, dir, tinfo);
flag = 1;
}
else {
flag = 0;
break;
}
}
if ( flag == 1 ){
for ( int i=0; i<tinfo.nmols_type; i++ )
for ( int k=0; k<num_blocks_per_sample; k++ )
for ( int kk=0; kk<num_blocks_per_sample-k; kk++ )
acf[k] += omega[kk][i]*omega[k+kk][i];
nsample++;
}
else if ( flag == 0 ) break;
}
printf("\n");
FILE *fout = fopen("single_mavacf.dat", "w");
if ( fout == NULL )
sep_error("Couldn't open file - BAILING OUT");
for ( int k=0; k< num_blocks_per_sample; k++ ){
double t = dt*(k+0.5);
double fac = 1.0/((num_blocks_per_sample-k)*tinfo.nmols_type*nsample);
fprintf(fout, "%f %f\n", t, acf[k]*fac);
}
fclose(fout);
sep_free_matrix(omega, num_blocks_per_sample);
free(acf);
return 0;
}
isc_result_t
acl_configure_zone_ssutable(const char *policy_str, dns_zone_t *zone)
{
isc_result_t result = ISC_R_SUCCESS;
cfg_parser_t *parser = NULL;
const cfg_listelt_t *el;
cfg_obj_t *policy = NULL;
dns_ssutable_t *table = NULL;
ld_string_t *new_policy_str = NULL;
isc_mem_t *mctx;
REQUIRE(zone != NULL);
mctx = dns_zone_getmctx(zone);
if (policy_str == NULL)
goto cleanup;
CHECK(bracket_str(mctx, policy_str, &new_policy_str));
CHECK(cfg_parser_create(mctx, dns_lctx, &parser));
result = cfg_parse_strbuf(parser, str_buf(new_policy_str), &cfg_type_update_policy, &policy);
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_ERROR,
"failed to parse policy string");
goto cleanup;
}
CHECK(dns_ssutable_create(mctx, &table));
for (el = cfg_list_first(policy); el != NULL; el = cfg_list_next(el)) {
const cfg_obj_t *stmt;
isc_boolean_t grant;
unsigned int match_type;
dns_fixedname_t fname, fident;
dns_rdatatype_t *types;
unsigned int n;
types = NULL;
stmt = cfg_listelt_value(el);
CHECK(get_mode(stmt, &grant));
CHECK(get_match_type(stmt, &match_type));
CHECK(get_fixed_name(stmt, "identity", &fident));
/* Use zone name for 'zonesub' match type */
result = get_fixed_name(stmt, "name", &fname);
if (result == ISC_R_NOTFOUND &&
match_type == DNS_SSUMATCHTYPE_SUBDOMAIN) {
dns_fixedname_init(&fname);
CHECK(dns_name_copy(dns_zone_getorigin(zone),
dns_fixedname_name(&fname),
&fname.buffer));
}
else if (result != ISC_R_SUCCESS)
goto cleanup;
CHECK(get_types(mctx, stmt, &types, &n));
if (match_type == DNS_SSUMATCHTYPE_WILDCARD &&
!dns_name_iswildcard(dns_fixedname_name(&fname))) {
char name[DNS_NAME_FORMATSIZE];
dns_name_format(dns_fixedname_name(&fname), name,
DNS_NAME_FORMATSIZE);
dns_zone_log(zone, ISC_LOG_ERROR,
"invalid update policy: "
"name '%s' is expected to be a wildcard",
name);
CLEANUP_WITH(DNS_R_BADNAME);
}
result = dns_ssutable_addrule(table, grant,
dns_fixedname_name(&fident),
match_type,
dns_fixedname_name(&fname),
n, types);
SAFE_MEM_PUT(mctx, types, n * sizeof(dns_rdatatype_t));
if (result != ISC_R_SUCCESS)
goto cleanup;
}
cleanup:
if (result == ISC_R_SUCCESS)
dns_zone_setssutable(zone, table);
str_destroy(&new_policy_str);
if (policy != NULL)
cfg_obj_destroy(parser, &policy);
if (parser != NULL)
cfg_parser_destroy(&parser);
if (table != NULL)
dns_ssutable_detach(&table);
return result;
}
