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

/* THIS IS OPEN SOURCE CODE */

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

/* 

* File:    papi_fwrappers.c

* Author:  Philip Mucci

*          mucci@cs.utk.edu

* Mods:    Nils Smeds

*          smeds@pdc.kth.se

*          Anders Nilsson

*          anni@pdc.kth.se

*	   Kevin London

*	   london@cs.utk.edu

*	   dan terpstra

*	   terpstra@cs.utk.edu

*          Min Zhou

*	   min@cs.utk.edu

*/

#pragma GCC visibility push(default)

#include <stdio.h>

#include <assert.h>

#include <string.h>

#include "papi.h"

/* Lets use defines to rename all the files */

#ifdef FORTRANUNDERSCORE

#define PAPI_FCALL(function,caps,args) void function##_ args

#elif FORTRANDOUBLEUNDERSCORE

#define PAPI_FCALL(function,caps,args) void function##__ args

#elif FORTRANCAPS

#define PAPI_FCALL(function,caps,args) void caps args

#else

#define PAPI_FCALL(function,caps,args) void function args

#endif

/* Many Unix systems passes Fortran string lengths as extra arguments */

#if defined(_AIX) || defined(sun) || defined(linux)

#define _FORTRAN_STRLEN_AT_END

#endif

/* The Low Level Wrappers */

/** \internal @defgroup PAPIF PAPI Fortran API */

/* helper routine to convert Fortran strings to C strings */

#if defined(_FORTRAN_STRLEN_AT_END)

static void Fortran2cstring( char *cstring, char *Fstring, int clen , int Flen )

{

	int slen, i;

	/* What is the maximum number of chars to copy ? */

	slen = Flen < clen ? Flen : clen;

	strncpy( cstring, Fstring, ( size_t ) slen );

	/* Remove trailing blanks from initial Fortran string */

	for ( i = slen - 1; i > -1 && cstring[i] == ' '; cstring[i--] = '\0' );

	/* Make sure string is NULL terminated */

	cstring[clen - 1] = '\0';

	if ( slen < clen )

		cstring[slen] = '\0';

}

#endif

/**	@class PAPIF_accum

 *	@ingroup PAPIF

 *	@brief accumulate and reset counters in an event set 

 *	

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_accum( C_INT EventSet, C_LONG_LONG(*) values, C_INT  check )

 *

 *	@see PAPI_accum

 */

PAPI_FCALL( papif_accum, PAPIF_ACCUM,

			( int *EventSet, long long *values, int *check ) )

{

	*check = PAPI_accum( *EventSet, values );

}

/**	@class PAPIF_add_event

 *	@ingroup PAPIF

 *	@brief add PAPI preset or native hardware event to an event set

 *	

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_add_event( C_INT EventSet, C_INT EventCode, C_INT check )

 *

 *	@see PAPI_add_event

 */

PAPI_FCALL( papif_add_event, PAPIF_ADD_EVENT,

			( int *EventSet, int *Event, int *check ) )

{

	*check = PAPI_add_event( *EventSet, *Event );

}

/**	@class PAPIF_add_named_event

 *	@ingroup PAPIF

 *	@brief add PAPI preset or native hardware event to an event set by name

 *	

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_add_named_event( C_INT EventSet, C_STRING EventName, C_INT check )

 *

 *	@see PAPI_add_named_event

 */

#if defined(_FORTRAN_STRLEN_AT_END)

PAPI_FCALL( papif_add_named_event, PAPIF_ADD_NAMED_EVENT,

			( int *EventSet, char *EventName, int *check, int Event_len ) )

{

	char tmp[PAPI_MAX_STR_LEN];

	Fortran2cstring( tmp, EventName, PAPI_MAX_STR_LEN, Event_len );

	*check = PAPI_add_named_event( *EventSet, tmp );	

}

#else

PAPI_FCALL( papif_add_named_event, PAPIF_ADD_NAMED_EVENT,

			( int *EventSet, char *EventName, int *check ) )

{

	*check = PAPI_add_named_event( *EventSet, EventName );

}

#endif

/**	@class PAPIF_add_events

 *	@ingroup PAPIF

 *	@brief add multiple PAPI presets or native hardware events to an event set

 *	

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_add_events( C_INT EventSet, C_INT(*) EventCodes, C_INT number, C_INT  check )

 *

 *	@see PAPI_add_events

 */

PAPI_FCALL( papif_add_events, PAPIF_ADD_EVENTS,

			( int *EventSet, int *Events, int *number, int *check ) )

{

	*check = PAPI_add_events( *EventSet, Events, *number );

}

/**	@class PAPIF_cleanup_eventset

 *	@ingroup PAPIF

 *	@brief empty and destroy an EventSet 

 *	

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_cleanup_eventset( C_INT EventSet, C_INT check )

 *

 *	@see PAPI_cleanup_eventset

 */

PAPI_FCALL( papif_cleanup_eventset, PAPIF_CLEANUP_EVENTSET,

			( int *EventSet, int *check ) )

{

	*check = PAPI_cleanup_eventset( *EventSet );

}

/**	@class PAPIF_create_eventset

 *	@ingroup PAPIF

 *	@brief create a new empty PAPI EventSet 

 *	

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_create_eventset( C_INT EventSet, C_INT check )

 *

 *	@see PAPI_create_eventset

 */

PAPI_FCALL( papif_create_eventset, PAPIF_CREATE_EVENTSET,

			( int *EventSet, int *check ) )

{

	*check = PAPI_create_eventset( EventSet );

}

/**	@class PAPIF_assign_eventset_component

 *	@ingroup PAPIF

 *	@brief assign a component index to an existing but empty EventSet 

 *	

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_assign_eventset_component( C_INT EventSet, C_INT EventSet, C_INT check )

 *

 *	@see PAPI_assign_eventset_component

 */

PAPI_FCALL( papif_assign_eventset_component, PAPIF_ASSIGN_EVENTSET_COMPONENT,

			( int *EventSet, int *cidx, int *check ) )

{

	*check = PAPI_assign_eventset_component( *EventSet, *cidx );

}

/**	@class PAPIF_destroy_eventset

 *	@ingroup PAPIF

 *	@brief empty and destroy an EventSet 

 *	

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_destroy_eventset( C_INT EventSet, C_INT check )

 *

 *	@see PAPI_destroy_eventset

 */

PAPI_FCALL( papif_destroy_eventset, PAPIF_DESTROY_EVENTSET,

			( int *EventSet, int *check ) )

{

	*check = PAPI_destroy_eventset( EventSet );

}

/**	@class PAPIF_get_dmem_info

 *	@ingroup PAPIF

 *	@brief get information about the dynamic memory usage of the current program 

 *	

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_get_dmem_info( C_INT EventSet, C_INT check )

 *

 *	@see PAPI_get_dmem_info

 */

 /* XXX This looks totally broken. Should be passed all the members of the dmem_info struct. */

PAPI_FCALL( papif_get_dmem_info, PAPIF_GET_DMEM_INFO,

			( long long *dest, int *check ) )

{

	*check = PAPI_get_dmem_info( ( PAPI_dmem_info_t * ) dest );

}

/**	@class PAPIF_get_exe_info

 *	@ingroup PAPIF

 *	@brief get information about the dynamic memory usage of the current program 

 *	

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_get_exe_info( C_STRING fullname, C_STRING name, @n

 *						C_LONG_LONG text_start,  C_LONG_LONG text_end, @n

 *						C_LONG_LONG data_start,  C_LONG_LONG data_end, @n

 *						C_LONG_LONG bss_start,   C_LONG_LONG bss_end, C_INT check )

 *

 *	@see PAPI_get_executable_info

 */

#if defined(_FORTRAN_STRLEN_AT_END)

PAPI_FCALL( papif_get_exe_info, PAPIF_GET_EXE_INFO,

			( char *fullname, char *name, long long *text_start,

			  long long *text_end, long long *data_start, long long *data_end,

			  long long *bss_start, long long *bss_end,

			  int *check, int fullname_len, int name_len ) )

#else

PAPI_FCALL( papif_get_exe_info, PAPIF_GET_EXE_INFO,

			( char *fullname, char *name, long long *text_start,

			  long long *text_end, long long *data_start, long long *data_end,

			  long long *bss_start, long long *bss_end, int *check ) )

#endif

{

	PAPI_option_t e;

/* WARNING: The casts from caddr_t to long below WILL BREAK on systems with

    64-bit addresses. I did it here because I was lazy. And because I wanted

    to get rid of those pesky gcc warnings. If you find a 64-bit system,

    conditionalize the cast with (yet another) #ifdef...

*/

	if ( ( *check = PAPI_get_opt( PAPI_EXEINFO, &e ) ) == PAPI_OK ) {

#if defined(_FORTRAN_STRLEN_AT_END)

		int i;

		strncpy( fullname, e.exe_info->fullname, ( size_t ) fullname_len );

		for ( i = ( int ) strlen( e.exe_info->fullname ); i < fullname_len;

			  fullname[i++] = ' ' );

		strncpy( name, e.exe_info->address_info.name, ( size_t ) name_len );

		for ( i = ( int ) strlen( e.exe_info->address_info.name ); i < name_len;

			  name[i++] = ' ' );

#else

		strncpy( fullname, e.exe_info->fullname, PAPI_MAX_STR_LEN );

		strncpy( name, e.exe_info->address_info.name, PAPI_MAX_STR_LEN );

#endif

		*text_start = ( long ) e.exe_info->address_info.text_start;

		*text_end = ( long ) e.exe_info->address_info.text_end;

		*data_start = ( long ) e.exe_info->address_info.data_start;

		*data_end = ( long ) e.exe_info->address_info.data_end;

		*bss_start = ( long ) e.exe_info->address_info.bss_start;

		*bss_end = ( long ) e.exe_info->address_info.bss_end;

	}

}

/**	@class PAPIF_get_hardware_info 

 *	@ingroup PAPIF

 *	@brief get information about the system hardware

 *	

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_get_hardware_info( C_INT ncpu, C_INT nnodes,  C_INT totalcpus,@n

 *						C_INT vendor, C_STRING vendor_str, C_INT model, C_STRING model_str, @n

 *						C_FLOAT revision, C_FLOAT mhz )

 *

 *	@see PAPI_get_hardware_info

 */

#if defined(_FORTRAN_STRLEN_AT_END)

PAPI_FCALL( papif_get_hardware_info, PAPIF_GET_HARDWARE_INFO, ( int *ncpu,

																int *nnodes,

																int *totalcpus,

																int *vendor,

																char

																*vendor_str,

																int *model,

																char *model_str,

																float *revision,

																float *mhz,

																int vendor_len,

																int

																model_len ) )

#else

PAPI_FCALL( papif_get_hardware_info, PAPIF_GET_HARDWARE_INFO, ( int *ncpu,

																int *nnodes,

																int *totalcpus,

																int *vendor,

																char

																*vendor_string,

																int *model,

																char

																*model_string,

																float *revision,

																float *mhz ) )

#endif

{

	const PAPI_hw_info_t *hwinfo;

	int i;

	hwinfo = PAPI_get_hardware_info(  );

	if ( hwinfo == NULL ) {

		*ncpu = 0;

		*nnodes = 0;

		*totalcpus = 0;

		*vendor = 0;

		*model = 0;

		*revision = 0;

		*mhz = 0;

	} else {

		*ncpu = hwinfo->ncpu;

		*nnodes = hwinfo->nnodes;

		*totalcpus = hwinfo->totalcpus;

		*vendor = hwinfo->vendor;

		*model = hwinfo->model;

		*revision = hwinfo->revision;

		*mhz = hwinfo->cpu_max_mhz;

#if defined(_FORTRAN_STRLEN_AT_END)

		strncpy( vendor_str, hwinfo->vendor_string, ( size_t ) vendor_len );

		for ( i = ( int ) strlen( hwinfo->vendor_string ); i < vendor_len;

			  vendor_str[i++] = ' ' );

		strncpy( model_str, hwinfo->model_string, ( size_t ) model_len );

		for ( i = ( int ) strlen( hwinfo->model_string ); i < model_len;

			  model_str[i++] = ' ' );

#else

		(void)i; /* unused...  */

		/* This case needs the passed strings to be of sufficient size *

		 * and will include the NULL character in the target string    */

		strcpy( vendor_string, hwinfo->vendor_string );

		strcpy( model_string, hwinfo->model_string );

#endif

	}

	return;

}

/** @class PAPIF_num_hwctrs

 *	@ingroup PAPIF

 *  @brief Return the number of hardware counters on the cpu.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_num_hwctrs( C_INT num )

 *

 * @see PAPI_num_hwctrs

 * @see PAPI_num_cmp_hwctrs

 */

PAPI_FCALL( papif_num_hwctrs, PAPIF_num_hwctrs, ( int *num ) )

{

	*num = PAPI_num_hwctrs(  );

}

/** @class PAPIF_num_cmp_hwctrs

 *	@ingroup PAPIF

 *  @brief Return the number of hardware counters on the specified component.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_num_cmp_hwctrs( C_INT cidx, C_INT num )

 *

 * @see PAPI_num_hwctrs

 * @see PAPI_num_cmp_hwctrs

 */

PAPI_FCALL( papif_num_cmp_hwctrs, PAPIF_num_cmp_hwctrs,

			( int *cidx, int *num ) )

{

	*num = PAPI_num_cmp_hwctrs( *cidx );

}

/** @class PAPIF_get_real_cyc

 *	@ingroup PAPIF

 *	@brief Get real time counter value in clock cycles.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_get_real_cyc( C_LONG_LONG real_cyc )

 *

 * @see PAPI_get_real_cyc

 */

PAPI_FCALL( papif_get_real_cyc, PAPIF_GET_REAL_CYC, ( long long *real_cyc ) )

{

	*real_cyc = PAPI_get_real_cyc(  );

}

/** @class PAPIF_get_real_usec

 *	@ingroup PAPIF

 *	@brief Get real time counter value in microseconds.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_get_real_usec( C_LONG_LONG time )

 *

 * @see PAPI_get_real_usec

 */

PAPI_FCALL( papif_get_real_usec, PAPIF_GET_REAL_USEC, ( long long *time ) )

{

	*time = PAPI_get_real_usec(  );

}

/** @class PAPIF_get_real_nsec

 *	@ingroup PAPIF

 *	@brief Get real time counter value in nanoseconds.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_get_real_nsec( C_LONG_LONG time )

 *

 * @see PAPI_get_real_nsec

 */

PAPI_FCALL( papif_get_real_nsec, PAPIF_GET_REAL_NSEC, ( long long *time ) )

{

	*time = PAPI_get_real_nsec(  );

}

/** @class PAPIF_get_virt_cyc

 *	@ingroup PAPIF

 *	@brief Get virtual time counter value in clock cycles.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_get_virt_cyc( C_LONG_LONG virt_cyc )

 *

 * @see PAPI_get_virt_cyc

 */

PAPI_FCALL( papif_get_virt_cyc, PAPIF_GET_VIRT_CYC, ( long long *virt_cyc ) )

{

	*virt_cyc = PAPI_get_virt_cyc(  );

}

/** @class PAPIF_get_virt_usec

 *	@ingroup PAPIF

 *	@brief Get virtual time counter value in microseconds.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_get_virt_usec( C_LONG_LONG time )

 *

 * @see PAPI_get_virt_usec

 */

PAPI_FCALL( papif_get_virt_usec, PAPIF_GET_VIRT_USEC, ( long long *time ) )

{

	*time = PAPI_get_virt_usec(  );

}

/** @class PAPIF_is_initialized

 *	@ingroup PAPIF

 *	@brief Check for initialization.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_is_initialized( C_INT level )

 *

 * @see PAPI_is_initialized

 */

PAPI_FCALL( papif_is_initialized, PAPIF_IS_INITIALIZED, ( int *level ) )

{

	*level = PAPI_is_initialized(  );

}

/** @class PAPIF_library_init

 *	@ingroup PAPIF

 *	@brief Initialize the PAPI library. 

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_library_init( C_INT check )

 *

 * @see PAPI_library_init

 */

PAPI_FCALL( papif_library_init, PAPIF_LIBRARY_INIT, ( int *check ) )

{

	*check = PAPI_library_init( *check );

}

/** @class PAPIF_thread_id

 *	@ingroup PAPIF

 *  @brief Get the thread identifier of the current thread.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_thread_id( C_INT id )

 *

 * @see PAPI_thread_id

 */

PAPI_FCALL( papif_thread_id, PAPIF_THREAD_ID, ( unsigned long *id ) )

{

	*id = PAPI_thread_id(  );

}

/** @class PAPIF_register_thread

 *	@ingroup PAPIF

 *  @brief Notify PAPI that a thread has 'appeared'.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_register_thread( C_INT check )

 *

 * @see PAPI_register_thread

 */

PAPI_FCALL( papif_register_thread, PAPIF_REGISTER_THREAD, ( int *check ) )

{

	*check = PAPI_register_thread(  );

}

/** @class PAPIF_unregister_thread

 *	@ingroup PAPIF

 *  @brief Notify PAPI that a thread has 'disappeared'.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_unregister_thread( C_INT check )

 *

 * @see PAPI_unregister_thread

 */

PAPI_FCALL( papif_unregister_thread, PAPIF_UNREGISTER_THREAD, ( int *check ) )

{

	*check = PAPI_unregister_thread(  );

}

/* There was a long (10+ years!) typo that was not noticed here */

/* Leaving it here as not to break any existing code out there */

PAPI_FCALL( papif_unregster_thread, PAPIF_UNREGSTER_THREAD, ( int *check ) )

{

	*check = PAPI_unregister_thread(  );

}

/** @class PAPIF_thread_init

 *	@ingroup PAPIF

 *  @brief Initialize thread support in the PAPI library.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_thread_init( C_INT FUNCTION  handle,  C_INT  check )

 *

 * @see PAPI_thread_init

 */

/* This must be passed an EXTERNAL or INTRINISIC FUNCTION not a SUBROUTINE */

PAPI_FCALL( papif_thread_init, PAPIF_THREAD_INIT,

			( unsigned long int ( *handle ) ( void ), int *check ) )

{

	*check = PAPI_thread_init( handle );

}

/** @class PAPI_list_events

 *	@ingroup PAPIF

 *	@brief List the events in an event set.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPI_list_events( C_INT EventSet, C_INT(*) Events, C_INT number, C_INT check )

 *

 * @see PAPI_list_events

 */

PAPI_FCALL( papif_list_events, PAPIF_LIST_EVENTS,

			( int *EventSet, int *Events, int *number, int *check ) )

{

	*check = PAPI_list_events( *EventSet, Events, number );

}

/** @class PAPIF_multiplex_init

 *	@ingroup PAPIF

 *	@brief Initialize multiplex support in the PAPI library.

 *

 * @par Fortran Interface:

 * \#include "fpapi.h" @n

 * PAPIF_multiplex_init( C_INT check )

 *

 * @see PAPI_multiplex_init

 */

PAPI_FCALL( papif_multiplex_init, PAPIF_MULTIPLEX_INIT, ( int *check ) )

{

	*check = PAPI_multiplex_init(  );

}

/** @class PAPIF_get_multiplex

 *	@ingroup PAPIF

 *	@brief Get the multiplexing status of specified event set.

 *

 * @par Fortran Interface:

 * \#include "fpapi.h" @n

 * PAPIF_get_multiplex( C_INT  EventSet,  C_INT  check )

 *

 * @see PAPI_get_multiplex

 */

PAPI_FCALL( papif_get_multiplex, PAPIF_GET_MULTIPLEX,

			( int *EventSet, int *check ) )

{

	*check = PAPI_get_multiplex( *EventSet );

}

/** @class PAPIF_set_multiplex

 *	@ingroup PAPIF

 *	@brief Convert a standard event set to a multiplexed event set. 

 *

 * @par Fortran Interface:

 * \#include "fpapi.h" @n

 * PAPIF_set_multiplex( C_INT  EventSet,  C_INT  check )

 *

 * @see PAPI_set_multiplex

 */

PAPI_FCALL( papif_set_multiplex, PAPIF_SET_MULTIPLEX,

			( int *EventSet, int *check ) )

{

	*check = PAPI_set_multiplex( *EventSet );

}

/** @class PAPIF_perror

 *	@ingroup PAPIF

 *  @brief Convert PAPI error codes to strings, and print error message to stderr. 

 *

 * @par Fortran Interface:

 * \#include "fpapi.h" @n

 *     PAPIF_perror( C_STRING message )

 *

 * @see PAPI_perror

 */

#if defined(_FORTRAN_STRLEN_AT_END)

PAPI_FCALL( papif_perror, PAPIF_PERROR,

			( char *message,

			  int message_len ) )

#else

PAPI_FCALL( papif_perror, PAPIF_PERROR,

			( char *message ) )

#endif

{

#if defined(_FORTRAN_STRLEN_AT_END)

		char tmp[PAPI_MAX_STR_LEN];

		Fortran2cstring( tmp, message, PAPI_MAX_STR_LEN, message_len );

	PAPI_perror( tmp );

#else

	PAPI_perror( message );

#endif

}

/* This will not work until Fortran2000 :)

 * PAPI_FCALL(papif_profil, PAPIF_PROFIL, (unsigned short *buf, unsigned *bufsiz, unsigned long *offset, unsigned *scale, unsigned *eventset, 

 *            unsigned *eventcode, unsigned *threshold, unsigned *flags, unsigned *check))

 * {

 * *check = PAPI_profil(buf, *bufsiz, *offset, *scale, *eventset, *eventcode, *threshold, *flags);

 * }

 */

/** @class PAPIF_query_event

 *	@ingroup PAPIF

 *  @brief Query if PAPI event exists.

 *

 * @par Fortran Interface:

 * \#include "fpapi.h" @n

 * PAPIF_query_event(C_INT EventCode, C_INT check )

 *

 * @see PAPI_query_event

 */

PAPI_FCALL( papif_query_event, PAPIF_QUERY_EVENT,

			( int *EventCode, int *check ) )

{

	*check = PAPI_query_event( *EventCode );

}

/** @class PAPIF_query_named_event

 *	@ingroup PAPIF

 *  @brief Query if named PAPI event exists.

 *

 * @par Fortran Interface:

 * \#include "fpapi.h" @n

 * PAPIF_query_named_event(C_STRING EventName, C_INT check )

 *

 * @see PAPI_query_named_event

 */

#if defined(_FORTRAN_STRLEN_AT_END)

PAPI_FCALL( papif_query_named_event, PAPIF_QUERY_NAMED_EVENT,

			( char *EventName, int *check, int Event_len ) )

{

	char tmp[PAPI_MAX_STR_LEN];

	Fortran2cstring( tmp, EventName, PAPI_MAX_STR_LEN, Event_len );

	*check = PAPI_query_named_event( tmp );	

}

#else

PAPI_FCALL( papif_query_named_event, PAPIF_QUERY_NAMED_EVENT,

			( char *EventName, int *check ) )

{

	*check = PAPI_query_named_event( EventName );

}

#endif

/** @class PAPIF_get_event_info

 *	@ingroup PAPIF

 *	@brief Get the event's name and description info.

 *

 * @par Fortran Interface:

 * \#include "fpapi.h" @n

 * PAPIF_get_event_info(C_INT EventCode, C_STRING symbol, C_STRING long_descr,

 						C_STRING short_descr, C_INT count, C_STRING event_note,

 						C_INT flags, C_INT check )

 *

 * @see PAPI_get_event_info

 */

#if defined(_FORTRAN_STRLEN_AT_END)

PAPI_FCALL( papif_get_event_info, PAPIF_GET_EVENT_INFO,

			( int *EventCode, char *symbol, char *long_descr, char *short_descr,

			  int *count, char *event_note, int *flags, int *check,

			  int symbol_len, int long_descr_len, int short_descr_len,

			  int event_note_len ) )

#else

PAPI_FCALL( papif_get_event_info, PAPIF_GET_EVENT_INFO,

			( int *EventCode, char *symbol, char *long_descr, char *short_descr,

			  int *count, char *event_note, int *flags, int *check ) )

#endif

{

	PAPI_event_info_t info;

	( void ) flags;			 /*Unused */

#if defined(_FORTRAN_STRLEN_AT_END)

	int i;

	if ( ( *check = PAPI_get_event_info( *EventCode, &info ) ) == PAPI_OK ) {

		strncpy( symbol, info.symbol, ( size_t ) symbol_len );

		for ( i = ( int ) strlen( info.symbol ); i < symbol_len;

			  symbol[i++] = ' ' );

		strncpy( long_descr, info.long_descr, ( size_t ) long_descr_len );

		for ( i = ( int ) strlen( info.long_descr ); i < long_descr_len;

			  long_descr[i++] = ' ' );

		strncpy( short_descr, info.short_descr, ( size_t ) short_descr_len );

		for ( i = ( int ) strlen( info.short_descr ); i < short_descr_len;

			  short_descr[i++] = ' ' );

		*count = ( int ) info.count;

		int note_len=0;

		strncpy( event_note, info.note,  ( size_t ) event_note_len );

		note_len=strlen(info.note);

		for ( i =  note_len; i < event_note_len;

			  event_note[i++] = ' ' );

	}

#else

/* printf("EventCode: %d\n", *EventCode ); -KSL */

	if ( ( *check = PAPI_get_event_info( *EventCode, &info ) ) == PAPI_OK ) {

		strncpy( symbol, info.symbol, PAPI_MAX_STR_LEN );

		strncpy( long_descr, info.long_descr, PAPI_MAX_STR_LEN );

		strncpy( short_descr, info.short_descr, PAPI_MAX_STR_LEN );

		*count = info.count;

		if (info.note) 

                   strncpy( event_note, info.note, 

			    PAPI_MAX_STR_LEN );

	}

/*  printf("Check: %d\n", *check); -KSL */

#endif

}

/** @class PAPIF_event_code_to_name

 *	@ingroup PAPIF

 *	@brief Convert a numeric hardware event code to a name.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_event_code_to_name( C_INT EventCode, C_STRING EventName, C_INT check )

 *

 * @see PAPI_event_code_to_name

 */

#if defined(_FORTRAN_STRLEN_AT_END)

PAPI_FCALL( papif_event_code_to_name, PAPIF_EVENT_CODE_TO_NAME,

			( int *EventCode, char *out_str, int *check, int out_len ) )

#else

PAPI_FCALL( papif_event_code_to_name, PAPIF_EVENT_CODE_TO_NAME,

			( int *EventCode, char *out, int *check ) )

#endif

{

#if defined(_FORTRAN_STRLEN_AT_END)

	char tmp[PAPI_MAX_STR_LEN];

	int i;

	*check = PAPI_event_code_to_name( *EventCode, tmp );

	/* tmp has \0 within PAPI_MAX_STR_LEN chars so strncpy is safe */

	strncpy( out_str, tmp, ( size_t ) out_len );

	/* overwrite any NULLs and trailing garbage in out_str */

	for ( i = ( int ) strlen( tmp ); i < out_len; out_str[i++] = ' ' );

#else

	/* The array "out" passed by the user must be sufficiently long */

	*check = PAPI_event_code_to_name( *EventCode, out );

#endif

}

/** @class PAPIF_event_name_to_code

 *	@ingroup PAPIF

 *	@brief Convert a name to a numeric hardware event code. 

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_event_name_to_code( C_STRING EventName, C_INT EventCode, C_INT check )

 *

 * @see PAPI_event_name_to_code

 */

#if defined(_FORTRAN_STRLEN_AT_END)

PAPI_FCALL( papif_event_name_to_code, PAPIF_EVENT_NAME_TO_CODE,

			( char *in_str, int *out, int *check, int in_len ) )

#else

PAPI_FCALL( papif_event_name_to_code, PAPIF_EVENT_NAME_TO_CODE,

			( char *in, int *out, int *check ) )

#endif

{

#if defined(_FORTRAN_STRLEN_AT_END)

	int slen, i;

	char tmpin[PAPI_MAX_STR_LEN];

	/* What is the maximum number of chars to copy ? */

	slen = in_len < PAPI_MAX_STR_LEN ? in_len : PAPI_MAX_STR_LEN;

	strncpy( tmpin, in_str, ( size_t ) slen );

	/* Remove trailing blanks from initial Fortran string */

	for ( i = slen - 1; i > -1 && tmpin[i] == ' '; tmpin[i--] = '\0' );

	/* Make sure string is NULL terminated before call */

	tmpin[PAPI_MAX_STR_LEN - 1] = '\0';

	if ( slen < PAPI_MAX_STR_LEN )

		tmpin[slen] = '\0';

	*check = PAPI_event_name_to_code( tmpin, out );

#else

	/* This will have trouble if argument in is not null terminated */

	*check = PAPI_event_name_to_code( in, out );

#endif

}

/** @class PAPIF_num_events

 *	@ingroup PAPIF

 *	@brief Enumerate PAPI preset or native events. 

 *

 * @par Fortran Interface:

 * \#include "fpapi.h" @n

 * PAPIF_num_events(C_INT  EventSet,  C_INT  count)

 *

 * @see PAPI_num_events

 */

PAPI_FCALL( papif_num_events, PAPIF_NUM_EVENTS, ( int *EventCode, int *count ) )

{

	*count = PAPI_num_events( *EventCode );

}

/** @class PAPIF_enum_event

 *	@ingroup PAPIF

 *  @brief Return the number of events in an event set.

 *

 *	@par Fortran Interface:

 *	\#include "fpapi.h" @n

 *	PAPIF_enum_event( C_INT  EventCode,  C_INT  modifier,  C_INT  check )

 *

 * @see PAPI_enum_event

 */

PAPI_FCALL( papif_enum_event, PAPIF_ENUM_EVENT,

			( int *EventCode, int *modifier, int *check ) )

{

	*check = PAPI_enum_event( EventCode, *modifier );

}

/** @class PAPIF_read

 *	@ingroup PAPIF

 *  @brief Read hardware counters from an event set.

 *

 *  @par Fortran Interface:

 * \#include "fpapi.h" @n

 *  PAPIF_read(C_INT EventSet, C_LONG_LONG(*) values, C_INT check )

 *

 * @see PAPI_read