/*

* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

* System Includes

*

*/

#include <stdio.h>

#include <assert.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <time.h>

#include "rpc_util.h"

#include "rpc_pars.h"

#include "rpc_scan.h"

/*********************************************************************

 *

 * Local Includes

 *

 ********************************************************************/

#include "ae_component_rpc.h"

/*********************************************************************

 *

 * Definitions

 *

 ********************************************************************/

#define BANNER_START "/****************************************************************************************\n"

#define BANNER_LINE  " * "

#define BANNER_END   " ***************************************************************************************/\n"

/*********************************************************************

 *

 * Macro Functions

 *

 ********************************************************************/

#define O(x)	     f_print(fout,x);

/*********************************************************************

 *

 * Types

 *

 ********************************************************************/

typedef void (*header_func_t)(char *filename, definition *program);

typedef void (*footer_func_t)(definition *program);

typedef void (*proc_func_t)(definition *program,proc_list *proc, char *version);

/*********************************************************************

 *

 * Prototypes

 *

 ********************************************************************/

void open_input( char *infile, char *define );

void open_output( char *infile, char *outfile );

char *extendfile( char *file, char *ext );

char *locase( char *str);

// filename related helpers

void PrintStartDefs( definition *def );

void PrintEndDefs( definition *def );

void PrintIncludeInterfaceHeader();

// banners

void PrintFileBanner( char *filename );

void PrintBanner( char *title );

void PrintAutogenBanner( char *filename );

void PrintAutogenModBanner( char *filename );

// classname helpers

char *ComponentClassname( definition *def );

char *ClientComponentClassname( definition *def );

char *ServiceManagerClassname( definition *def );

// function helpers

void PrintClientStubSignature( int indent, char *classname, proc_list *proc );

void PrintComponentInstanceMethodSignature( char *classname, definition *program, proc_list *proc );

void PrintSetErrorValue( int indent, definition *program, proc_list *proc, char *error );

int IsSetErrorCallRequired( proc_list *proc );

void PrintServiceCheck( definition *program, proc_list *proc );

void PrintCallFromServiceStubToInstance( definition *program, proc_list *proc, char *extraargs );

void PrintCallFromServiceStubToStatic( definition *program, proc_list *proc, char *extra_args );

// misc helpers

char *ucase( char *str );

void trace( int indent, definition *program, proc_list *proc, char *fname, int enter );

// service stub implementations

void output_header_service_implementation( char *filename, definition *program );

void output_footer_service_implementation( definition *program );

void output_proc_service_implementation( definition *program, proc_list *proc, char *version );

void output_std_proc_service_implementation( definition *program, proc_list *proc );

void output_cstr_proc_service_implementation( definition *program, proc_list *proc );

void output_dstr_proc_service_implementation( definition *program, proc_list *proc );

void output_startup_proc_service_implementation( definition *program, proc_list *proc );

void output_shutdown_proc_service_implementation( definition *program, proc_list *proc );

void output_list_proc_service_implementation( definition *program, proc_list *proc );

void output_static_proc_service_implementation( definition *program, proc_list *proc );

// service manager class header

void output_header_svc_header( char *filename, definition *program );

void output_footer_svc_header( definition *program );

void output_proc_svc_header( definition *program, proc_list *proc, char *version );

// service manager class cpp

void output_header_svc_cpp( char *filename, definition *program );

void output_footer_svc_cpp( definition *program );

void output_proc_svc_cpp( definition *program, proc_list *proc, char *version );

// server component class header

void output_header_inst_header( char *filename, definition *program );

void output_footer_inst_header( definition *program );

void output_proc_inst_header( definition *program, proc_list *proc, char *version );

// server component class cpp

void output_header_inst_cpp( char *filename, definition *program );

void output_footer_inst_cpp( definition *program );

void output_proc_inst_cpp( definition *program, proc_list *proc, char *version );

// client component stub class header

void output_header_stub_header( char *filename, definition *program );

void output_footer_stub_header( definition *program );

void output_proc_stub_header( definition *program, proc_list *proc, char *version );

// client component stub class cpp

void output_header_stub_cpp( char *filename, definition *program );

void output_footer_stub_cpp( definition *program );

void output_proc_stub_cpp( definition *program, proc_list *proc, char *version );

void output_proc_stub_cpp_std( definition *program, proc_list *proc, char *version );

/*********************************************************************

 *

 * Static Vars

 *

 ********************************************************************/

static header_func_t hf[] = { output_header_service_implementation, output_header_svc_header, output_header_svc_cpp,	output_header_inst_header,	output_header_inst_cpp,	output_header_stub_header,	output_header_stub_cpp	};

static footer_func_t ff[] = { output_footer_service_implementation, output_footer_svc_header, output_footer_svc_cpp,	output_footer_inst_header,	output_footer_inst_cpp,	output_footer_stub_header,	output_footer_stub_cpp	};

static proc_func_t   pf[] = { output_proc_service_implementation,   output_proc_svc_header,	  output_proc_svc_cpp,		output_proc_inst_header,	output_proc_inst_cpp,	output_proc_stub_header,	output_proc_stub_cpp	};

static char *input_filename;

static int gtype;

static int trace_points[7] = { 0 };

/*********************************************************************

 *

 * ae_output_rpc_file()

 *

 ********************************************************************/

void ae_output_rpc_file( char *infile, char *outfile, int type )

{

	char tmpfilename[128];

	char *outfilename;

	int foundprogram = 0;

	definition *def, *def_program;

	version_list *vp;

	proc_list *proc;

	// save some stuff for use down the chain

	input_filename = infile;

	gtype = type;

	// open the input file 

	open_input( infile, "-DRPC_SVC" );

	// look for the program definition

	while( (def = get_definition()) ) {

		if( def->def_kind == DEF_PROGRAM ) {

			def_program = def;

			foundprogram++;

		}

	}

	// if there is no program then exit 

	if( foundprogram == 0 ) {

		return;

	}

	// open the output file

	if( (type == TYPE_SVC_MGR_H) || (type == TYPE_SVC_MGR_C) ) {

		sprintf( tmpfilename, "%s", ServiceManagerClassname(def_program) );

		infile = tmpfilename;

	} else if( (type == TYPE_INST_H) || (type == TYPE_INST_C) ) {

		sprintf( tmpfilename, "%s", ComponentClassname(def_program) );

		infile = tmpfilename;

	} else if( (type == TYPE_CLIENT_H) || (type == TYPE_CLIENT_C) ) {

		sprintf( tmpfilename, "%s", ClientComponentClassname(def_program) );

		infile = tmpfilename;

	}

	outfilename = extendfile(infile, outfile);

	open_output( infile, outfilename );

	// if there is more than one program then say I don't handle this

	if( foundprogram > 1 ) {

		fprintf( stderr, "ERROR: PR0094 modifications can't handle multiple program definitions in a single file.\n" );

		return;

	}

	// I also don't handle multiple versions in a single file

	vp = def_program->def.pr.versions;

	if( vp->next != NULL ) {

		fprintf( stderr, "ERROR: PR0094 modifications can't handle multiple program versions in a single file.\n" );

		return;

	}

	// HOOK: Insert header code

	hf[type]( outfilename, def_program );

	// process each procedure

	for( proc = vp->procs; proc != NULL; proc = proc->next ) {

		// HOOK: Insert proc code

		pf[type]( def_program, proc, vp->vers_num );

	}

	// HOOK: Insert footer code

	ff[type]( def_program );

	// done

	return;

}

/*********************************************************************

 *

 * SECTION: Service Stub Implementation

 *

 ********************************************************************/

/*********************************************************************

 *

 * Service Stub Implementation -- START

 *

 ********************************************************************/

void output_header_service_implementation( char *filename, definition *program )

{

	// output the autogen banner

	PrintAutogenBanner( filename );

	// output the system includes

	PrintBanner( "System Includes" );

	f_print( fout, "#include <assert.h>\n" );

	// output the local includes

	PrintBanner( "Local Includes" );

	f_print( fout, "#include \"%s.h\"\n", ServiceManagerClassname(program) );

	f_print( fout, "#include \"%s.h\"\n", ComponentClassname(program) );

	f_print( fout, "#include \"CComponentManager.h\"\n" );

	// output the static variables

	PrintBanner( "Static Variables" );

	f_print( fout, "static CComponentManager<%s> *iComponentManager;\n", ComponentClassname(program) );

}

/*********************************************************************

 *

 * Service Stub Implementation -- END

 *

 ********************************************************************/

void output_footer_service_implementation( definition *program )

{

}

/*********************************************************************

 *

 * Service Stub Implementation -- METHOD GENERATION (TOP LEVEL)

 *

 ********************************************************************/

void output_proc_service_implementation( definition *program, proc_list *proc, char *version )

{

	char str[512];

	// print banner

	sprintf( str, "PUBLIC FUNCTION: %s", locase(proc->proc_name) );

	PrintBanner( str );

	// print the function signature

	ptype( proc->res_prefix, proc->res_type, 1 );

	f_print( fout, "*");

	pvname( proc->proc_name, version );

	f_print(fout, "( ");

	ptype( proc->arg_prefix, proc->arg_type, 1 );

	f_print(fout, "*aArgs, CLIENT *aDutout )\n");

	// demux based on the name of the prefix

	if( strncmp(proc->proc_name,"SS_",3) == 0 ) {

		output_startup_proc_service_implementation( program, proc );

	} else if( strncmp(proc->proc_name,"SC_",3) == 0 ) {

		output_shutdown_proc_service_implementation( program, proc );

	} else if( strncmp(proc->proc_name,"CSTR_",5) == 0 ) {

		output_cstr_proc_service_implementation( program, proc );

	} else if( strncmp(proc->proc_name,"DSTR_",5) == 0 ) {

		output_dstr_proc_service_implementation( program, proc );

	} else if( strncmp(proc->proc_name,"LIST_",5) == 0 ) {

		output_list_proc_service_implementation( program, proc );

	} else if( strncmp(proc->proc_name,"ST_",3) == 0 ) {

		output_static_proc_service_implementation( program, proc );

	} else {

		output_std_proc_service_implementation( program, proc );

	}

}

/*********************************************************************

 *

 * Service Stub Implementation -- METHOD GENERATION (STANDARD METHODS)

 *

 ********************************************************************/

void output_std_proc_service_implementation( definition *program, proc_list *proc )

{

	int void_return_type = 0;

	// start

	f_print( fout, "{\n" );

	// check for void return value

	if( strncmp(proc->res_type,"void",4) == 0 ) {

		void_return_type = 1;

	}

	// declare variables

	f_print( fout, "\tstatic " );

	if( void_return_type == 0 ) {

		ptype( proc->res_prefix, proc->res_type, 1 );

	} else {

		f_print( fout, "int " );

	}	

	f_print( fout, "rv;\n");

	f_print( fout, "\tint instance_key;\n" );

	f_print( fout, "\t%s *session;\n\n", ComponentClassname(program) );

	trace( 1, program, proc, NULL, 1 );

	// check that the service is already started

	PrintServiceCheck( program, proc );

	// set the return value to generic error

	O( "\t// set the return value to generic error\n" );

	PrintSetErrorValue( 1, program, proc, "ERR_FAILED_TO_RETRIEVE_KEY" );

	f_print( fout, "\n" );

	// get the key for the instance from the args

	O( "\t// get the key for the instance from the args\n" );

	f_print( fout, "\tinstance_key = %s::GetInstanceKeyFromArgs( %s, (void*)aArgs );\n", ServiceManagerClassname(program), proc->proc_name );

	O( "\tif( instance_key < 0 ) {\n" );

	trace( 2, program, proc, NULL, 0 );

	O( "\t\treturn &rv;\n" );

	O( "\t}\n" );

	O( "\n" );

	// make sure the key is valid

	O( "\t// make sure the key is valid\n" );

	O( "\tif( iComponentManager->IsValidKey(instance_key) == 0 ) {\n" );		

	PrintSetErrorValue( 2, program, proc, "ERR_INSTANCE_DOES_NOT_EXIST" );

	O( "\t\treturn &rv;\n" );

	O( "\t}\n" );

	O( "\n" );

	// get the instance

	O( "\t// get the instance\n" );

	O( "\tsession = iComponentManager->GetInstance( instance_key );\n" );

	O( "\tassert( session != NULL );\n" );

	O( "\n" );

	// call the corresponding method on the instance and return the result

	PrintCallFromServiceStubToInstance( program, proc, NULL );

	trace( 1, program, proc, NULL, 0 );

	f_print( fout, "\treturn &rv;\n" );

	f_print( fout, "}\n" );

}

/*********************************************************************

 *

 * Service Stub Implementation -- METHOD GENERATION (STATIC METHODS)

 *

 ********************************************************************/

void output_static_proc_service_implementation( definition *program, proc_list *proc )

{

	int void_return_type = 0;

	// start

	f_print( fout, "{\n" );

	// check for void return value

	if( strncmp(proc->res_type,"void",4) == 0 ) {

		void_return_type = 1;

	}

	// declare the return variable

	f_print( fout, "\tstatic " );

	if( void_return_type == 0 ) {

		ptype( proc->res_prefix, proc->res_type, 1 );

	} else {

		f_print( fout, "int " );

	}	

	f_print( fout, "rv;\n");

	trace( 1, program, proc, NULL, 1 );

	O( "\n" );

	// check that the service is already started

	PrintServiceCheck( program, proc );

	// call the corresponding method on the instance and return the result

	PrintCallFromServiceStubToStatic( program, proc, NULL );

	trace( 1, program, proc, NULL, 0 );

	f_print( fout, "\treturn &rv;\n" );

	f_print( fout, "}\n" );

}

/*********************************************************************

 *

 * Service Stub Implementation -- METHOD GENERATION (CSTR METHODS)

 *

 ********************************************************************/

void output_cstr_proc_service_implementation( definition *program, proc_list *proc )

{

	int integer_return_type;

	// start

	f_print( fout, "{\n" );

	// a void return type is illegal for a cstr_ method

	if( strncmp(proc->res_type,"void",4) == 0 ) {

		fprintf( stderr, "ERROR: 'cstr_' methods must not have void return type.\n" );

		return;

	}

	// declare variables

	f_print( fout, "\tstatic " );

	ptype( proc->res_prefix, proc->res_type, 1 );

	f_print( fout, "rv;\n" );

	f_print( fout, "\tint result;\n" );

	f_print( fout, "\tint internal_err;\n" );

	f_print( fout, "\tint instance_key;\n" );

	f_print( fout, "\t%s *session;\n", ComponentClassname(program) );

	trace( 1, program, proc, NULL, 1 );

	O( "\n" );

	// check that the service is already started

	PrintServiceCheck( program, proc );

	// create a new component instance

	O( "\t// create a new component instance\n" );

	O( "\tinstance_key = iComponentManager->CreateInstance();\n" );

	O( "\tif( instance_key < 0 ) {\n" );

	PrintSetErrorValue( 2, program, proc, "instance_key" );

	trace( 2, program, proc, NULL, 0 );

	O( "\t\treturn &rv;\n" );

	O( "\t}\n\n" );

	// get the instance

	O( "\t// get the instance\n" );

	O( "\tsession = iComponentManager->GetInstance( instance_key );\n" );

	O( "\tassert( session != NULL );\n" );

	O( "\n" );

	// call the corresponding method on the instance

	PrintCallFromServiceStubToInstance( program, proc, NULL );

	// now extract the top level error code

	integer_return_type = IsSetErrorCallRequired( proc );

	if( integer_return_type == 0 ) {

		f_print( fout, "\tresult = rv;\n" );

	} else {

		f_print( fout, "\tresult = %s::GetError( %s, (void*)&rv );\n", ServiceManagerClassname(program), proc->proc_name );

	}

	O( "\n" );

	// if the method fails then we cleanup the instance -- otherwise we set the instance key

	// as the return value

	O( "\t// if the method fails then we cleanup the instance -- otherwise we set the instance key\n" );

	O( "\t// as the return value\n" );

	O( "\tif( result != ERR_NONE ) {\n" );

	O( "\t\tinternal_err = iComponentManager->DeleteInstance( instance_key );\n" );

	O( "\t\tassert( internal_err == 0 );\n" );

	O( "\t} else { \n" );

	PrintSetErrorValue( 2, program, proc, "instance_key" );

	O( "\t}\n" );

	O( "\n" );

	// done

	f_print( fout, "\t// done\n" );

	trace( 1, program, proc, NULL, 0 );

	f_print( fout, "\treturn &rv;\n" );

	f_print( fout, "}\n" );

}

/*********************************************************************

 *

 * Service Stub Implementation -- METHOD GENERATION (DSTR METHODS)

 *

 ********************************************************************/

void output_dstr_proc_service_implementation( definition *program, proc_list *proc )

{

	int integer_return_type;

	// start

	f_print( fout, "{\n" );

	// declare variables

	f_print( fout, "\tstatic " );

	ptype( proc->res_prefix, proc->res_type, 1 );

	f_print( fout, "rv;\n" );

	f_print( fout, "\tint result;\n" );

	f_print( fout, "\tint internal_err;\n" );

	f_print( fout, "\tint instance_key;\n" );

	f_print( fout, "\tint should_delete = 1;\n" );