mxArray *
dbfield2mxArray( Dbptr db )
{
mxArray *result;
long type;
Dbvalue value;
char warning[STRSZ];
dbquery( db, dbFIELD_TYPE, &type );
antelope_mex_clear_register( 1 );
if( dbget( db, value.s ) < 0 )
{
antelope_mex_clear_register( 1 );
return (mxArray *) NULL;
}
switch( type )
{
case dbDBPTR:
result = CreateDbptrStructFromDbptr( value.db );
break;
case dbSTRING:
copystrip( value.s, value.s, strlen( value.s ) );
result = mxCreateString( value.s );
break;
case dbBOOLEAN:
case dbINTEGER:
case dbYEARDAY:
copystrip( value.s, value.s, strlen( value.s ) );
result = CreateDouble( (double) atol( value.s ) );
break;
case dbREAL:
case dbTIME:
copystrip( value.s, value.s, strlen( value.s ) );
result = CreateDouble( (double) atof( value.s ) );
break;
default:
sprintf( warning,
"Can't interpret field of type %s",
xlatnum( type, Dbxlat, NDbxlat ) );
mexWarnMsgTxt( warning );
result = (mxArray *) NULL;
break;
}
return result;
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
double orbfd;
int version;
if( nrhs != 1 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( ! get_scalar( prhs[0], &orbfd ) )
{
mexErrMsgTxt( "orbping: bad orb file descriptor\n" );
}
if( mex_orbping( (int) orbfd, &version ) ) {
antelope_mex_clear_register( 1 );
mexErrMsgTxt ( "orbping: failed\n" );
}
plhs[0] = CreateDouble( (double) version );
if( plhs[0] == NULL )
{
mexErrMsgTxt( "orbping: failed to create return value" );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
double orbfd;
if( nlhs > 0 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( nrhs != 1 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( ! get_scalar( prhs[0], &orbfd ) )
{
mexErrMsgTxt( "orbclose: bad orb file descriptor\n" );
}
if( mex_orbclose( (int) orbfd ) ) {
antelope_mex_clear_register( 1 );
mexErrMsgTxt ( "orbclose: failed\n" );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
char *filename;
FILE *fp;
Response *response;
if( nlhs > 1 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( nrhs != 1 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_trimmed_string( prhs[0], &filename ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( ( fp = fopen( filename, "r" ) ) == NULL ) {
perror( "dbresponse" );
mxFree( filename );
mexErrMsgTxt( "Failed to open response file." );
} else {
mxFree( filename );
}
if( read_response( fp, &response ) != 0 ) {
fclose( fp );
antelope_mex_clear_register( 1 );
mexErrMsgTxt( "Failed to read response file." );
} else {
antelope_mex_clear_register( 1 );
fclose( fp );
}
plhs[0] = Response2mxArray( response );
if( ! plhs[0] )
{
mexErrMsgTxt( "Failed to create an object of class dbresponse");
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
float *data = NULL;
double *doublep;
mwSize *dims;
int nsamp;
int rc;
int i;
mexWarnMsgTxt ( "\ntrputwf is DEPRECATED; switch to trsave_wf\n" );
if( nrhs != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( mxGetClassID( prhs[1] ) != mxDOUBLE_CLASS )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( mxGetNumberOfDimensions( prhs[1] ) != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
dims = (mwSize *) mxGetDimensions( prhs[1] );
if( dims[1] != 1 && dims[0] != 1 )
mexErrMsgTxt ( "trputwf: DATA must have dimensions Nx1 or 1xN\n" );
if( dims[1] == 1 ) nsamp = dims[0];
else nsamp = dims[1];
doublep = mxGetPr( prhs[1] );
data = mxCalloc( nsamp, sizeof( float ) );
for( i=0; i<nsamp; i++ )
{
data[i] = (float) doublep[i];
}
rc = trputwf( db, data );
antelope_mex_clear_register( 1 );
mxFree( data );
if( rc == dbINVALID )
{
mexErrMsgTxt( "trputwf: failed\n" );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
Tbl *groupfields = 0;
char errmsg[STRSZ];
int rhs_index;
long type = 1;
double type_fp = 1;
if( nrhs < 2 || nrhs > 3 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_stringtbl( prhs[1], &groupfields ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( nrhs == 3 ) {
if( ! get_scalar( prhs[2], &type_fp ) ) {
antelope_mexUsageMsgTxt ( USAGE );
return;
} else {
type = (long) type_fp;
}
}
db = dbgroup( db, groupfields, NULL, type );
antelope_mex_clear_register( 1 );
freetbl( groupfields, 0 );
if( db.table == dbINVALID )
{
mexErrMsgTxt( "dbgroup: group failed" );
}
plhs[0] = CreateDbptrStructFromDbptr( db );
if( plhs[0] == NULL )
{
sprintf( errmsg, "dbgroup: failed to create database-pointer " );
strcat( errmsg, "structure for result" );
mexErrMsgTxt( errmsg );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
char *tablename = 0;
char filename[FILENAME_MAX];
char status[STRSZ];
int rc;
if( nrhs != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_string( prhs[1], &tablename ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
rc = dbextfile( db, tablename, filename );
antelope_mex_clear_register( 1 );
switch( rc ) {
case 2:
sprintf( status, "file exists, is compressed, and is readable" );
break;
case 1:
sprintf( status, "file exists and is readable" );
break;
case 0:
sprintf( status, "file does not exist, but directory is writeable" );
break;
case -1:
sprintf( status, "file does not exist; directory is not writeable" );
break;
default:
sprintf( status, "file status unknown" );
break;
}
mxFree( tablename );
plhs[0] = mxCreateString( filename );
plhs[1] = mxCreateString( status );
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr tr;
char *newchan[3];
Tbl *newchan_tbl;
int rc;
int i;
if( nrhs != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &tr ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_stringtbl( prhs[1], &newchan_tbl ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( maxtbl( newchan_tbl ) != 3 )
{
freetbl( newchan_tbl, 0 );
mexErrMsgTxt( "NEWCHANS array must have three channel names" );
}
else
{
for( i = 0; i < 3; i++ )
{
newchan[i] = gettbl( newchan_tbl, i );
}
}
rc = rotate_to_standard( tr, newchan );
antelope_mex_clear_register( 1 );
freetbl( newchan_tbl, 0 );
plhs[0] = CreateDouble( (double) rc );
if( plhs[0] == NULL )
{
mexErrMsgTxt( "trrotate_to_standard: failed to create return value" );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
char *record;
int use_dbscratch = 0;
int rc;
if( nrhs != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_string( prhs[1], &record ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( STREQ( record, "dbSCRATCH" ) )
{
mxFree( record );
record = 0;
}
rc = dbadd( db, record );
antelope_mex_clear_register( 1 );
if( record ) mxFree( record );
if( rc < 0 )
{
mexErrMsgTxt( "dbadd: failed to add record" );
}
else
{
plhs[0] = CreateDouble( (double) rc );
if( plhs[0] == NULL )
{
mexErrMsgTxt( "dbadd: failed to create return value" );
}
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Pf *pf;
char *name;
char *mystring;
mxArray *input[1];
if( nlhs > 1 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( nrhs != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_pf( prhs[0], &pf ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_string( prhs[1], &name ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
pfconfig( "ask", (void *) matlabPfprompt );
mystring = pfget_string( pf, name );
antelope_mex_clear_register( 1 );
mxFree( name );
if( mystring == NULL )
{
mexErrMsgTxt( "pfget_num: Couldn't get specified value" );
}
else
{
input[0] = mxCreateString( mystring );
mexCallMATLAB( 1, plhs, 1, input, "str2double" );
mxDestroyArray( input[0] );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
int type;
char *string;
int printflag;
double *doublep;
int *intp;
int i;
char **messages;
int *count;
int NMAX;
int next, wrapflag;
char s[STRSZ];
if( nrhs > 1 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( nrhs == 1 )
{
if( ! mtlb_get_string( prhs[0], &string ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! STREQ( string, "print" ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else
{
mxFree( string );
printflag = 1;
}
}
else
{
printflag = 0;
}
antelope_mex_clear_register ( printflag );
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr tr;
if( nrhs != 1 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &tr ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
trdestroy( &tr );
antelope_mex_clear_register( 1 );
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr tr;
char *tr_path = 0;
char *schema_name = 0;
char errmsg[STRSZ];
if( nrhs > 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( nrhs >= 1 && ! get_trimmed_string( prhs[0], &tr_path ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( nrhs == 2 && ! mtlb_get_string( prhs[1], &schema_name ) )
{
mxFree( tr_path );
antelope_mexUsageMsgTxt ( USAGE );
return;
}
tr = trnew( tr_path, schema_name );
antelope_mex_clear_register( 1 );
if( tr_path ) mxFree( tr_path );
if( schema_name ) mxFree( schema_name );
if( tr.database == dbINVALID )
{
mexErrMsgTxt( "trnew: failed to create new trace database" );
}
plhs[0] = CreateDbptrStructFromDbptr( tr );
if( plhs[0] == NULL )
{
sprintf( errmsg, "trnew: failed to create database-pointer " );
strcat( errmsg, "structure for result" );
mexErrMsgTxt( errmsg );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
char *table;
char errmsg[STRSZ];
if( nrhs != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_string( prhs[1], &table ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
db = dbseparate( db, table );
antelope_mex_clear_register( 1 );
if( db.table == dbINVALID )
{
mexErrMsgTxt( "dbseparate: returned invalid database pointer" );
}
mxFree( table );
plhs[0] = CreateDbptrStructFromDbptr( db );
if( plhs[0] == NULL )
{
sprintf( errmsg, "dbseparate: failed to create " );
strcat( errmsg, "database-pointer structure for result" );
mexErrMsgTxt( errmsg );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
double orbfd;
double time;
int nselected;
int pktid;
if( nlhs > 1 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( nrhs != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( ! get_scalar( prhs[0], &orbfd ) )
{
antelope_mexUsageMsgTxt ( USAGE );
mexErrMsgTxt( "orbafter: bad orb file descriptor\n" );
}
if( ! get_scalar( prhs[1], &time ) )
{
antelope_mexUsageMsgTxt ( USAGE );
}
pktid = mex_orbafter( (int) orbfd, time );
antelope_mex_clear_register ( 1 );
plhs[0] = CreateDouble( (double) pktid );
if( plhs[0] == NULL )
{
mexErrMsgTxt( "orbafter: failed to create return value" );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr tr;
double tolerance;
if( nrhs != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &tr ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_scalar( prhs[1], &tolerance ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
trsplice( tr, tolerance, 0, 0 );
antelope_mex_clear_register( 1 );
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
char *formatstring;
char *timestring;
mxArray *timestr;
double *epoch;
int M, N;
int nsubs = 2;
int subs[2];
int cell_index;
int i, j;
if( nrhs != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( mxGetClassID( prhs[0] ) != mxDOUBLE_CLASS )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_string( prhs[1], &formatstring ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
epoch = mxGetPr( prhs[0] );
M = mxGetM( prhs[0] );
N = mxGetN( prhs[0] );
if( M == 1 && N == 1 )
{
timestring = epoch2str( *epoch, formatstring );
antelope_mex_clear_register( 1 );
plhs[0] = mxCreateString( timestring );
free( timestring );
}
else
{
plhs[0] = mxCreateCellMatrix( M, N );
for( i = 0; i < M; i++ )
{
for( j = 0; j < N; j++ )
{
timestring = epoch2str( *(epoch + i*N + j),
formatstring );
antelope_mex_clear_register( 1 );
timestr = mxCreateString( timestring );
free( timestring );
subs[0] = i;
subs[1] = j;
cell_index = mxCalcSingleSubscript( plhs[0],
nsubs, subs );
mxSetCell( plhs[0], cell_index, timestr );
}
}
}
mxFree( formatstring );
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
Dbptr tr;
int type;
char *table = NULL;
char *time_str = NULL, *endtime_str = NULL;
double scalar;
double *doublep;
float *floatp;
int *intp;
char *s;
char errmsg[STRSZ];
int rc;
if( nrhs < 3 || nrhs > 5 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( nrhs == 4 )
{
if( ! mtlb_get_string( prhs[3], &table ) )
{
if( ! get_dbptr( prhs[3], &tr ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
}
}
else if( nrhs == 5 )
{
if( ! get_dbptr( prhs[3], &tr ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( ! mtlb_get_string( prhs[4], &table ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
}
if( ! mtlb_get_string( prhs[1], &time_str ) )
{
if( ! get_scalar( prhs[1], &scalar ) )
{
if( table ) mxFree( table );
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else
{
s = epoch2str( scalar, "%E\0" );
antelope_mex_clear_register( 1 );
time_str = mxCalloc( STRSZ, sizeof( char ) );
strcpy( time_str, s );
free( s );
}
}
if( ! mtlb_get_string( prhs[2], &endtime_str ) )
{
if( ! get_scalar( prhs[2], &scalar ) )
{
if( table ) mxFree( table );
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else
{
s = epoch2str( scalar, "%E\0" );
antelope_mex_clear_register( 1 );
endtime_str = mxCalloc( STRSZ, sizeof( char ) );
strcpy( endtime_str, s );
free( s );
}
}
if( nrhs <= 3 || ( nrhs == 4 && table != NULL ) )
{
tr.database = dbINVALID;
}
rc = trload_css( db, time_str, endtime_str, &tr, table, 0 );
antelope_mex_clear_register( 1 );
if( table ) mxFree( table );
mxFree( time_str );
mxFree( endtime_str );
if( rc < 0 )
{
mexPrintf( "trload_css: No matching data were found\n" );
}
else if( rc > 0 )
{
mexErrMsgTxt( "trload_css failed\n" );
}
else /* Success */
{
plhs[0] = CreateDbptrStructFromDbptr( tr );
if( plhs[0] == NULL )
{
sprintf( errmsg, "trload_css: failed to create " );
strcat( errmsg, "database-pointer structure " );
strcat( errmsg, "for result" );
mexErrMsgTxt( errmsg );
}
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
char *database;
char *table;
char *field;
char *record;
char errmsg[STRSZ];
if( nrhs != 5 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_string( prhs[1], &database ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_string( prhs[2], &table ) )
{
mxFree( database );
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_string( prhs[3], &field ) )
{
mxFree( database );
mxFree( table );
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_string( prhs[4], &record ) )
{
mxFree( database );
mxFree( table );
mxFree( field );
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( ! STREQ( record, "" ) &&
! STREQ( record, "dbSCRATCH" ) &&
! STREQ( record, "dbNULL" ) &&
! STREQ( record, "dbALL" ) )
{
/* We're trying to match a record... */
if( STREQ( field, "dbALL" ) ||
( STREQ( field, "" ) && db.field < 0 ) )
{
/* But we don't know which field to look at */
mxFree( database );
mxFree( table );
mxFree( field );
mxFree( record );
mexErrMsgTxt(
"dblookup: Specify field before matching records" );
}
}
db = dblookup( db, database, table, field, record );
antelope_mex_clear_register( 1 );
mxFree( database );
mxFree( table );
mxFree( field );
mxFree( record );
plhs[0] = CreateDbptrStructFromDbptr( db );
if( plhs[0] == NULL )
{
sprintf( errmsg, "dblookup: failed to create " );
strcat( errmsg, "database-pointer structure for result" );
mexErrMsgTxt( errmsg );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
Point *polygon;
int nrec;
int single_record;
double NaN;
double *lat;
double *lon;
int nvertices;
int nsaved,closed;
int i,j;
double *lat_pr, *lon_pr;
Expression *expr;
int maxneeded;
int sumpoints;
int *nanindices;
char closedstr[2];
NaN=mxGetNaN();
if ( nrhs != 1 ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( ! get_dbptr( prhs[0], &db ) ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( nlhs != 2 ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
}
if (dbquery( db, dbRECORD_COUNT, &nrec) < 0) {
antelope_mex_clear_register( 1 );
mexErrMsgTxt("readpolygon: dbquery(recordcount) failed\n");
}
if (nrec <= 0 ) {
mexErrMsgTxt("readpolygon: no rows in database view\n");
}
if (db.record == dbALL) {
if (nrec == 1) {
single_record= 1;
db.record=0;
dbgetv(db,0,"npoints",&sumpoints,0);
maxneeded= (nrec*2) + sumpoints;
} else {
single_record=0;
db.record=0;
dbex_compile(db,"sum(npoints)",&expr,dbINTEGER);
dbex_eval(db,expr,0,&sumpoints);
dbex_free(expr);
maxneeded= (nrec*2) + sumpoints;
nanindices=mxCalloc(nrec,sizeof(int));
}
} else {
if (db.record >= 0) {
single_record= 1;
dbgetv(db,0,"npoints",&sumpoints,"closed",&closedstr,0);
maxneeded= (nrec*2) + sumpoints;
} else {
mexErrMsgTxt("readpolygon: unspecified subset?!?\n");
}
}
nsaved= 0;
nvertices= readPolygon(db,&polygon);
lat= mxCalloc(maxneeded+1, sizeof(double));
lon= mxCalloc(maxneeded+1, sizeof(double));
for (j= 0; j < nvertices; j++) {
lat[j]= polygon[j].lat;
lon[j]= polygon[j].lon;
}
nsaved += nvertices;
free(polygon);
/* eventually close polygon*/
if (strncmp(closedstr,"y",1)==0) {
if ( (lat[nvertices-1] != lat[0]) || (lon[nvertices-1] != lon[0]) ) {
nsaved++;
lat[nsaved-1]= lat[0];
lon[nsaved-1]= lon[0];
}
}
if ( (single_record == 0) && (nrec > 1) ) {
for (i= 1; i < nrec; i++) {
db.record=i;
dbgetv(db,0,"closed",&closedstr,0);
nvertices= readPolygon(db,&polygon);
/* separate (sub)polygons by NaN */
lat[nsaved + 1]=NaN;
lon[nsaved + 1]=NaN;
nanindices[i-1]= nsaved+1;
nsaved++;
for (j= 0; j < nvertices; j++) {
lat[j+nsaved]= polygon[j].lat;
lon[j+nsaved]= polygon[j].lon;
}
nsaved += nvertices;
/* eventually close polygon*/
if (strncmp(closedstr,"y",1)==0) {
if ( (lat[nvertices-1] != lat[0]) || (lon[nvertices-1] != lon[0]) ) {
lat[nsaved]= lat[nsaved-nvertices];
lon[nsaved]= lon[nsaved-nvertices];
nsaved++;
}
}
free(polygon);
}
}
plhs[0] = mxCreateDoubleMatrix(nsaved,1,mxREAL);
lat_pr=(double *)mxGetPr(plhs[0]);
memcpy(lat_pr, lat, nsaved*sizeof(double));
plhs[1] = mxCreateDoubleMatrix(nsaved,1,mxREAL);
lon_pr=(double *)mxGetPr(plhs[1]);
memcpy(lon_pr, lon, nsaved*sizeof(double));
/* NaN does NOT pass the memcpy */
if (single_record == 0) {
for (i=0; i < nrec-1; i++) {
lat_pr[nanindices[i]-1]=NaN;
lon_pr[nanindices[i]-1]=NaN;
}
mxFree(nanindices);
}
mxFree(lat);
mxFree(lon);
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
int single_row;
int nrows;
int nfields;
char *field_name;
int arg_index;
int rc;
int i;
if( nrhs < 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
nfields = nrhs - 1;
for( i=0; i< nfields; i++ )
{
arg_index = i + 1;
if( mxGetClassID( prhs[arg_index] ) != mxCHAR_CLASS )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
}
rc = dbquery( db, dbRECORD_COUNT, &nrows );
antelope_mex_clear_register( 1 );
if( rc == dbINVALID )
{
mexErrMsgTxt( "dbgetv: query for number of records failed" );
}
if( nrows <= 0 )
{
mexErrMsgTxt( "dbgetv: no rows in database view" );
}
if( db.record == dbALL ) {
if( nrows == 1 ) {
single_row = 1;
db.record = 0;
} else {
single_row = 0;
}
} else {
single_row = 1;
}
for( i = 0; i < nfields; i++ )
{
arg_index = i + 1;
get_malloced_string( prhs[arg_index], &field_name );
db = dblookup ( db, 0, 0, field_name, 0 );
antelope_mex_clear_register( 1 );
if( db.field < 0 )
{
cleanup_and_bail( plhs, field_name, i );
}
if( single_row )
{
plhs[i] = dbfield2mxArray( db );
}
else
{
plhs[i] = dbcolumn2mxArray( db );
}
if( plhs[i] == (mxArray *) NULL )
{
cleanup_and_bail( plhs, field_name, i );
}
mxFree( field_name );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
Tbl *tbl;
char **sortfields;
char errmsg[STRSZ];
int i, arg_index, nvarargs;
int flags = 0;
int rc;
if( nrhs < 1 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
nvarargs = nrhs - 1;
for( i = 0; i<nvarargs; i++)
{
arg_index = i + 1;
if( mxGetClassID( prhs[arg_index] ) != mxCHAR_CLASS )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
}
if( nvarargs > 0 )
{
tbl = newtbl( nvarargs );
sortfields = (char **) mxCalloc( nvarargs, sizeof( char * ) );
for( i = 0; i < nvarargs; i++ )
{
arg_index = i + 1;
get_malloced_string( prhs[arg_index], &sortfields[i] );
if( STREQ( sortfields[i], "dbSORT_UNIQUE" ) ) {
flags |= dbSORT_UNIQUE;
} else if( STREQ( sortfields[i], "dbSORT_REVERSE" ) ) {
flags |= dbSORT_REVERSE;
} else {
pushtbl( tbl, sortfields[i] );
}
}
}
else
{
rc = dbquery ( db, dbPRIMARY_KEY, &tbl );
antelope_mex_clear_register( 1 );
if( rc == dbINVALID )
{
mexErrMsgTxt( "dbsort: query for primary keys failed" );
}
}
db = dbsort ( db, tbl, flags, 0) ;
antelope_mex_clear_register( 1 );
if( nvarargs > 0 )
{
for( i = 0; i < nvarargs; i++ )
{
mxFree( sortfields[i] );
}
mxFree( sortfields );
freetbl( tbl, 0 );
}
if( db.table == dbINVALID )
{
mexErrMsgTxt( "dbsort failed" );
}
plhs[0] = CreateDbptrStructFromDbptr( db );
if( plhs[0] == NULL )
{
sprintf( errmsg, "dbsort: failed to create database-pointer " );
strcat( errmsg, "structure for result" );
mexErrMsgTxt( errmsg );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Response *response;
double *real_ptr, *imag_ptr;
double *omega_ptr;
int M, N;
int nelements;
int rc;
int i;
if( nlhs > 1 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( nrhs != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_response( prhs[0], &response ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( mxGetClassID( prhs[1] ) != mxDOUBLE_CLASS )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( mxGetNumberOfDimensions( prhs[1] ) != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
M = mxGetM( prhs[1] );
N = mxGetN( prhs[1] );
plhs[0] = mxCreateDoubleMatrix( M, N, mxCOMPLEX );
nelements = M * N;
omega_ptr = (double *) mxGetPr( prhs[1] );
real_ptr = (double *) mxGetPr( plhs[0] );
imag_ptr = (double *) mxGetPi( plhs[0] );
for( i = 0; i < nelements; i++ )
{
rc = eval_response( *omega_ptr++, response,
real_ptr++, imag_ptr++ );
if( rc ) {
mxDestroyArray( plhs[0] );
antelope_mex_clear_register( 1 );
mexErrMsgTxt( "eval_response failed" );
}
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
double orbfd;
char *orbstring_code;
char *nodelay_string;
int nodelay = 0;
char errmsg[STRSZ];
int pktid;
char srcname[STRSZ];
char pkttype[STRSZ];
double time;
char *packet = 0;
int nbytes = 0;
int bufsize = 0;
int rc;
if( nrhs < 1 || nrhs > 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_scalar( prhs[0], &orbfd ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( nrhs == 2 )
{
if( ! mtlb_get_string( prhs[1], &nodelay_string ) || ! STREQ( nodelay_string, "nodelay" ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else
{
mxFree( nodelay_string );
nodelay = 1;
}
}
if( nodelay )
{
rc = mex_orbreap_nd( (int) orbfd, &pktid, &srcname[0], &time,
&packet, &nbytes, &bufsize );
}
else
{
rc = mex_orbreap( (int) orbfd, &pktid, &srcname[0], &time,
&packet, &nbytes, &bufsize );
}
antelope_mex_clear_register( 1 );
if( rc < 0 )
{
return;
}
plhs[0] = orbpkt2mxArray( srcname, time, packet, nbytes, pkttype );
plhs[1] = CreateDouble( time );
plhs[2] = mxCreateString( srcname );
plhs[3] = CreateDouble( (double) pktid );
plhs[4] = mxCreateString( pkttype );
free( packet );
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
Point *polygon;
char *pname;
char *ptype;
char *auth;
char *dir;
char *dfile;
char *s_pcode;
int pcode;
double *lat;
double *lon;
long nsamp;
mwSize nlat,nlon;
const mwSize *dimensions;
int i;
int retcode;
char *dbfile_name;
char *dbschema_name;
char errmsg[STRSZ];
if ( nrhs != 9 ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( ! get_dbptr( prhs[0], &db ) ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( !mxIsDouble( prhs[1] ) ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( !mxIsDouble( prhs[2] ) ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( !mxIsChar( prhs[3] ) ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( !mxIsChar( prhs[4] ) ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( !mxIsChar( prhs[5] ) ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( !mxIsChar( prhs[6] ) ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( !mxIsChar( prhs[7] ) ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
} else if ( !mxIsChar( prhs[8] ) ) {
antelope_mexUsageMsgTxt ( USAGE ); return;
}
dimensions= (mwSize*) mxGetDimensions( prhs[1] );
if (dimensions[1] != 1 && dimensions[0] != 1) {
mexErrMsgTxt("writepolygondata: LAT must have dimensions Nx1 or 1xN\n");
}
if (dimensions[1] == 1) {
nlat= dimensions[0];
} else {
nlat= dimensions[1];
}
dimensions= (mwSize *)mxGetDimensions( prhs[2] );
if (dimensions[1] != 1 && dimensions[0] != 1) {
mexErrMsgTxt("writepolygondata: LON must have dimensions Nx1 or 1xN\n");
}
if (dimensions[1] == 1) {
nlon= dimensions[0];
} else {
nlon= dimensions[1];
}
if (nlat != nlon) {
mexErrMsgTxt("writepolygondata: LAT and LON must be of same size\n");
}
if( ( retcode = dbquery(db, dbDATABASE_FILENAME, &dbfile_name) ) < 0 ) {
mexErrMsgTxt("writepolygondata: problem getting descriptor filename\n");
}
if ( is_file(dbfile_name)==1 ) {
if( ( retcode = dbquery(db, dbSCHEMA_NAME, &dbschema_name) ) < 0 ) {
mexErrMsgTxt("writepolygondata: problem getting schema name\n");
} else {
if (strmatches(dbschema_name,"polygon1.2.*", 0) != 1) {
sprintf(errmsg, "writepolygondata: wrong schema '%s' for output database '%s'\n",dbschema_name,dbfile_name);
mexErrMsgTxt(errmsg);
}
}
} else {
sprintf(errmsg, "writepolygondata: please create database schema '%s' with schema polygon1.2\n",dbfile_name);
mexErrMsgTxt(errmsg);
//there might be a fix, but for the moment this simply does NOT work
if (dbcreate(dbfile_name,"polygon1.2",0, 0, 0) != 0 ) {
mexErrMsgTxt("writepolygondata: problem with dbcreate\n");
}
}
nsamp= (long) nlat;
lat= mxGetPr(prhs[1]);
lon= mxGetPr(prhs[2]);
polygon= mxCalloc(nsamp+1,sizeof(Point));
for (i= 0; i < nsamp; i++) {
polygon[i].lat=lat[i];
polygon[i].lon=lon[i];
}
get_malloced_string(prhs[3],&pname);
get_malloced_string(prhs[4],&ptype);
get_malloced_string(prhs[5],&auth);
get_malloced_string(prhs[6],&dir);
get_malloced_string(prhs[7],&dfile);
get_malloced_string(prhs[8],&s_pcode);
pcode= polycode(s_pcode);
/*maybe nsamp -1, check later...*/
writePolygonData(db,polygon,nsamp,pname,1,1,ptype,auth,dir,dfile,pcode);
antelope_mex_clear_register(1);
mxFree(polygon);
mxFree(s_pcode);
mxFree(dfile);
mxFree(dir);
mxFree(auth);
mxFree(ptype);
mxFree(pname);
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
Dbvalue *value;
char errmsg[STRSZ];
char *field_name;
int nfields;
int retcode = 0;
int rc;
long type;
int fieldname_index;
int fieldval_index;
int i;
if( nrhs < 3 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ( nrhs - 1 ) % 2 != 0 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
nfields = ( nrhs - 1 ) / 2;
for( i = 0; i < nfields; i++ )
{
fieldname_index = i * 2 + 1;
if( mxGetClassID( prhs[fieldname_index] ) != mxCHAR_CLASS )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
}
for( i=0; i<nfields; i++ )
{
fieldname_index = i * 2 + 1;
fieldval_index = fieldname_index + 1;
get_malloced_string( prhs[fieldname_index], &field_name );
db = dblookup ( db, 0, 0, field_name, 0 );
antelope_mex_clear_register( 1 );
rc = dbquery ( db, dbFIELD_TYPE, &type );
antelope_mex_clear_register( 1 );
if( rc == dbINVALID )
{
sprintf( errmsg,
"dbputv: dbquery failed for field %s",
field_name );
mxFree( field_name );
mexErrMsgTxt( errmsg );
}
value = mxArray2dbvalue( prhs[fieldval_index], type );
if( value == (Dbvalue *) NULL )
{
sprintf( errmsg,
"dbputv: failed to convert field %s",
field_name );
mxFree( field_name );
mexErrMsgTxt( errmsg );
}
switch (type ) {
case dbDBPTR:
retcode |= dbputv( db, 0, field_name, value->db, NULL );
break;
case dbSTRING:
retcode |= dbputv( db, 0, field_name, value->s, NULL );
break;
case dbBOOLEAN:
case dbYEARDAY:
case dbINTEGER:
retcode |= dbputv( db, 0, field_name, value->i, NULL );
break;
case dbREAL:
case dbTIME:
retcode |= dbputv( db, 0, field_name, value->d, NULL );
break;
default:
retcode = -1;
break;
}
antelope_mex_clear_register( 1 );
mxFree( value );
mxFree( field_name );
}
if( retcode != 0 )
{
mexErrMsgTxt( "dbputv failed" );
}
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
mxArray *array_ptr;
char errmsg[STRSZ];
char *dbstring_code;
int dbcode;
int retcode;
char *string;
Tbl *tbl;
long n;
int i;
if( nrhs != 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_string( prhs[1], &dbstring_code ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
dbcode = xlatname( dbstring_code, Dbxlat, NDbxlat );
switch( dbcode )
{
case dbSCHEMA_DEFAULT:
case dbDATABASE_FILENAME:
case dbIDSERVER:
case dbLOCKS:
case dbSCHEMA_DESCRIPTION:
case dbTIMEDATE_NAME:
case dbDATABASE_DESCRIPTION:
case dbTABLE_DESCRIPTION:
case dbFIELD_DESCRIPTION:
case dbSCHEMA_DETAIL:
case dbDATABASE_DETAIL:
case dbTABLE_DETAIL:
case dbFIELD_DETAIL:
case dbSCHEMA_NAME:
case dbDATABASE_NAME:
case dbTABLE_NAME:
case dbFIELD_NAME:
case dbTABLE_FILENAME:
case dbTABLE_DIRNAME:
case dbFIELD_RANGE:
case dbFIELD_FORMAT:
case dbDBPATH:
case dbFORMAT:
case dbFIELD_UNITS:
case dbFIELD_BASE_TABLE:
case dbUNIQUE_ID_NAME:
if( ( retcode = dbquery(db, dbcode, &string) ) >= 0 )
{
plhs[0] = mxCreateString( string );
}
antelope_mex_clear_register( 1 );
break;
case dbDATABASE_COUNT:
case dbTABLE_COUNT:
case dbFIELD_COUNT:
case dbRECORD_COUNT:
case dbTABLE_SIZE:
case dbFIELD_SIZE:
case dbFIELD_INDEX:
case dbVIEW_TABLE_COUNT:
case dbRECORD_SIZE:
case dbTABLE_IS_WRITEABLE:
case dbTABLE_IS_VIEW:
case dbDATABASE_IS_WRITABLE:
case dbTABLE_PRESENT:
case dbTABLE_IS_TRANSIENT:
if( ( retcode = dbquery(db, dbcode, &n) ) >= 0 )
{
antelope_mex_clear_register( 1 );
plhs[0] = CreateDouble( (double) n );
if( plhs[0] == NULL )
{
mxFree( dbstring_code );
mexErrMsgTxt(
"dbquery: failed to create return value" );
}
}
else
{
antelope_mex_clear_register( 1 );
}
break;
case dbFIELD_TYPE:
if( ( retcode = dbquery(db, dbcode, &n) ) >= 0 )
{
antelope_mex_clear_register( 1 );
plhs[0] = mxCreateString( xlatnum( n, Dbxlat, NDbxlat ) );
}
else
{
antelope_mex_clear_register( 1 );
}
break;
case dbLINK_FIELDS:
case dbSCHEMA_FIELDS:
case dbSCHEMA_TABLES:
case dbFIELD_TABLES:
case dbVIEW_TABLES:
case dbTABLE_FIELDS:
case dbPRIMARY_KEY:
case dbALTERNATE_KEY:
case dbFOREIGN_KEYS:
if( ( retcode = dbquery(db, dbcode, &tbl) ) >= 0 )
{
antelope_mex_clear_register( 1 );
plhs[0] = stringtbl2cellstr( tbl );
}
else
{
antelope_mex_clear_register( 1 );
}
break;
default:
sprintf( errmsg, "dbquery: bad code '%s'", dbstring_code );
mxFree( dbstring_code );
mexErrMsgTxt( errmsg );
break ;
}
mxFree( dbstring_code );
}
int pfput_mxArray( Pf *pf, char *name, const mxArray *array )
{
Pf *sub_pf;
double number;
char *string;
mxArray *in[2], *out[1];
char warning[STRSZ];
char *fieldname;
mxArray *mxfield;
mxArray *mxcell;
int M,N;
int rc;
int i;
if( mxIsClass( array, "dbpf" ) )
{
if( ! get_pf( array, &sub_pf ) )
{
return PFINVALID;
}
if( sub_pf->type == PFFILE)
{
/* Don't embed a PFFILE in something else */
sub_pf->type = PFARR;
}
switch (pf->type) {
case PFFILE:
case PFARR:
setarr ( pf->value.arr, name, sub_pf ) ;
break ;
case PFTBL:
settbl ( pf->value.tbl, (int) name, sub_pf ) ;
break ;
default :
return PFINVALID;
}
antelope_mex_clear_register( 1 );
}
else if( mxIsDouble( array ) )
{
if( ! get_scalar( array, &number ) )
{
return PFINVALID;
}
in[0] = (mxArray *) array; /* Input scalar */
mexCallMATLAB( 1, out, 1, in, "floor" );
in[1] = out[0]; /* floor( Input scalar ) */
mexCallMATLAB( 1, out, 2, in, "eq" );
mxDestroyArray( in[1] );
if( mxIsLogicalScalarTrue( out[0] ) )
{
pfput_int( pf, name, (int) number );
}
else
{
pfput_double( pf, name, number );
}
antelope_mex_clear_register( 1 );
mxDestroyArray( out[0] );
}
else if( mxIsChar( array ) )
{
if( ! mtlb_get_string( array, &string ) )
{
sprintf( warning,
"failed to extract string for parameter %s\n",
name );
mexWarnMsgTxt( warning );
return PFINVALID;
}
pfput_string( pf, name, string );
antelope_mex_clear_register( 1 );
mxFree( string );
}
else if( mxIsStruct( array ) )
{
if( mxGetNumberOfDimensions( array ) > 2 )
{
sprintf( warning,
"structure has too many dimensions for parameter %s\n",
name );
mexWarnMsgTxt( warning );
return PFINVALID;
}
else if( mxGetM( array ) != 1 || mxGetN( array ) != 1 )
{
sprintf( warning,
"structure has too many elements for parameter %s\n",
name );
mexWarnMsgTxt( warning );
return PFINVALID;
}
N = mxGetNumberOfFields( array );
sub_pf = pfnew( PFARR );
for( i = 0; i < N; i++ )
{
fieldname = (char *) mxGetFieldNameByNumber( array, i );
mxfield = mxGetFieldByNumber( array, 0, i );
rc = pfput_mxArray( sub_pf, fieldname, mxfield );
if( rc == PFINVALID )
{
pffree( sub_pf );
return PFINVALID;
}
}
switch (pf->type) {
case PFFILE:
case PFARR:
setarr ( pf->value.arr, name, sub_pf ) ;
break ;
case PFTBL:
settbl ( pf->value.tbl, (int) name, sub_pf ) ;
break ;
default :
pffree( sub_pf );
return PFINVALID;
}
antelope_mex_clear_register( 1 );
}
else if( mxIsCell( array ) )
{
if( mxGetNumberOfDimensions( array ) > 2 )
{
sprintf( warning,
"cell array has too many dimensions for parameter %s\n",
name );
mexWarnMsgTxt( warning );
return PFINVALID;
}
M = mxGetM( array );
N = mxGetN( array );
sub_pf = pfnew( PFTBL );
for( i = 0; i < M * N; i++ )
{
mxcell = mxGetCell( array, i );
rc = pfput_mxArray( sub_pf, (char *) i, mxcell );
if( rc == PFINVALID )
{
pffree( sub_pf );
return PFINVALID;
}
}
switch (pf->type) {
case PFFILE:
case PFARR:
setarr ( pf->value.arr, name, sub_pf ) ;
break ;
case PFTBL:
settbl ( pf->value.tbl, (int) name, sub_pf ) ;
break ;
default :
pffree( sub_pf );
return PFINVALID;
}
antelope_mex_clear_register( 1 );
}
else
{
return PFINVALID;
}
return 0;
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr db;
char *result = NULL;
char *dbscratch_string;
int use_dbscratch = 0;
long n;
int rc;
double *doublep;
int *intp;
if( nrhs < 1 || nrhs > 2 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( nrhs == 2 )
{
if( ! mtlb_get_string( prhs[1], &dbscratch_string ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! STREQ( dbscratch_string, "dbSCRATCH" ) )
{
mxFree( dbscratch_string );
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else
{
mxFree( dbscratch_string );
use_dbscratch = 1;
}
}
if( use_dbscratch )
{
if( dbget( db, NULL ) < 0 )
{
antelope_mex_clear_register( 1 );
mexErrMsgTxt( "dbget into scratch record failed" );
}
}
else
{
rc = dbquery(db, dbSIZE, &n);
antelope_mex_clear_register( 1 );
if( rc == dbINVALID )
{
mexErrMsgTxt( "dbget: dbquery failed" );
}
result = (char *) mxCalloc( n+3, sizeof( char ) );
if( dbget( db, result ) < 0 )
{
antelope_mex_clear_register( 1 );
mxFree( result );
mexErrMsgTxt( "dbget failed\n" );
}
else
{
if ( db.field != dbALL )
{
copystrip( result, result, n );
}
plhs[0] = mxCreateString( result );
mxFree( result );
}
}
antelope_mex_clear_register( 1 );
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
Dbptr tr;
Dbptr db;
char *datatype;
char *wfname;
int rc;
int flags = 0;
char *flag_string;
if( nrhs < 4 || nrhs > 5 )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[0], &tr ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! get_dbptr( prhs[1], &db ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_string( prhs[2], &datatype ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
else if( ! mtlb_get_string( prhs[3], &wfname ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( nrhs == 5 )
{
if( ! mtlb_get_string( prhs[4], &flag_string ) )
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
if( STREQ( flag_string, "overwrite" ) )
{
flags |= trOVERWRITE;
}
else if( STREQ( flag_string, "append" ) )
{
flags |= trAPPEND;
}
else
{
antelope_mexUsageMsgTxt ( USAGE );
return;
}
}
rc = trsave_wf( tr, db, datatype, wfname, flags );
antelope_mex_clear_register( 1 );
mxFree( datatype );
mxFree( wfname );
if( rc & TR_CLIPPED || rc & TR_TRUNCATED )
{
mexWarnMsgTxt(
"trsave_wf: clipping occurred during conversion\n" );
}
if( rc < 0 ) mexErrMsgTxt( "trsave_wf failed\n" );
}
