Return-Path: Delivered-To: apmail-httpd-cvs-archive@www.apache.org Received: (qmail 57028 invoked from network); 2 Dec 2004 05:47:37 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur-2.apache.org with SMTP; 2 Dec 2004 05:47:37 -0000 Received: (qmail 63931 invoked by uid 500); 2 Dec 2004 05:47:36 -0000 Delivered-To: apmail-httpd-cvs-archive@httpd.apache.org Received: (qmail 63889 invoked by uid 500); 2 Dec 2004 05:47:36 -0000 Mailing-List: contact cvs-help@httpd.apache.org; run by ezmlm Precedence: bulk Reply-To: dev@httpd.apache.org list-help: list-unsubscribe: list-post: Delivered-To: mailing list cvs@httpd.apache.org Received: (qmail 63874 invoked by uid 99); 2 Dec 2004 05:47:36 -0000 X-ASF-Spam-Status: No, hits=-10.0 required=10.0 tests=ALL_TRUSTED,NO_REAL_NAME X-Spam-Check-By: apache.org Received: from minotaur.apache.org (HELO minotaur.apache.org) (209.237.227.194) by apache.org (qpsmtpd/0.28) with SMTP; Wed, 01 Dec 2004 21:47:32 -0800 Received: (qmail 56980 invoked by uid 65534); 2 Dec 2004 05:47:31 -0000 Date: 2 Dec 2004 05:47:31 -0000 Message-ID: <20041202054731.56979.qmail@minotaur.apache.org> From: stoddard@apache.org To: cvs@httpd.apache.org Subject: svn commit: r109435 - /httpd/mod_arm4/trunk/arm4.h /httpd/mod_arm4/trunk/arm4dyn.h /httpd/mod_arm4/trunk/arm4os.h MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 X-Virus-Checked: Checked X-Spam-Rating: minotaur-2.apache.org 1.6.2 0/1000/N Author: stoddard Date: Wed Dec 1 18:24:33 2004 New Revision: 109435 URL: http://svn.apache.org/viewcvs?view=rev&rev=109435 Log: ARM4 header files from: http://www.opengroup.org/tech/management/arm/uploads/40/4901/arm40_c_headers.tar Added: httpd/mod_arm4/trunk/arm4.h httpd/mod_arm4/trunk/arm4dyn.h httpd/mod_arm4/trunk/arm4os.h Added: httpd/mod_arm4/trunk/arm4.h Url: http://svn.apache.org/viewcvs/httpd/mod_arm4/trunk/arm4.h?view=auto&rev=109435 ============================================================================== --- (empty file) +++ httpd/mod_arm4/trunk/arm4.h Wed Dec 1 18:24:33 2004 @@ -0,0 +1,642 @@ +/* ------------------------------------------------------------------------- */ +/* */ +/* Copyright (c) 2003 The Open Group */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining a */ +/* copy of this software (the "Software"), to deal in the Software without */ +/* restriction, including without limitation the rights to use, copy, */ +/* modify, merge, publish, distribute, sublicense, and/or sell copies of */ +/* the Software, and to permit persons to whom the Software is furnished */ +/* to do so, subject to the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be included */ +/* in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS */ +/* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT */ +/* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR */ +/* THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/* */ +/* ------------------------------------------------------------------------- */ +/* */ +/* File revision information */ +/* */ +/* $Source: /tang_cvs/arm4/sdk4/c/include/arm4.h,v $ */ +/* $Revision: 1.2 $ */ +/* $Date: 2003/12/03 13:55:14 $ */ +/* */ +/* --------------------------------------------------------------- */ +/* arm4.h - ARM4 standard header file */ +/* */ +/* This header file defines all defines, typedefs, structures, */ +/* and API functions visible for an application which uses an ARM */ +/* agent. All compiler/platform specifics are handled in a */ +/* separate header file named . */ +/* */ +/* NOTE: The ARM4 C language binding differs completely from */ +/* ARM1 and ARM2 bindings. */ +/* --------------------------------------------------------------- */ + +#ifndef ARM4_H_INCLUDED +#define ARM4_H_INCLUDED + +#ifndef ARM4OS_H_INCLUDED +#include "arm4os.h" +#endif /* ARM4OS_H_INCLUDED */ + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* --------------------------------------------------------------- */ +/* ---------------------- defines section ------------------------ */ +/* --------------------------------------------------------------- */ + +/* Boolean values */ +#define ARM_FALSE 0 +#define ARM_TRUE 1 + +/* Transaction status */ +#define ARM_STATUS_GOOD 0 +#define ARM_STATUS_ABORTED 1 +#define ARM_STATUS_FAILED 2 +#define ARM_STATUS_UNKNOWN 3 + +/* -------------- reserved error codes range --------------------- */ + +#define ARM_ERROR_CODE_RESERVED_MIN -20999 +#define ARM_ERROR_CODE_RESERVED_MAX -20000 + +/* --------------- known sub-buffer formats ---------------------- */ + +#define ARM_SUBBUFFER_USER 3 +#define ARM_SUBBUFFER_ARRIVAL_TIME 4 +#define ARM_SUBBUFFER_METRIC_VALUES 5 +#define ARM_SUBBUFFER_SYSTEM_ADDRESS 6 +#define ARM_SUBBUFFER_DIAG_DETAIL 7 + +#define ARM_SUBBUFFER_APP_IDENTITY 102 +#define ARM_SUBBUFFER_APP_CONTEXT 103 +#define ARM_SUBBUFFER_TRAN_IDENTITY 104 +#define ARM_SUBBUFFER_TRAN_CONTEXT 105 +#define ARM_SUBBUFFER_METRIC_BINDINGS 106 +#define ARM_SUBBUFFER_CHARSET 107 + +/* -------------------- metric defines --------------------------- */ + +#define ARM_METRIC_FORMAT_RESERVED 0 +#define ARM_METRIC_FORMAT_COUNTER32 1 +#define ARM_METRIC_FORMAT_COUNTER64 2 +#define ARM_METRIC_FORMAT_CNTRDIVR32 3 +#define ARM_METRIC_FORMAT_GAUGE32 4 +#define ARM_METRIC_FORMAT_GAUGE64 5 +#define ARM_METRIC_FORMAT_GAUGEDIVR32 6 +#define ARM_METRIC_FORMAT_NUMERICID32 7 +#define ARM_METRIC_FORMAT_NUMERICID64 8 +/* format 9 (string8) is deprecated */ +#define ARM_METRIC_FORMAT_STRING32 10 + +#define ARM_METRIC_USE_GENERAL 0 +#define ARM_METRIC_USE_TRAN_SIZE 1 +#define ARM_METRIC_USE_TRAN_STATUS 2 + +#define ARM_METRIC_MIN_ARRAY_INDEX 0 +#define ARM_METRIC_MAX_ARRAY_INDEX 6 +#define ARM_METRIC_MAX_COUNT 7 + +#define ARM_METRIC_STRING32_MAX_CHARS 31 +#define ARM_METRIC_STRING32_MAX_LENGTH \ + (ARM_METRIC_STRING32_MAX_CHARS*3+1) + +/* ------------------- misc string defines ----------------------- */ + +#define ARM_NAME_MAX_CHARS 127 +#define ARM_NAME_MAX_LENGTH (ARM_NAME_MAX_CHARS*3+1) + +#define ARM_DIAG_DETAIL_MAX_CHARS 4095 +#define ARM_DIAG_DETAIL_MAX_LENGTH (ARM_DIAG_DETAIL_MAX_CHARS*3+1) + +#define ARM_MSG_BUFFER_CHARS 255 +#define ARM_MSG_BUFFER_LENGTH (ARM_MSG_BUFFER_CHARS*3+1) + +/* ------------------- properties defines ------------------------ */ + +#define ARM_PROPERTY_MIN_ARRAY_INDEX 0 +#define ARM_PROPERTY_MAX_ARRAY_INDEX 19 +#define ARM_PROPERTY_MAX_COUNT 20 + +#define ARM_PROPERTY_NAME_MAX_CHARS (ARM_NAME_MAX_CHARS) +#define ARM_PROPERTY_NAME_MAX_LENGTH \ + (ARM_PROPERTY_NAME_MAX_CHARS*3+1) +#define ARM_PROPERTY_VALUE_MAX_CHARS 255 +#define ARM_PROPERTY_VALUE_MAX_LENGTH \ + (ARM_PROPERTY_VALUE_MAX_CHARS*3+1) + +#define ARM_PROPERTY_URI_MAX_CHARS 4095 +#define ARM_PROPERTY_URI_MAX_LENGTH (ARM_PROPERTY_URI_MAX_CHARS*3+1) + +/* -------------- system address format values ------------------- */ + +#define ARM_SYSADDR_FORMAT_RESERVED 0 +#define ARM_SYSADDR_FORMAT_IPV4 1 +#define ARM_SYSADDR_FORMAT_IPV4PORT 2 +#define ARM_SYSADDR_FORMAT_IPV6 3 +#define ARM_SYSADDR_FORMAT_IPV6PORT 4 +#define ARM_SYSADDR_FORMAT_SNA 5 +#define ARM_SYSADDR_FORMAT_X25 6 +#define ARM_SYSADDR_FORMAT_HOSTNAME 7 +#define ARM_SYSADDR_FORMAT_UUID 8 + +/* ------------------ mandatory charsets ------------------------- */ + +/* IANA charset MIBenum numbers (http://www.iana.org/) */ +#define ARM_CHARSET_ASCII 3 /* mandatory */ +#define ARM_CHARSET_UTF8 106 /* mandatory */ +#define ARM_CHARSET_UTF16BE 1013 +#define ARM_CHARSET_UTF16LE 1014 + /* mandatory on Windows */ +#define ARM_CHARSET_UTF16 1015 +#define ARM_CHARSET_IBM037 2028 + /* mandatory on iSeries */ +#define ARM_CHARSET_IBM1047 2102 + /* mandatory on zSeries */ + +/* ------------- flags to be passed on API calls ----------------- */ + +/* Use ARM_FLAG_NONE instead of zero to be more readable. */ +#define ARM_FLAG_NONE (0x00000000) + +/* ARM_FLAG_TRACE_REQUEST could be used in the following calls to */ +/* request a trace: */ +/* - arm_generate_correlator() */ +/* - arm_start_transaction() */ +/* - arm_report_transaction() */ +/* NOTE: The agent need not support instance tracing, so to be */ +/* sure check the generated correlator using the */ +/* arm_get_correlator_flags() function. */ +#define ARM_FLAG_TRACE_REQUEST (0x00000001) + +/* ARM_FLAG_BIND_THREAD could be used on arm_start_transaction() */ +/* call to do an implicit arm_bind_thread(). */ +#define ARM_FLAG_BIND_THREAD (0x00000002) + +/* ARM_FLAG_CORR_IN_PROCESS indicates that a correlator will only */ +/* be used within the process it was created. So an ARM */ +/* implementation may optimize the generation of a correlator */ +/* for that special usage. This flag can be passed to: */ +/* - arm_generate_correlator() */ +/* - arm_start_transaction() */ +/* NOTE: The agent need not support in-process correlation at all. */ +#define ARM_FLAG_CORR_IN_PROCESS (0x00000004) + +/* --------------- correlator defines ---------------------------- */ + +#define ARM_CORR_MAX_LENGTH 512 + /* total max length */ + +/* Correlator interface flag numbers. See */ +/* arm_get_correlator_flags(). */ +#define ARM_CORR_FLAGNUM_APP_TRACE 1 +#define ARM_CORR_FLAGNUM_AGENT_TRACE 2 + + +/* Use if no correlator should be provided (e.g., in */ +/* arm_start_transaction(). */ +#define ARM_CORR_NONE ((arm_correlator_t *) NULL) + +/* --- current time for arm_report_transaction() stop time ------- */ + +#define ARM_USE_CURRENT_TIME ((arm_stop_time_t)-1) + +/* ------------------ misc defines ------------------------------- */ + +/* Use ARM_BUF4_NONE instead of a NULL to be more readable. */ +#define ARM_BUF4_NONE ((arm_buffer4_t*) NULL) + +/* Use ARM_ID_NONE instead of a NULL to be more readable. */ +#define ARM_ID_NONE ((arm_id_t *) NULL) + +/* --------------------------------------------------------------- */ +/* --------------- basic typedef section ------------------------- */ +/* --------------------------------------------------------------- */ + +/* Generic data types */ +/* ARM4_*INT* defines are set in the header file. */ +/* They are platform/compiler-specific. */ +typedef ARM4_CHAR arm_char_t; + +typedef ARM4_INT8 arm_int8_t; +typedef ARM4_UINT8 arm_uint8_t; + /* used to define an opaque byte array */ + +typedef ARM4_INT16 arm_int16_t; +typedef ARM4_UINT16 arm_uint16_t; + +typedef ARM4_INT32 arm_int32_t; +typedef ARM4_UINT32 arm_uint32_t; + +typedef ARM4_INT64 arm_int64_t; +typedef ARM4_UINT64 arm_uint64_t; + +/* ARM-specific simple types */ +typedef arm_int32_t arm_boolean_t; +typedef arm_int32_t arm_error_t; + +typedef arm_int64_t arm_arrival_time_t; /* opaque arrival time */ +typedef arm_int64_t arm_stop_time_t; /* stop time in milli secs */ +typedef arm_int64_t arm_response_time_t; + /* response time in nano secs */ + +typedef arm_int32_t arm_tran_status_t; /* ARM_TRAN_STATUS_* values */ +typedef arm_int32_t arm_charset_t; /* IANA MIBenum values */ +typedef arm_int32_t arm_sysaddr_format_t; /* ARM_SYSADDR_* values */ + +/* ARM string buffer types */ +typedef arm_char_t arm_message_buffer_t[ARM_MSG_BUFFER_LENGTH]; + +/* subbuffer types */ +typedef arm_int32_t arm_subbuffer_format_t; + +/* metric types */ +typedef arm_uint8_t arm_metric_format_t; +typedef arm_uint8_t arm_metric_slot_t; +typedef arm_int16_t arm_metric_usage_t; + +/* handle types */ +typedef arm_int64_t arm_app_start_handle_t; +typedef arm_int64_t arm_tran_start_handle_t; +typedef arm_int64_t arm_tran_block_handle_t; + +/* correlator types */ +typedef arm_int16_t arm_correlator_length_t; + +/* --------------------------------------------------------------- */ +/* ---------------- compound typedefs section -------------------- */ +/* --------------------------------------------------------------- */ + +/* All IDs are 16 bytes on an 8-byte boundary. */ +typedef struct arm_id +{ + union + { + arm_uint8_t uint8[16]; + arm_uint32_t uint32[4]; + arm_uint64_t uint64[2]; + } id_u; +} arm_id_t; + +/* Correlator */ +typedef struct arm_correlator +{ + arm_uint8_t opaque[ARM_CORR_MAX_LENGTH]; +} arm_correlator_t; + +/* User-defined metrics */ +typedef arm_int32_t arm_metric_counter32_t; +typedef arm_int64_t arm_metric_counter64_t; +typedef arm_int32_t arm_metric_divisor32_t; +typedef arm_int32_t arm_metric_gauge32_t; +typedef arm_int64_t arm_metric_gauge64_t; +typedef arm_int32_t arm_metric_numericID32_t; +typedef arm_int64_t arm_metric_numericID64_t; +typedef const arm_char_t *arm_metric_string32_t; +typedef struct arm_metric_cntrdivr32 +{ + arm_metric_counter32_t counter; + arm_metric_divisor32_t divisor; +} arm_metric_cntrdivr32_t; +typedef struct arm_metric_gaugedivr32 +{ + arm_metric_gauge32_t gauge; + arm_metric_divisor32_t divisor; +} arm_metric_gaugedivr32_t; + +typedef struct arm_metric +{ + arm_metric_slot_t slot; + arm_metric_format_t format; + arm_metric_usage_t usage; + arm_boolean_t valid; + union + { + arm_metric_counter32_t counter32; + arm_metric_counter64_t counter64; + arm_metric_cntrdivr32_t counterdivisor32; + arm_metric_gauge32_t gauge32; + arm_metric_gauge64_t gauge64; + arm_metric_gaugedivr32_t gaugedivisor32; + arm_metric_numericID32_t numericid32; + arm_metric_numericID64_t numericid64; + arm_metric_string32_t string32; + } metric_u; +} arm_metric_t; + +typedef struct arm_metric_binding +{ + arm_metric_slot_t slot; + arm_id_t id; +} arm_metric_binding_t; + +typedef struct arm_property +{ + const arm_char_t *name; + const arm_char_t *value; +} arm_property_t; + +/* ------------------------------------------------------------- */ +/* -------------- sub-buffer typedefs section ------------------ */ +/* ------------------------------------------------------------- */ + +typedef struct arm_subbuffer { + arm_subbuffer_format_t format; + /* Format-specific data fields follow here. */ +} arm_subbuffer_t; + +/* This macro could be used avoid a compiler warning if you */ +/* direct one of the following arm_subbuffer_*_t structure */ +/* pointers to a function accepting sub-buffer pointers. Any */ +/* sub-buffer is passed to the ARM API call as a */ +/* (arm_subbuffer_t *) pointer. Use this macro if you pass a */ +/* "real" subbuffer to an API function. Note for the special */ +/* ARM SDK subbuffers the ARM_SDKSB() macro has to be used. */ +#define ARM_SB(x) (&((x).header)) + +/* The user data buffer */ +typedef struct arm_buffer4 +{ + arm_int32_t count; + arm_subbuffer_t **subbuffer_array; +} arm_buffer4_t; + +typedef struct arm_subbuffer_charset +{ + arm_subbuffer_t header; /* ARM_SUBBUFFER_CHARSET */ + + arm_charset_t charset; /* One of the IANA MIBenum values */ + arm_int32_t flags; +} arm_subbuffer_charset_t; + +typedef struct arm_subbuffer_app_identity +{ + arm_subbuffer_t header; /* ARM_SUBBUFFER_APP_IDENTITY */ + + arm_int32_t identity_property_count; + const arm_property_t *identity_property_array; + arm_int32_t context_name_count; + const arm_char_t **context_name_array; +} arm_subbuffer_app_identity_t; + +typedef struct arm_subbuffer_app_context +{ + arm_subbuffer_t header; /* ARM_SUBBUFFER_APP_CONTEXT */ + + arm_int32_t context_value_count; + const arm_char_t **context_value_array; +} arm_subbuffer_app_context_t; + +typedef struct arm_subbuffer_tran_identity +{ + arm_subbuffer_t header; /* ARM_SUBBUFFER_TRAN_IDENTITY */ + + arm_int32_t identity_property_count; + const arm_property_t *identity_property_array; + arm_int32_t context_name_count; + const arm_char_t **context_name_array; + const arm_char_t *uri; +} arm_subbuffer_tran_identity_t; + +typedef struct arm_subbuffer_tran_context +{ + arm_subbuffer_t header; /* ARM_SUBBUFFER_TRAN_CONTEXT */ + + arm_int32_t context_value_count; + const arm_char_t **context_value_array; + const arm_char_t *uri; +} arm_subbuffer_tran_context_t; + +typedef struct arm_subbuffer_arrival_time +{ + arm_subbuffer_t header; /* ARM_SUBBUFFER_ARRIVAL_TIME */ + + arm_arrival_time_t opaque_time; +} arm_subbuffer_arrival_time_t; + +typedef struct arm_subbuffer_metric_bindings +{ + arm_subbuffer_t header; /* ARM_SUBBUFFER_METRIC_BINDINGS */ + + arm_int32_t count; + const arm_metric_binding_t *metric_binding_array; +} arm_subbuffer_metric_bindings_t; + +typedef struct arm_subbuffer_metric_values +{ + arm_subbuffer_t header; /* ARM_SUBBUFFER_METRIC_VALUES */ + + arm_int32_t count; + const arm_metric_t *metric_value_array; +} arm_subbuffer_metric_values_t; + +typedef struct arm_subbuffer_user +{ + arm_subbuffer_t header; /* ARM_SUBBUFFER_USER */ + + const arm_char_t *name; + arm_boolean_t id_valid; + arm_id_t id; +} arm_subbuffer_user_t; + +typedef struct arm_subbuffer_system_address +{ + arm_subbuffer_t header; /* ARM_SUBBUFFER_SYSTEM_ADDRESS */ + + arm_int16_t address_format; + arm_int16_t address_length; + const arm_uint8_t *address; + arm_boolean_t id_valid; + arm_id_t id; +} arm_subbuffer_system_address_t; + +typedef struct arm_subbuffer_diag_detail +{ + arm_subbuffer_t header; /* ARM_SUBBUFFER_DIAG_DETAIL */ + + const arm_char_t *diag_detail; +} arm_subbuffer_diag_detail_t; + +/* --------------------------------------------------------------- */ +/* ------------------ ARM4 API section --------------------------- */ +/* --------------------------------------------------------------- */ + +/* register metadata API functions */ +ARM4_API_DYNAMIC(arm_error_t) +arm_register_application( + const arm_char_t *app_name, + const arm_id_t *input_app_id, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_id_t *output_app_id); + +ARM4_API_DYNAMIC(arm_error_t) +arm_destroy_application( + const arm_id_t *app_id, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +ARM4_API_DYNAMIC(arm_error_t) +arm_register_transaction( + const arm_id_t *app_id, + const arm_char_t *tran_name, + const arm_id_t *input_tran_id, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_id_t *output_tran_id); + +ARM4_API_DYNAMIC(arm_error_t) +arm_register_metric( + const arm_id_t *app_id, + const arm_char_t *metric_name, + const arm_metric_format_t metric_format, + const arm_metric_usage_t metric_usage, + const arm_char_t *metric_unit, + const arm_id_t *input_metric_id, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_id_t *output_metric_id); + +/* application instance API functions */ +ARM4_API_DYNAMIC(arm_error_t) +arm_start_application( + const arm_id_t *app_id, + const arm_char_t *app_group, + const arm_char_t *app_instance, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_app_start_handle_t *app_handle); + +ARM4_API_DYNAMIC(arm_error_t) +arm_stop_application( + const arm_app_start_handle_t app_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +/* transaction instance API functions */ +ARM4_API_DYNAMIC(arm_error_t) +arm_start_transaction( + const arm_app_start_handle_t app_handle, + const arm_id_t *tran_id, + const arm_correlator_t *parent_correlator, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_tran_start_handle_t *tran_handle, + arm_correlator_t *current_correlator); + +ARM4_API_DYNAMIC(arm_error_t) +arm_stop_transaction( + const arm_tran_start_handle_t tran_handle, + const arm_tran_status_t tran_status, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +ARM4_API_DYNAMIC(arm_error_t) +arm_update_transaction( + const arm_tran_start_handle_t tran_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +ARM4_API_DYNAMIC(arm_error_t) +arm_discard_transaction( + const arm_tran_start_handle_t tran_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +ARM4_API_DYNAMIC(arm_error_t) +arm_block_transaction( + const arm_tran_start_handle_t tran_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_tran_block_handle_t *block_handle); + +ARM4_API_DYNAMIC(arm_error_t) +arm_unblock_transaction( + const arm_tran_start_handle_t tran_handle, + const arm_tran_block_handle_t block_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +/* thread support API functions */ +ARM4_API_DYNAMIC(arm_error_t) +arm_bind_thread( + const arm_tran_start_handle_t tran_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +ARM4_API_DYNAMIC(arm_error_t) +arm_unbind_thread( + const arm_tran_start_handle_t tran_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +/* report transaction data API function */ +ARM4_API_DYNAMIC(arm_error_t) +arm_report_transaction( + const arm_app_start_handle_t app_handle, + const arm_id_t *tran_id, + const arm_tran_status_t tran_status, + const arm_response_time_t response_time, + const arm_stop_time_t stop_time, + const arm_correlator_t *parent_correlator, + const arm_correlator_t *current_correlator, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +/* correlator API functions */ +ARM4_API_DYNAMIC(arm_error_t) +arm_generate_correlator( + const arm_app_start_handle_t app_handle, + const arm_id_t *tran_id, + const arm_correlator_t *parent_correlator, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_correlator_t *current_correlator); + +ARM4_API_DYNAMIC(arm_error_t) +arm_get_correlator_length( + const arm_correlator_t *correlator, + arm_correlator_length_t *length); + +ARM4_API_DYNAMIC(arm_error_t) +arm_get_correlator_flags( + const arm_correlator_t *correlator, + const arm_int32_t corr_flag_num, + arm_boolean_t *flag); + +/* miscellaneous API functions */ +ARM4_API_DYNAMIC(arm_error_t) +arm_get_arrival_time( + arm_arrival_time_t *opaque_time); + +ARM4_API_DYNAMIC(arm_error_t) +arm_get_error_message( + const arm_charset_t charset, + const arm_error_t code, + arm_message_buffer_t msg); + +ARM4_API_DYNAMIC(arm_error_t) +arm_is_charset_supported( + const arm_charset_t charset, + arm_boolean_t *supported); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#ifndef ARM4DYN_H_INCLUDED +#include "arm4dyn.h" +#endif /* !ARM4DYN_H_INCLUDED */ + +#endif /* ARM4_H_INCLUDED */ + Added: httpd/mod_arm4/trunk/arm4dyn.h Url: http://svn.apache.org/viewcvs/httpd/mod_arm4/trunk/arm4dyn.h?view=auto&rev=109435 ============================================================================== --- (empty file) +++ httpd/mod_arm4/trunk/arm4dyn.h Wed Dec 1 18:24:33 2004 @@ -0,0 +1,208 @@ +/* ------------------------------------------------------------------------- */ +/* */ +/* Copyright (c) 2003 The Open Group */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining a */ +/* copy of this software (the "Software"), to deal in the Software without */ +/* restriction, including without limitation the rights to use, copy, */ +/* modify, merge, publish, distribute, sublicense, and/or sell copies of */ +/* the Software, and to permit persons to whom the Software is furnished */ +/* to do so, subject to the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be included */ +/* in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS */ +/* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT */ +/* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR */ +/* THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/* */ +/* ------------------------------------------------------------------------- */ +/* */ +/* File revision information */ +/* */ +/* $Source: /tang_cvs/arm4/sdk4/c/include/arm4dyn.h,v $ */ +/* $Revision: 1.2 $ */ +/* $Date: 2003/12/03 13:55:14 $ */ +/* */ +/* ------------------------------------------------------------------------- */ + +#ifndef ARM4DYN_H_INCLUDED +#define ARM4DYN_H_INCLUDED + +#ifndef ARM4_H_INCLUDED +#error "don't include arm4dyn.h directly, use arm4.h instead!" +#endif + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* API function pointer types for registering metadata */ +typedef arm_error_t +(ARM4_API_CALL* arm_register_application_t)( + const arm_char_t *app_name, + const arm_id_t *input_app_id, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_id_t *output_app_id); + +typedef arm_error_t +(ARM4_API_CALL* arm_destroy_application_t)( + const arm_id_t *app_id, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +typedef arm_error_t +(ARM4_API_CALL* arm_register_transaction_t)( + const arm_id_t *app_id, + const arm_char_t *tran_name, + const arm_id_t *input_tran_id, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_id_t *output_tran_id); + +typedef arm_error_t + (ARM4_API_CALL* arm_register_metric_t)( + const arm_id_t *app_id, + const arm_char_t *metric_name, + const arm_metric_format_t metric_format, + const arm_metric_usage_t metric_usage, + const arm_char_t *metric_unit, + const arm_id_t *input_metric_id, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_id_t *output_metric_id); + +/* API function pointer types for application instances */ +typedef arm_error_t +(ARM4_API_CALL* arm_start_application_t)( + const arm_id_t *app_id, + const arm_char_t *app_group, + const arm_char_t *app_instance, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_app_start_handle_t *app_handle); + +typedef arm_error_t +(ARM4_API_CALL* arm_stop_application_t)( + const arm_app_start_handle_t app_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +/* API function pointer types for transaction instances */ +typedef arm_error_t +(ARM4_API_CALL* arm_start_transaction_t)( + const arm_app_start_handle_t app_handle, + const arm_id_t *tran_id, + const arm_correlator_t *parent_correlator, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_tran_start_handle_t *tran_handle, + arm_correlator_t *current_correlator); + +typedef arm_error_t +(ARM4_API_CALL* arm_stop_transaction_t)( + const arm_tran_start_handle_t tran_handle, + const arm_tran_status_t tran_status, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +typedef arm_error_t +(ARM4_API_CALL* arm_update_transaction_t)( + const arm_tran_start_handle_t tran_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +typedef arm_error_t +(ARM4_API_CALL* arm_discard_transaction_t)( + const arm_tran_start_handle_t tran_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +typedef arm_error_t +(ARM4_API_CALL* arm_block_transaction_t)( + const arm_tran_start_handle_t tran_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_tran_block_handle_t *block_handle); + +typedef arm_error_t +(ARM4_API_CALL* arm_unblock_transaction_t)( + const arm_tran_start_handle_t tran_handle, + const arm_tran_block_handle_t block_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +/* API function pointer types for thread support */ +typedef arm_error_t +(ARM4_API_CALL* arm_bind_thread_t)( + const arm_tran_start_handle_t tran_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +typedef arm_error_t +(ARM4_API_CALL* arm_unbind_thread_t)( + const arm_tran_start_handle_t tran_handle, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +/* API function pointer types for reporting transaction data */ +typedef arm_error_t +(ARM4_API_CALL* arm_report_transaction_t)( + const arm_app_start_handle_t app_handle, + const arm_id_t *tran_id, + const arm_tran_status_t tran_status, + const arm_response_time_t response_time, + const arm_stop_time_t stop_time, + const arm_correlator_t *parent_correlator, + const arm_correlator_t *current_correlator, + const arm_int32_t flags, + const arm_buffer4_t *buffer4); + +/* API function pointer types for correlators */ +typedef arm_error_t +(ARM4_API_CALL* arm_generate_correlator_t)( + const arm_app_start_handle_t app_handle, + const arm_id_t *tran_id, + const arm_correlator_t *parent_correlator, + const arm_int32_t flags, + const arm_buffer4_t *buffer4, + arm_correlator_t *current_correlator); + +typedef arm_error_t +(ARM4_API_CALL* arm_get_correlator_length_t)( + const arm_correlator_t *correlator, + arm_correlator_length_t *length); + +typedef arm_error_t +(ARM4_API_CALL* arm_get_correlator_flags_t)( + const arm_correlator_t *correlator, + const arm_int32_t corr_flag_num, + arm_boolean_t *flag); + +/* miscellaneous API function pointer types */ +typedef arm_error_t +(ARM4_API_CALL* arm_get_arrival_time_t)( + arm_arrival_time_t *opaque_time); + +typedef arm_error_t +(ARM4_API_CALL* arm_get_error_message_t)( + const arm_charset_t charset, + const arm_error_t code, + arm_message_buffer_t msg); + +typedef arm_error_t +(ARM4_API_CALL* arm_is_charset_supported_t)( + const arm_charset_t charset, + arm_boolean_t *supported); + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif Added: httpd/mod_arm4/trunk/arm4os.h Url: http://svn.apache.org/viewcvs/httpd/mod_arm4/trunk/arm4os.h?view=auto&rev=109435 ============================================================================== --- (empty file) +++ httpd/mod_arm4/trunk/arm4os.h Wed Dec 1 18:24:33 2004 @@ -0,0 +1,339 @@ +/* ------------------------------------------------------------------------- */ +/* */ +/* Copyright (c) 2003 The Open Group */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining a */ +/* copy of this software (the "Software"), to deal in the Software without */ +/* restriction, including without limitation the rights to use, copy, */ +/* modify, merge, publish, distribute, sublicense, and/or sell copies of */ +/* the Software, and to permit persons to whom the Software is furnished */ +/* to do so, subject to the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be included */ +/* in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS */ +/* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT */ +/* OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR */ +/* THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/* */ +/* ------------------------------------------------------------------------- */ +/* */ +/* File revision information */ +/* */ +/* $Source: /tang_cvs/arm4/sdk4/c/include/arm4os.h,v $ */ +/* $Revision: 1.4 $ */ +/* $Date: 2004/03/04 09:24:49 $ */ +/* */ +/* ------------------------------------------------------------------------- */ +/* arm4os.h - ARM4 SDK operating system and compiler specific header file */ +/* */ +/* The arm4os.h header file hides OS and compiler specifics from the */ +/* actual ARM4 interface found in the arm4.h header file. It is meant to */ +/* facilitate the adaption of additional compiler/os combinations. */ +/* */ +/* Currently, the following platform/compiler combinations are supported and */ +/* tested: */ +/* */ +/* Platform Compiler */ +/* ------------------------------------------------------------------------- */ +/* Linux 2.4.x (x86) gcc (2.95, 3.3) GNU C/C++ Compiler */ +/* Linux 2.4.x (ppc) gcc (2.95, 3.2) GNU C/C++ Compiler */ +/* Linux 2.4.x (x86) icc (7.0) Intel C++ Compiler */ +/* Solaris 8 (sparc) cc (5.3) Sun WorkShop 6 C Compiler */ +/* Solaris 8 (sparc) CC (5.3) Sun WorkShop 6 C++ Compiler */ +/* Solaris 8 (sparc) gcc (2.95) GNU C/C++ Compiler */ +/* OSF1 V5.0 Tru64 (alpha) cc (6.1) Compaq C Compiler */ +/* OSF1 V5.0 Tru64 (alpha) gcc (2.95) GNU C/C++ Compiler */ +/* Windows 2000 (x86) MSVC (6.0) Microsoft VisualC++ */ +/* */ +/* The following mechanisms are implemented in this header file: */ +/* */ +/* 1. Determine the native compiler type for 8, 16, 32 and 64 bit integers. */ +/* Macros: ARM4_INT8, ARM4_UINT8, ARM4_INT16, ARM4_UINT16, ARM4_INT32, */ +/* ARM4_UINT32, ARM4_INT64, ARM_UINT64 and ARM4_CHAR. */ +/* 2. Special handling for exporting function symbols to support different */ +/* shared library scenarios. Set-up of specific function calling */ +/* conventions. */ +/* Macros: ARM4_API_CALL, ARM4_API_CALLVA, ARM4_API_DYNAMIC */ +/* 3. Determine compiler inlining support, if any, and setting of the */ +/* appropriate keyword for the compier used. */ +/* Macros: ARM4_INLINE */ +/* ------------------------------------------------------------------------- */ + +#ifndef ARM4OS_H_INCLUDED +#define ARM4OS_H_INCLUDED + +/* ------------------------------------------------------------------------- */ +/* Consolidate known OS platform identifiers first. */ +/* ------------------------------------------------------------------------- */ + +#if defined(WIN32) || defined(__WIN32__) +#if !defined(_WIN32) +#define _WIN32 +#endif +#endif + +#if defined(WIN64) || defined(__WIN64__) +#if !defined(_WIN64) +#define _WIN64 +#endif +#endif + +/* ------------------------------------------------------------------------- */ +/* ------------- Step 1: determine 32 and 64 bit integer types ------------- */ +/* ------------------ (compiler/target platform dependent) ----------------- */ +/* ------------------------------------------------------------------------- */ + +#if defined(__STDC_VERSION__) && __STDC_VERSION__ > 199900L + +/* C99 standard defines all types required for us. */ +#ifdef __cplusplus +#include +#else +#include +#endif + +#define ARM4_CHAR char + +#define ARM4_INT8 int8_t +#define ARM4_INT16 int16_t +#define ARM4_INT32 int32_t +#define ARM4_INT64 int64_t + +#define ARM4_UINT8 uint8_t +#define ARM4_UINT16 uint16_t +#define ARM4_UINT32 uint32_t +#define ARM4_UINT64 uint64_t + +#else + +/* Needed to find out appropriate int32 and int64 types, limit.h is an */ +/* ANSI-C header file. Thus any ANSI-C compliant compiler works. */ +#ifdef __cplusplus +#include +#else +#include +#endif + +/* set-up arm_int32_t type */ +#if INT_MAX == 2147483647l +#define ARM4_INT32 int +#elif LONG_MAX == 2147483647l +#define ARM4_INT32 long +#else +#error "can't determine 32bit integer type" +#endif /* INT_MAX == 2147483647l */ + +#ifndef ARM4_UINT32 +#define ARM4_UINT32 unsigned ARM4_INT32 +#endif /* !ARM4_UINT32 */ + +/* now find appropriate 64 bit integer type */ +#ifndef ARM4_INT64 + +#if defined(_MSC_VER) || defined(__BORLANDC__) || defined (__WATCOMC__) +/* MSVC and compatible compiler native 64 bit types */ +#define ARM4_INT64 __int64 + +#elif (defined(LLONG_MAX) && LLONG_MAX > 2147483647l) || \ + (defined(LONGLONG_MAX) && LONGLONG_MAX > 2147483647l) +/* LLONG_MAX and LONGLONG_MAX indicate usage of long long 64 bit types */ +#define ARM4_INT64 long long + +#elif (defined(__GNUC__) && \ + (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95))) +/* GNU supports long long. To be safe just use current V 2.95 or V3.x */ +/* Older versions have to be checked first! */ +#define ARM4_INT64 long long + +#elif defined(__INTEL_COMPILER) +/* INTEL C compiler for Windows/Linux supports long long. */ +#define ARM4_INT64 long long + +#elif defined(__hpux) +/* hpux uses *int64_t */ +#define ARM4_INT64 int64_t +#define ARM4_UINT64 uint64_t + +#elif LONG_MAX > 2147483647l +/* on 64-bit systems the normal long type could actually be a 64-bit type */ +#define ARM4_INT64 long + +#else +/* Raise a compile-time error if unsure. Note that assuming "long long" */ +/* for int64 might get past the compilation but may cause run-time problems */ +/* if it is not exactly 64-bit. */ +#error "can't determine 64bit integer type" + +#endif /* _MSC_VER ... */ +#endif /* ARM4_INT64 */ + +/* if ARM4_UINT64 isn't set, use ARM4_INT64 combined with unsigned keyword. */ +#ifndef ARM4_UINT64 +#define ARM4_UINT64 unsigned ARM4_INT64 +#endif /* !ARM4_UINT64 */ + + +/* define standard character and integer defintions if not set previously. */ +#ifndef ARM4_CHAR +#define ARM4_CHAR char +#endif + +#ifndef ARM4_INT8 +#define ARM4_INT8 signed char +#endif + +#ifndef ARM4_UINT8 +#define ARM4_UINT8 unsigned char +#endif + +#ifndef ARM4_INT16 +#define ARM4_INT16 signed short +#endif + +#ifndef ARM4_UINT16 +#define ARM4_UINT16 unsigned short +#endif + +#endif /* defined(__STDC_VERSION__) && __STDC_VERSION__ > 199900L */ + +#if defined(_WIN32) || defined(_WIN64) +#define ARM4_LLCONST(x) ((arm_int64_t) (x)) +#define ARM4_ULLCONST(x) ((arm_uint64_t) (x)) +#else +#define ARM4_LLCONST(x) x##ll +#define ARM4_ULLCONST(x) x##ull +#endif + +/* ------------------------------------------------------------------------- */ +/* ---------------------- Step 2: API function export ---------------------- */ +/* ------------------ (compiler/target platform dependent) ----------------- */ +/* ------------------------------------------------------------------------- */ + +/* Each OS platform needs to define the API calling convention for itself, */ +/* and make sure the proper compiler keywords are used. */ +/* ARM4_API_CALL is for API calls with fixed # of parameters, while */ +/* ARM4_API_VACALL is for API calls with variable # of parameters. */ + +#if defined(_WIN32) || defined(_WIN64) +/* For 32-bit and 64-bit Windows, "stdcall" (pascal) calling convention is */ +/* explicitly chosen for ARM4_API_CALL to save a few instructions per call. */ +#if defined(__GNUC__) +#define ARM4_API_CALL __attribute__((stdcall)) +#define ARM4_API_VACALL __attribute__((cdecl)) +#else +/* If a compiler does not support __stdcall or __cdecl, it will generate */ +/* compile time errors when encountering these modifiers. Most compilers, */ +/* e.g. _MSC_VER, __WATCOMC__, __BORLANDC__ and __MWERKS__ do support both. */ +/* __INTEL_COMPILER knows both, too. */ +#define ARM4_API_CALL __stdcall +#define ARM4_API_VACALL __cdecl +#endif +#endif /* _WIN32 || _WIN64 */ + +#if defined(linux) + +#if defined(__GNUC__) + +#if defined(__i386__) +#define ARM4_API_CALL __attribute__((stdcall)) +#define ARM4_API_VACALL __attribute__((cdecl)) +#endif + +#elif !defined(__INTEL_COMPILER) +/* On linux the intel compiler doesn't support __stdcall !?!*/ +#define ARM4_API_CALL __stdcall +#define ARM4_API_VACALL __cdecl + +#endif +#endif /* linux */ + +/* For other OS platforms, the compiler's default calling convention is used */ +/* and, hopefully, this won't cause link-time or run-time problems. */ +#if !defined(ARM4_API_CALL) +#define ARM4_API_CALL +#define ARM4_API_VACALL +#endif + +/* Set up the ARM4_API_DYNAMIC definition here so the ARM library can be */ +/* built correctly as a shared library or DLL. Note the return type of the */ +/* API call must be specified as an argument to this macro because MSVC */ +/* needs the __declspec() before and __stdcall keyword after the return type.*/ +/* */ +/* Note that dllexport and dllimport are needed only for _WIN32 or _WIN64. */ +/* It is recommended that ARM agent providers for Windows explicitly use an */ +/* libarm4.def to spell out the exact name of the exports, such that */ +/* applications can do a GetProcAddress() without problems. Note that in the */ +/* case of a compiler not supporting __declspec(), compile time errors are */ +/* to be expected. */ + +#if !(defined(_WIN32) || defined(_WIN64)) || defined(ARM4_NODLL) +#define ARM4_API_DYNAMIC(type) extern type ARM4_API_CALL + +#elif defined(__GNUC__) +#if defined(ARM4_BUILD_DLL) +#define ARM4_API_DYNAMIC(type) __attribute__((dllexport)) type ARM4_API_CALL +#else +#define ARM4_API_DYNAMIC(type) __attribute__((dllimport)) type ARM4_API_CALL +#endif +#else +#if defined(ARM4_BUILD_DLL) +#define ARM4_API_DYNAMIC(type) __declspec(dllexport) type ARM4_API_CALL +#else +#define ARM4_API_DYNAMIC(type) __declspec(dllimport) type ARM4_API_CALL +#endif /* __GNUC__ */ + +#endif /* !defined(_WIN32) || ... */ + +#define ARM4_API_STATIC(type) type ARM4_API_CALL +#define ARM4_API_VASTATIC(type) type ARM4_API_VACALL + +/* ------------------------------------------------------------------------- */ +/* ------------------------ Step 3: inlining support ----------------------- */ +/* ---------------------------- (compiler dependent) ----------------------- */ +/* ------------------------------------------------------------------------- */ + +/* determine correct inline keyword */ +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ > 199900L) || \ + defined(__cplusplus) +/* C99 C compliant and C++ compilers use the inline keyword */ +#define ARM4_INLINE inline + +#elif defined(__GNUC__) +/* GNU C supports inlining */ +#if __GNUC__ > 2 +#define ARM4_INLINE static __attribute__((always_inline)) __inline__ +#else +#define ARM4_INLINE static __inline__ +#endif + +#elif defined(_MSC_VER) +/* MSVC supports inlining */ +#define ARM4_INLINE __inline + +#elif defined(__INTEL_COMPILER) +/* INTEL compiler can take both inline or __inline */ +#define ARM4_INLINE __inline + +#elif defined(__DECC) +/* Compaq C V6.1 cc compiler can take __inline */ +#define ARM4_INLINE __inline + +/* any other compiler specific inline support should be */ +/* placed here. */ + +#else +/* not sure if the current compiler supports inlining, so */ +/* use the default keyword. Compile time errors will result */ +/* if the compiler does not support the default keyword. */ +#define ARM4_INLINE inline + +#endif /* (defined(__STD_VERSION__) && ... */ + +/* ------------------------------------------------------------------------- */ + +#endif /* !ARM4OS_H_INCLUDED */