/* * Copyright (c) 1999 The University of Utah and * the Computer Systems Laboratory at the University of Utah (CSL). * * This file is part of Flick, the Flexible IDL Compiler Kit. * * Flick is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * Flick is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Flick; see the file COPYING. If not, write to * the Free Software Foundation, 59 Temple Place #330, Boston, MA 02111, USA. */ #include #include #include #include #include struct be_event *be_file_prologue_handler(struct be_handler *bh, struct be_event *be) { struct be_file *file = (struct be_file *)bh->get_parent(); struct be_state *state = file->get_state(); switch( be->id ) { case BEFE_INIT: { struct scml_scope *scope; if( (scope = state->get_scml_root()-> find_child(flick_asprintf("%s_file_defs", file->get_name()))) ) { struct scml_context *sc; sc = new scml_context; sc->set_scope(scope); sc->exec_cmd("prologue", 0, NULL); delete sc; } break; } default: break; } return( be ); } struct be_handler be_file_prologue("prologue", 128, be_file_prologue_handler); struct be_event *be_file_header_defs_handler(struct be_handler *bh, struct be_event *be) { struct be_file *file = (struct be_file *)bh->get_parent(); struct be_state *state = file->get_state(); pres_c_1 *pres = state->get_pres(); switch( be->id ) { case BEFE_BODY: { unsigned int i; w_header_includes(pres); for (i = 0; i < pres->cast.cast_scope_len; i++) { if( !(pres->meta_data.channels.channels_val [pres->cast.cast_scope_val[i].channel]. flags & DATA_CHANNEL_SQUELCHED) ) { cast_w_def(&pres->cast.cast_scope_val[i], 0); w_printf("\n"); } } break; } default: break; } return( be ); } struct be_handler be_file_header_defs("header defs", 0, be_file_header_defs_handler); struct be_event *be_file_pre_stubs_handler(struct be_handler *bh, struct be_event *be) { struct be_file *file = (struct be_file *)bh->get_parent(); struct be_state *state = file->get_state(); switch( be->id ) { case BEFE_BODY: make_interface_graph(state->get_pres()); cast_w_scope(&state->get_pres()->pres_cast, 0); do_main_output(state->get_pres()); if( state->get_pres_collection() ) state->get_pres_collection()-> implement(state->get_pres()); break; default: break; } return( be ); } struct be_handler be_file_pre_stubs("pre stubs", 1, be_file_pre_stubs_handler); struct be_event *be_file_gen_stubs_handler(struct be_handler *bh, struct be_event *be) { struct be_file *file = (struct be_file *)bh->get_parent(); struct be_state *state = file->get_state(); pres_c_1 *pres = state->get_pres(); struct mu_stub_info_node *msi; unsigned int i; if( be->id != BEFE_BODY ) return be; /* Print the regular presented stubs out. This is the first pass. */ for (i = 0; i < pres->stubs.stubs_len; i++) { data_channel_index channel; switch (pres->stubs.stubs_val[i].kind) { case PRES_C_MARSHAL_STUB: case PRES_C_UNMARSHAL_STUB: /* We never output m/u stubs on the first pass. */ channel = pres->stubs_cast.cast_scope_val[ pres->stubs.stubs_val[i]. pres_c_stub_u.mstub.c_func].channel; assert(pres->meta_data.channels.channels_val[channel]. flags & DATA_CHANNEL_SQUELCHED); continue; case PRES_C_CLIENT_STUB: channel = pres->stubs_cast.cast_scope_val[ pres->stubs.stubs_val[i]. pres_c_stub_u.cstub.c_func].channel; break; case PRES_C_CLIENT_SKEL: channel = pres->stubs_cast.cast_scope_val[ pres->stubs.stubs_val[i]. pres_c_stub_u.cskel.c_def].channel; break; case PRES_C_SERVER_SKEL: channel = pres->stubs_cast.cast_scope_val[ pres->stubs.stubs_val[i]. pres_c_stub_u.sskel.c_def].channel; break; case PRES_C_SEND_STUB: channel = pres->stubs_cast.cast_scope_val[ pres->stubs.stubs_val[i]. pres_c_stub_u.send_stub.c_func].channel; break; case PRES_C_RECV_STUB: channel = pres->stubs_cast.cast_scope_val[ pres->stubs.stubs_val[i]. pres_c_stub_u.recv_stub.c_func].channel; break; case PRES_C_MESSAGE_MARSHAL_STUB: channel = pres->stubs_cast.cast_scope_val[ pres->stubs.stubs_val[i]. pres_c_stub_u.mmstub.c_func].channel; break; case PRES_C_MESSAGE_UNMARSHAL_STUB: channel = pres->stubs_cast.cast_scope_val[ pres->stubs.stubs_val[i]. pres_c_stub_u.mustub.c_func].channel; break; case PRES_C_CONTINUE_STUB: channel = pres->stubs_cast.cast_scope_val[ pres->stubs.stubs_val[i]. pres_c_stub_u.continue_stub.c_func].channel; break; default: panic("Unknown PRES_C_STUB_KIND!"); break; } if (!(pres->meta_data.channels.channels_val[channel]. flags & DATA_CHANNEL_SQUELCHED)) w_stub(pres, i); } /* * This is the second pass - we output the marshal/unmarshal stubs that * we found were used while generating the regular presented stubs. */ if (!empty_list(state->get_mu_stub_list())) w_printf("\n" "/* Mandatory marshaling/unmarshaling stubs. */\n\n"); msi = (struct mu_stub_info_node *)state->get_mu_stub_list()->head; while( msi->link.succ ) { switch(msi->stub_kind) { case PRES_C_MARSHAL_STUB: w_marshal_stub(pres, *msi); break; case PRES_C_UNMARSHAL_STUB: w_unmarshal_stub(pres, *msi); break; default: warn(("Invalid stub kind %d found in set of used " "marshaling/unmarshaling stubs."), msi->stub_kind); } msi = (struct mu_stub_info_node *)msi->link.succ; } return( be ); } struct be_handler be_file_gen_stubs("gen stubs", 0, be_file_gen_stubs_handler); struct be_event *be_file_epilogue_handler(struct be_handler *bh, struct be_event *be) { struct be_file *file = (struct be_file *)bh->get_parent(); struct be_state *state = file->get_state(); switch( be->id ) { case BEFE_SHUTDOWN: { struct scml_scope *scope; if( (scope = state->get_scml_root()-> find_child(flick_asprintf("%s_file_defs", file->get_name()))) ) { struct scml_context *sc; sc = new scml_context; sc->set_scope(scope); sc->exec_cmd("epilogue", 0, NULL); delete sc; } break; } default: break; } return( be ); } struct be_handler be_file_epilogue("epilogue", -128, be_file_epilogue_handler);