static void declare_scheduler_interface(data_declaration task_decl) { region r = parse_region; location loc = task_decl->ast->location; word task_name; interface_ref task_interface; rp_interface task_uses; int osection; /* We save the task's replacement interface in its interface field... */ if (task_decl->interface) return; /* Build the (uses) 'interface Scheduler as X' ast, declare the interface. */ /* This specific AST structure is assumed in wire_scheduler below */ task_name = new_word(r, loc, str2cstring(r, task_decl->name)); task_interface = new_interface_ref(r, loc, make_scheduler_interfacedef_name(loc), NULL, task_name, NULL, NULL, NULL); osection = current.spec_section; current.spec_section = spec_uses; declare_interface_ref(task_interface, NULL, current.container->env, NULL); current.spec_section = osection; task_decl->interface = task_interface->ddecl; /* Build the 'uses <interface>' AST, add it to the component */ task_uses = new_rp_interface(r, loc, TRUE, CAST(declaration, task_interface)); all_tasks = declaration_chain(CAST(declaration, task_uses), all_tasks); }
void add_cdecls(declaration cdecls) { all_cdecls = declaration_chain(all_cdecls, CAST(declaration, cdecls)); }
static expression build_taskid(module m, data_declaration taskdecl) { /* Build a unique identifier for a task whose declaration is taskdecl, in module m. Method: we add enum { m$taskdecl = unique("task-unique-string") }; to all_cdecls and return an identifier-expression referring to m$taskdecl */ location loc = taskdecl->ast->location; region r = parse_region; cstring idname; enumerator idast; struct data_declaration tempdecl; enum_ref idenum; tag_declaration enumdecl; data_decl iddecl; expression unique_id, unique_fn, unique_args, use_id; cstring silly_name; identifier_declarator silly_id; declarator silly_d; type_element silly_modifiers; rid silly_typedef; type silly_type; variable_decl silly_vd; data_decl silly_decl; /* Build unique("task-unique-string") */ unique_fn = build_identifier(r, loc, magic_unique); unique_args = build_string(r, loc, scheduler_unique_name); default_conversion(unique_args); unique_id = build_function_call(r, loc, unique_fn, unique_args); /* Build, declare enumerator taskdecl */ idname = str2cstring(r, taskdecl->name); idast = new_enumerator(r, loc, idname, unique_id, NULL); init_data_declaration(&tempdecl, CAST(declaration, idast), idname.data, int_type); tempdecl.kind = decl_constant; tempdecl.definition = tempdecl.ast; tempdecl.value = unique_id->cst; idast->ddecl = declare(m->ienv, &tempdecl, FALSE); /* Build the enum declaration */ idenum = new_enum_ref(r, loc, NULL, NULL, NULL, TRUE); idenum->fields = CAST(declaration, idast); idenum->tdecl = enumdecl = declare_tag(idenum); layout_enum_start(enumdecl); enumdecl->definition = idenum; enumdecl->defined = TRUE; layout_enum_end(enumdecl); /* Build the expression we will use in the wiring. */ use_id = build_identifier(r, loc, idast->ddecl); /* Hack: the use_id expression needs to be in the module's AST so that we do instantiation and constant folding on it. We build a silly typedef for that purpose: typedef int __nesc_sillytask_taskdecl[use_id] */ silly_name = alloc_cstring(r, strlen(taskdecl->name) + 17); sprintf(silly_name.data, "__nesc_sillytask_%s", taskdecl->name); silly_id = new_identifier_declarator(r, loc, silly_name); silly_type = make_array_type(int_type, use_id); type2ast(r, loc, silly_type, CAST(declarator, silly_id), &silly_d, &silly_modifiers); silly_typedef = new_rid(r, loc, RID_TYPEDEF); silly_vd = new_variable_decl(r, loc, silly_d, NULL, NULL, NULL, NULL/*ddecl*/); init_data_declaration(&tempdecl, CAST(declaration, silly_vd), silly_name.data, silly_type); tempdecl.kind = decl_typedef; tempdecl.definition = tempdecl.ast; silly_vd->ddecl = declare(m->ienv, &tempdecl, FALSE); silly_vd->declared_type = silly_type; silly_decl = new_data_decl(r, loc, type_element_chain(CAST(type_element, silly_typedef), silly_modifiers), CAST(declaration, silly_vd)); m->decls = declaration_chain(CAST(declaration, silly_decl), m->decls); /* Build the declaration and add it to the module's decls */ iddecl = new_data_decl(r, loc, CAST(type_element, idenum), NULL); m->decls = declaration_chain(CAST(declaration, iddecl), m->decls); return use_id; }