static void init_primary_helper(uint32_t pageable_part, uint32_t nsec_entry)
{
/*
* Mask asynchronous exceptions before switch to the thread vector
* as the thread handler requires those to be masked while
* executing with the temporary stack. The thread subsystem also
* asserts that IRQ is blocked when using most if its functions.
*/
thread_set_exceptions(THREAD_EXCP_ALL);
init_vfp_sec();
init_runtime(pageable_part);
IMSG("Initializing (%s)\n", core_v_str);
thread_init_primary(generic_boot_get_handlers());
thread_init_per_cpu();
init_sec_mon(nsec_entry);
main_init_gic();
init_vfp_nsec();
if (init_teecore() != TEE_SUCCESS)
panic();
DMSG("Primary CPU switching to normal world boot\n");
}
bool codegen(ast_t* program, pass_opt_t* opt)
{
if(opt->verbosity >= VERBOSITY_MINIMAL)
fprintf(stderr, "Generating\n");
pony_mkdir(opt->output);
compile_t c;
memset(&c, 0, sizeof(compile_t));
genned_strings_init(&c.strings, 64);
ffi_decls_init(&c.ffi_decls, 64);
if(!init_module(&c, program, opt))
return false;
init_runtime(&c);
genprim_reachable_init(&c, program);
bool ok;
if(c.opt->library)
ok = genlib(&c, program);
else
ok = genexe(&c, program);
codegen_cleanup(&c);
return ok;
}
int main(int argc, char **argv) {
init_runtime();
//env_dump(globals);
//symtab_dump();
printf("\nREADER TEST:\n");
value_prn(reader_read(" 135 "));
value_prn(reader_read(" -35 "));
value_prn(reader_read(" foo'bah "));
value_prn(reader_read(" [1 23 4]"));
value_prn(reader_read(" [1 23 4 55 six 7 eight]"));
value_prn(reader_read(" 'barf "));
value_prn(reader_read(" [1 23 [4 55 'six 7] \"eight\" 9]"));
value_prn(reader_read(" {foo=bar baz=\"barf\" zoo=1221}"));
/* Output expected:
READER TEST:
135
-35
foo'bah
[1 23 4]
[1 23 4 55 six 7 eight]
[quote barf]
[1 23 [4 55 [quote six] 7] eight 9]
{foo=bar baz=barf zoo=1221}
*/
return 0;
}
bool codegen(ast_t* program, pass_opt_t* opt)
{
printf("Generating\n");
pony_mkdir(opt->output);
compile_t c;
memset(&c, 0, sizeof(compile_t));
init_module(&c, program, opt);
init_runtime(&c);
genprim_builtins(&c);
// Emit debug info for this compile unit.
dwarf_init(&c.dwarf, c.opt, c.builder, c.target_data, c.module);
dwarf_compileunit(&c.dwarf, program);
bool ok;
if(c.opt->library)
ok = genlib(&c, program);
else
ok = genexe(&c, program);
codegen_cleanup(&c);
return ok;
}
int main (int argc, char const *argv[]) {
void *literals[] = {
(void *) "the answer is:",
(void *) "print",
(void *) 30,
(void *) 2
};
byte instructions[] = {
PUSH_SELF,
PUSH_STRING, 0,
CALL, 1, 1,
PUSH_NUMBER, 2,
PUSH_NUMBER, 3,
ADD,
SET_LOCAL, 0,
PUSH_BOOL, 0,
JUMP_UNLESS, 6,
PUSH_SELF,
GET_LOCAL, 0,
CALL, 1, 1,
RETURN
};
init_runtime();
run(literals, instructions);
destroy_runtime();
return 0;
}
/**
* Function for getting free/busy information.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param start time_t variable specifying start and end for range. Both
* are included in range.
* @param end time_t variable specifying start and end for range. Both
* are included in range.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_freebusy(response *result,
time_t start,
time_t end,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
if (!result) {
result = malloc(sizeof(response *));
memset(result, '\0', sizeof(response *));
}
init_caldav_settings(&settings);
settings.ACTION = FREEBUSY;
settings.start = start;
settings.end = end;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
result->msg = NULL;
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
result->msg = g_strdup(settings.file);
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
int main (int argc, char const *argv[]) {
void *literals[] = LITERALS;
byte instructions[] = INSTRUCTIONS;
init_runtime();
run(literals, instructions);
destroy_runtime();
return 0;
}
bool codegen_gen_test(compile_t* c, ast_t* program, pass_opt_t* opt,
pass_id last_pass)
{
if(last_pass < PASS_REACH)
{
memset(c, 0, sizeof(compile_t));
genned_strings_init(&c->strings, 64);
ffi_decls_init(&c->ffi_decls, 64);
if(!init_module(c, program, opt))
return false;
init_runtime(c);
genprim_reachable_init(c, program);
const char* main_actor = c->str_Main;
const char* env_class = c->str_Env;
ast_t* package = ast_child(program);
ast_t* main_def = ast_get(package, main_actor, NULL);
if(main_def == NULL)
return false;
ast_t* main_ast = type_builtin(opt, main_def, main_actor);
ast_t* env_ast = type_builtin(opt, main_def, env_class);
if(lookup(opt, main_ast, main_ast, c->str_create) == NULL)
return false;
reach(c->reach, main_ast, c->str_create, NULL, opt);
reach(c->reach, env_ast, c->str__create, NULL, opt);
reach_done(c->reach, c->opt);
}
if(opt->limit == PASS_REACH)
return true;
if(last_pass < PASS_PAINT)
paint(&c->reach->types);
if(opt->limit == PASS_PAINT)
return true;
if(!gentypes(c))
return false;
return true;
}
/**
* Function for modifying a task.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_tasks_modify_object(const char* object,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
init_caldav_settings(&settings);
settings.file = g_strdup(object);
settings.ACTION = MODIFYTASKS;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
SMC::SMC ()
{
if (!initialized) {
init_runtime();
init_stencil();
init_chemistry();
init_variables();
initialized = true;
}
build_multifabs();
init_from_scratch();
wt_fb1 = wt_fb2 = wt_chem1 = wt_chem2 = wt_hypdiff = 0.0;
}
/**
* Function to test wether a calendar resource is CalDAV enabled or not.
* @param URL Defines CalDAV resource. Receiver is responsible for
* freeing the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @result 0 (zero) means no CalDAV support, otherwise CalDAV support
* detechted.
*/
int caldav_enabled_resource(const char* URL, runtime_info* info) {
CURL* curl;
caldav_settings settings;
struct config_data data;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
init_caldav_settings(&settings);
parse_url(&settings, URL);
curl = get_curl(&settings);
if (!curl) {
info->error->code = -1;
info->error->str = g_strdup("Could not initialize libcurl");
settings.file = NULL;
return TRUE;
}
if (info->options->trace_ascii)
data.trace_ascii = 1;
else
data.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
if (info->options->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
gboolean res = test_caldav_enabled(curl, &settings, info->error);
free_caldav_settings(&settings);
curl_easy_cleanup(curl);
return (res && (info->error->code == 0 || info->error->code == 200)) ? 1 : 0;
}
bool codegen(ast_t* program, pass_opt_t* opt)
{
PONY_LOG(opt, VERBOSITY_MINIMAL, ("Generating\n"));
pony_mkdir(opt->output);
compile_t c;
memset(&c, 0, sizeof(compile_t));
init_module(&c, program, opt);
init_runtime(&c);
genprim_reachable_init(&c, program);
bool ok;
if(c.opt->library)
ok = genlib(&c, program);
else
ok = genexe(&c, program);
codegen_cleanup(&c);
return ok;
}
