/*
*+
* Name:
* fkeymap.c
* Purpose:
* Define a FORTRAN 77 interface to the AST KeyMap class.
* Type of Module:
* C source file.
* Description:
* This file defines FORTRAN 77-callable C functions which provide
* a public FORTRAN 77 interface to the KeyMap class.
* Routines Defined:
* AST_ISAKEYMAP
* AST_KEYMAP
* AST_MAPCOPY
* AST_MAPPUT0<X>
* AST_MAPPUT1<X>
* AST_MAPPUTU
* AST_MAPGET0<X>
* AST_MAPGET1<X>
* AST_MAPGETELEM<X>
* AST_MAPPUTELEM<X>
* AST_MAPREMOVE
* AST_MAPRENAME
* AST_MAPSIZE
* AST_MAPLENGTH
* AST_MAPLENC
* AST_MAPTYPE
* AST_MAPKEY
* Copyright:
* Copyright (C) 1997-2006 Council for the Central Laboratory of the
* Research Councils
* Licence:
* This program is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, either
* version 3 of the License, or (at your option) any later
* version.
*
* This program 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* License along with this program. If not, see
* <http://www.gnu.org/licenses/>.
* Authors:
* DSB: D.S. Berry (Starlink)
* History:
* 13-NOV-2004 (DSB):
* Original version.
* 5-JUN-2006 (DSB):
* Added support for single precision entries.
*/
/* Define the astFORTRAN77 macro which prevents error messages from
AST C functions from reporting the file and line number where the
error occurred (since these would refer to this file, they would
not be useful). */
#define astFORTRAN77
/* Header files. */
/* ============= */
#include "f77.h" /* FORTRAN <-> C interface macros (SUN/209) */
#include "c2f77.h" /* F77 <-> C support functions/macros */
#include "error.h" /* Error reporting facilities */
#include "memory.h" /* Memory handling facilities */
#include "keymap.h" /* C interface to the KeyMap class */
F77_LOGICAL_FUNCTION(ast_isakeymap)( INTEGER(THIS), INTEGER(STATUS) ) {
GENPTR_INTEGER(THIS)
F77_LOGICAL_TYPE(RESULT);
astAt( "AST_ISAKEYMAP", NULL, 0 );
astWatchSTATUS(
RESULT = astIsAKeyMap( astI2P( *THIS ) ) ? F77_TRUE : F77_FALSE;
)
return RESULT;
}
F77_INTEGER_FUNCTION(ast_keymap)( CHARACTER(OPTIONS),
INTEGER(STATUS)
TRAIL(OPTIONS) ) {
GENPTR_CHARACTER(OPTIONS)
F77_INTEGER_TYPE(RESULT);
char *options;
int i;
astAt( "AST_KEYMAP", NULL, 0 );
astWatchSTATUS(
options = astString( OPTIONS, OPTIONS_length );
/* Truncate the options string to exlucde any trailing spaces. */
astChrTrunc( options );
/* Change ',' to '\n' (see AST_SET in fobject.c for why). */
if ( astOK ) {
for ( i = 0; options[ i ]; i++ ) {
if ( options[ i ] == ',' ) options[ i ] = '\n';
}
}
RESULT = astP2I( astKeyMap( "%s", options ) );
astFree( options );
)
return RESULT;
}
F77_SUBROUTINE(ast_mapput0a)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
astAt( "AST_MAPPUT0A", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
astMapPut0A( astI2P( *THIS ), key, astI2P( *VALUE ), comment );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput0c)( INTEGER(THIS),
CHARACTER(KEY),
CHARACTER(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(VALUE)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_CHARACTER(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *value, *key;
astAt( "AST_MAPPUT0C", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
value = astString( VALUE, VALUE_length );
comment = astString( COMMENT, COMMENT_length );
astMapPut0C( astI2P( *THIS ), key, value, comment );
astFree( key );
astFree( value );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput0i)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
astAt( "AST_MAPPUT0I", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
astMapPut0I( astI2P( *THIS ), key, *VALUE, comment );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput0s)( INTEGER(THIS),
CHARACTER(KEY),
WORD(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_WORD(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
astAt( "AST_MAPPUT0W", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
astMapPut0S( astI2P( *THIS ), key, *VALUE, comment );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput0b)( INTEGER(THIS),
CHARACTER(KEY),
UBYTE(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_UBYTE(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
astAt( "AST_MAPPUT0B", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
astMapPut0B( astI2P( *THIS ), key, *VALUE, comment );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput0d)( INTEGER(THIS),
CHARACTER(KEY),
DOUBLE(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_DOUBLE(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
astAt( "AST_MAPPUT0D", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
astMapPut0D( astI2P( *THIS ), key, *VALUE, comment );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput0r)( INTEGER(THIS),
CHARACTER(KEY),
REAL(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_REAL(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
astAt( "AST_MAPPUT0R", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
astMapPut0F( astI2P( *THIS ), key, *VALUE, comment );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput1a)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(SIZE),
INTEGER_ARRAY(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(SIZE)
GENPTR_INTEGER_ARRAY(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
AstObject **values;
int i;
astAt( "AST_MAPPUT1A", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
values = astMalloc( sizeof( AstObject * )*(size_t)( *SIZE ));
if( astOK ) {
for( i = 0; i < *SIZE; i++ ) {
values[ i ] = astI2P( VALUE[ i ] );
}
}
astMapPut1A( astI2P( *THIS ), key, *SIZE, values, comment );
astFree( values );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput1c)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(SIZE),
CHARACTER_ARRAY(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(VALUE)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(SIZE)
GENPTR_CHARACTER_ARRAY(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
const char **values;
int i;
astAt( "AST_MAPPUT1C", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
values = astMalloc( sizeof( const char * )*(size_t)( *SIZE ));
if( astOK ) {
for( i = 0; i < *SIZE; i++ ) {
values[ i ] = astString( VALUE + i*VALUE_length, VALUE_length );
}
}
astMapPut1C( astI2P( *THIS ), key, *SIZE, values, comment );
if( astOK ) {
for( i = 0; i < *SIZE; i++ ) astFree( (void *) values[ i ] );
}
astFree( (void *) values );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput1i)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(SIZE),
INTEGER_ARRAY(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(SIZE)
GENPTR_INTEGER_ARRAY(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
astAt( "AST_MAPPUT1I", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
astMapPut1I( astI2P( *THIS ), key, *SIZE, VALUE, comment );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput1s)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(SIZE),
WORD_ARRAY(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(SIZE)
GENPTR_WORD_ARRAY(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
astAt( "AST_MAPPUT1W", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
astMapPut1S( astI2P( *THIS ), key, *SIZE, VALUE, comment );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput1b)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(SIZE),
UBYTE_ARRAY(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(SIZE)
GENPTR_UBYTE_ARRAY(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
astAt( "AST_MAPPUT1B", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
astMapPut1B( astI2P( *THIS ), key, *SIZE, VALUE, comment );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput1d)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(SIZE),
DOUBLE_ARRAY(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(SIZE)
GENPTR_DOUBLE_ARRAY(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
astAt( "AST_MAPPUT1D", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
astMapPut1D( astI2P( *THIS ), key, *SIZE, VALUE, comment );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapput1r)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(SIZE),
REAL_ARRAY(VALUE),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(SIZE)
GENPTR_REAL_ARRAY(VALUE)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
astAt( "AST_MAPPUT1R", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
astMapPut1F( astI2P( *THIS ), key, *SIZE, VALUE, comment );
astFree( key );
astFree( comment );
)
}
F77_SUBROUTINE(ast_mapputu)( INTEGER(THIS),
CHARACTER(KEY),
CHARACTER(COMMENT),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(COMMENT) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_CHARACTER(COMMENT)
char *comment, *key;
astAt( "AST_MAPPUTU", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
comment = astString( COMMENT, COMMENT_length );
astMapPutU( astI2P( *THIS ), key, comment );
astFree( key );
astFree( comment );
)
}
F77_LOGICAL_FUNCTION(ast_mapget0i)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGET0I", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGet0I( astI2P( *THIS ), key, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget0s)( INTEGER(THIS),
CHARACTER(KEY),
WORD(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_WORD(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGET0W", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGet0S( astI2P( *THIS ), key, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget0b)( INTEGER(THIS),
CHARACTER(KEY),
UBYTE(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_UBYTE(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGET0W", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGet0B( astI2P( *THIS ), key, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget0d)( INTEGER(THIS),
CHARACTER(KEY),
DOUBLE(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_DOUBLE(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGET0D", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGet0D( astI2P( *THIS ), key, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget0r)( INTEGER(THIS),
CHARACTER(KEY),
REAL(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_REAL(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGET0R", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGet0F( astI2P( *THIS ), key, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget0c)( INTEGER(THIS),
CHARACTER(KEY),
CHARACTER(VALUE),
INTEGER(L),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(VALUE) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_CHARACTER(VALUE)
GENPTR_INTEGER(L)
F77_LOGICAL_TYPE(RESULT);
char *key;
const char *value;
int i;
astAt( "AST_MAPGET0C", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
value = NULL;
RESULT = astMapGet0C( astI2P( *THIS ), key, &value ) ? F77_TRUE : F77_FALSE;
astFree( key );
i = 0;
if( value ) {
for( ; value[ i ] && ( i < VALUE_length ); i++ ) {
VALUE[ i ] = value[ i ];
}
*L = i;
} else {
*L = 0;
}
if( VALUE ) {
for( ; i < VALUE_length; i++ ) {
VALUE[ i ] = ' ';
}
}
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget0a)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
AstObject *value;
astAt( "AST_MAPGET0A", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGet0A( astI2P( *THIS ), key, &value ) ? F77_TRUE : F77_FALSE;
astFree( key );
*VALUE = astP2I( value );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget1i)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(MXVAL),
INTEGER(NVAL),
INTEGER_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(MXVAL)
GENPTR_INTEGER(NVAL)
GENPTR_INTEGER_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGET1I", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGet1I( astI2P( *THIS ), key, *MXVAL, NVAL, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget1d)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(MXVAL),
INTEGER(NVAL),
DOUBLE_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(MXVAL)
GENPTR_INTEGER(NVAL)
GENPTR_DOUBLE_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGET1D", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGet1D( astI2P( *THIS ), key, *MXVAL, NVAL, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget1s)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(MXVAL),
INTEGER(NVAL),
WORD_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(MXVAL)
GENPTR_INTEGER(NVAL)
GENPTR_WORD_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGET1W", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGet1S( astI2P( *THIS ), key, *MXVAL, NVAL, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget1b)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(MXVAL),
INTEGER(NVAL),
UBYTE_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(MXVAL)
GENPTR_INTEGER(NVAL)
GENPTR_UBYTE_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGET1B", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGet1B( astI2P( *THIS ), key, *MXVAL, NVAL, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget1r)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(MXVAL),
INTEGER(NVAL),
REAL_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(MXVAL)
GENPTR_INTEGER(NVAL)
GENPTR_REAL_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGET1R", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGet1F( astI2P( *THIS ), key, *MXVAL, NVAL, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget1a)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(MXVAL),
INTEGER(NVAL),
INTEGER_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(MXVAL)
GENPTR_INTEGER(NVAL)
GENPTR_INTEGER_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
AstObject **values;
int i;
astAt( "AST_MAPGET1A", NULL, 0 );
astWatchSTATUS(
values = astMalloc( sizeof( AstObject *)*(size_t) *MXVAL );
key = astString( KEY, KEY_length );
RESULT = astMapGet1A( astI2P( *THIS ), key, *MXVAL, NVAL, values ) ? F77_TRUE : F77_FALSE;
astFree( key );
if( astOK ) {
for( i = 0; i < *NVAL; i++ ) VALUE[ i ] = astP2I( values[ i ] );
}
astFree( values );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapget1c)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(MXVAL),
INTEGER(NVAL),
CHARACTER_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(VALUE) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(MXVAL)
GENPTR_INTEGER(NVAL)
GENPTR_CHARACTER_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
char *values, *c, *d;
int i, j, term;
astAt( "AST_MAPGET1C", NULL, 0 );
astWatchSTATUS(
values = astMalloc( sizeof( char )*(size_t) (*MXVAL)*( VALUE_length + 1 ) );
key = astString( KEY, KEY_length );
RESULT = astMapGet1C( astI2P( *THIS ), key, VALUE_length + 1, *MXVAL,
NVAL, values ) ? F77_TRUE : F77_FALSE;
astFree( key );
/* Loop round each string value returned in the array */
if( astOK ) {
c = values;
d = VALUE;
for( i = 0; i < *NVAL; i++ ) {
/* Loop round each of character in the "i"th element of the returned
array. Copy characters from the work array until a terminating null is
found. Replace this null by a space and replace all subsequent
characters by spaces up to the end of the returned array element. */
term = 0;
for( j = 0; j < VALUE_length; j++, d++, c++ ) {
if( term ) {
*d = ' ';
} else if( (*d = *c) == 0 ) {
*d = ' ';
term = 1;
}
}
/* Skip over the extra character at the end of each element in the work
array. */
c++;
}
}
astFree( values );
)
return RESULT;
}
F77_SUBROUTINE(ast_mapremove)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
char *key;
astAt( "AST_MAPREMOVE", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
astMapRemove( astI2P( *THIS ), key );
astFree( key );
)
}
F77_SUBROUTINE(ast_maprename)( INTEGER(THIS),
CHARACTER(OLDKEY),
CHARACTER(NEWKEY),
INTEGER(STATUS)
TRAIL(OLDKEY)
TRAIL(NEWKEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(OLDKEY)
GENPTR_CHARACTER(NEWKEY)
char *oldkey, *newkey;
astAt( "AST_MAPRENAME", NULL, 0 );
astWatchSTATUS(
oldkey = astString( OLDKEY, OLDKEY_length );
newkey = astString( NEWKEY, NEWKEY_length );
astMapRename( astI2P( *THIS ), oldkey, newkey );
astFree( oldkey );
astFree( newkey );
)
}
F77_SUBROUTINE(ast_mapcopy)( INTEGER(THIS),
INTEGER(THAT),
INTEGER(STATUS) ) {
GENPTR_INTEGER(THIS)
GENPTR_INTEGER(THAT)
astAt( "AST_MAPCOPY", NULL, 0 );
astWatchSTATUS(
astMapCopy( astI2P( *THIS ), astI2P( *THAT ) );
)
}
F77_INTEGER_FUNCTION(ast_mapsize)( INTEGER(THIS), INTEGER(STATUS) ) {
GENPTR_INTEGER(THIS)
F77_INTEGER_TYPE(RESULT);
astAt( "AST_MAPSIZE", NULL, 0 );
astWatchSTATUS(
RESULT = astMapSize( astI2P( *THIS ) );
)
return RESULT;
}
F77_INTEGER_FUNCTION(ast_maplength)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
F77_INTEGER_TYPE(RESULT);
char *key;
astAt( "AST_MAPLENGTH", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapLength( astI2P( *THIS ), key );
astFree( key );
)
return RESULT;
}
F77_INTEGER_FUNCTION(ast_maplenc)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
F77_INTEGER_TYPE(RESULT);
char *key;
astAt( "AST_MAPLENGTH", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapLenC( astI2P( *THIS ), key );
astFree( key );
)
return RESULT;
}
F77_INTEGER_FUNCTION(ast_maptype)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
F77_INTEGER_TYPE(RESULT);
char *key;
astAt( "AST_MAPTYPE", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapType( astI2P( *THIS ), key );
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_maphaskey)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPHASKEY", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapHasKey( astI2P( *THIS ), key ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapdefined)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPDEFINED", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapDefined( astI2P( *THIS ), key ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
/* NO_CHAR_FUNCTION indicates that the f77.h method of returning a
character result doesn't work, so add an extra argument instead and
wrap this function up in a normal FORTRAN 77 function (in the file
keymap.f). */
#if NO_CHAR_FUNCTION
F77_SUBROUTINE(ast_mapkey_a)( CHARACTER(RESULT),
#else
F77_SUBROUTINE(ast_mapkey)( CHARACTER_RETURN_VALUE(RESULT),
#endif
INTEGER(THIS),
INTEGER(INDEX),
#if NO_CHAR_FUNCTION
INTEGER(STATUS)
TRAIL(RESULT) ) {
#else
INTEGER(STATUS) ) {
#endif
GENPTR_CHARACTER(RESULT)
GENPTR_INTEGER(THIS)
GENPTR_INTEGER(INDEX)
const char *result;
int i;
astAt( "AST_MAPKEY", NULL, 0 );
astWatchSTATUS(
result = astMapKey( astI2P( *THIS ), *INDEX - 1 );
i = 0;
if ( astOK ) { /* Copy result */
for ( ; result[ i ] && i < RESULT_length; i++ ) {
RESULT[ i ] = result[ i ];
}
}
while ( i < RESULT_length ) RESULT[ i++ ] = ' '; /* Pad with blanks */
)
}
F77_LOGICAL_FUNCTION(ast_mapgetelemi)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
INTEGER_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_INTEGER_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGETELEMI", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGetElemI( astI2P( *THIS ), key, *ELEM - 1, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapgetelemd)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
DOUBLE_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_DOUBLE_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGETELEMD", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGetElemD( astI2P( *THIS ), key, *ELEM - 1, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapgetelems)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
WORD_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_WORD_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGETELEMW", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGetElemS( astI2P( *THIS ), key, *ELEM - 1, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapgetelemb)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
UBYTE_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_UBYTE_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGETELEMB", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGetElemB( astI2P( *THIS ), key, *ELEM - 1, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapgetelemr)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
REAL_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_REAL_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
astAt( "AST_MAPGETELEMR", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGetElemF( astI2P( *THIS ), key, *ELEM - 1, VALUE ) ? F77_TRUE : F77_FALSE;
astFree( key );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapgetelema)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
INTEGER_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_INTEGER_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
AstObject *ptr;
astAt( "AST_MAPGETELEMA", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
RESULT = astMapGetElemA( astI2P( *THIS ), key, *ELEM - 1, &ptr ) ? F77_TRUE : F77_FALSE;
astFree( key );
if( astOK ) *VALUE = astP2I( ptr );
)
return RESULT;
}
F77_LOGICAL_FUNCTION(ast_mapgetelemc)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
CHARACTER_ARRAY(VALUE),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(VALUE) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_CHARACTER_ARRAY(VALUE)
F77_LOGICAL_TYPE(RESULT);
char *key;
char *values, *c, *d;
int j;
astAt( "AST_MAPGETELEMC", NULL, 0 );
astWatchSTATUS(
values = astMalloc( sizeof( char )*(size_t) ( VALUE_length + 1 ) );
key = astString( KEY, KEY_length );
RESULT = astMapGetElemC( astI2P( *THIS ), key, VALUE_length + 1, *ELEM - 1,
values ) ? F77_TRUE : F77_FALSE;
astFree( key );
/* Copy characters from the work array until a terminating null is
found. Replace this null by a space and replace all subsequent
characters by spaces up to the end of the returned array element. */
if( astOK ) {
c = values;
d = VALUE;
for( j = 0; j < VALUE_length; j++, d++, c++ ) {
if( (*d = *c) == 0 ) {
*d = ' ';
break;
}
}
for( ; j < VALUE_length; j++, d++ ) *d = ' ';
}
astFree( values );
)
return RESULT;
}
F77_SUBROUTINE(ast_mapputelemi)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
INTEGER(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_INTEGER(VALUE)
char *key;
astAt( "AST_MAPPUTELEMI", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
astMapPutElemI( astI2P( *THIS ), key, *ELEM - 1, *VALUE );
astFree( key );
)
}
F77_SUBROUTINE(ast_mapputelems)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
WORD(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_WORD(VALUE)
char *key;
astAt( "AST_MAPPUTELEMW", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
astMapPutElemS( astI2P( *THIS ), key, *ELEM - 1, *VALUE );
astFree( key );
)
}
F77_SUBROUTINE(ast_mapputelemb)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
UBYTE(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_UBYTE(VALUE)
char *key;
astAt( "AST_MAPPUTELEMB", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
astMapPutElemB( astI2P( *THIS ), key, *ELEM - 1, *VALUE );
astFree( key );
)
}
F77_SUBROUTINE(ast_mapputelemd)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
DOUBLE(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_DOUBLE(VALUE)
char *key;
astAt( "AST_MAPPUTELEMD", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
astMapPutElemD( astI2P( *THIS ), key, *ELEM - 1, *VALUE );
astFree( key );
)
}
F77_SUBROUTINE(ast_mapputelemr)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
REAL(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_REAL(VALUE)
char *key;
astAt( "AST_MAPPUTELEMR", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
astMapPutElemF( astI2P( *THIS ), key, *ELEM - 1, *VALUE );
astFree( key );
)
}
F77_SUBROUTINE(ast_mapputelema)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
INTEGER(VALUE),
INTEGER(STATUS)
TRAIL(KEY) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_INTEGER(VALUE)
char *key;
astAt( "AST_MAPPUTELEMA", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
astMapPutElemA( astI2P( *THIS ), key, *ELEM - 1, astI2P( *VALUE ) );
astFree( key );
)
}
F77_SUBROUTINE(ast_mapputelemc)( INTEGER(THIS),
CHARACTER(KEY),
INTEGER(ELEM),
CHARACTER(VALUE),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(VALUE) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_INTEGER(ELEM)
GENPTR_CHARACTER(VALUE)
char *key;
char *value;
astAt( "AST_MAPPUTELEMC", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
value = astString( VALUE, VALUE_length );
astMapPutElemC( astI2P( *THIS ), key, *ELEM - 1, value );
astFree( key );
astFree( value );
)
}
F77_LOGICAL_FUNCTION(ast_mapgetc)( INTEGER(THIS),
CHARACTER(KEY),
CHARACTER(VALUE),
INTEGER(L),
INTEGER(STATUS)
TRAIL(KEY)
TRAIL(VALUE) ) {
GENPTR_INTEGER(THIS)
GENPTR_CHARACTER(KEY)
GENPTR_CHARACTER(VALUE)
GENPTR_INTEGER(L)
F77_LOGICAL_TYPE(RESULT);
char *key;
const char *value;
int i;
astAt( "AST_MAPGETC", NULL, 0 );
astWatchSTATUS(
key = astString( KEY, KEY_length );
value = NULL;
RESULT = astMapGetC( astI2P( *THIS ), key, &value ) ? F77_TRUE : F77_FALSE;
astFree( key );
i = 0;
if( value ) {
for( ; value[ i ] && ( i < VALUE_length ); i++ ) {
VALUE[ i ] = value[ i ];
}
*L = i;
} else {
*L = 0;
}
if( VALUE ) {
for( ; i < VALUE_length; i++ ) {
VALUE[ i ] = ' ';
}
}
)
return RESULT;
}