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;
}
