struct GridIDLPrm *IDLMakeGridPrm(IDL_VPTR *vptr) {
void *s=NULL;
static IDL_STRUCT_TAG_DEF ttime[]={
{"YR",0,(void *) IDL_TYP_INT},
{"MO",0,(void *) IDL_TYP_INT},
{"DY",0,(void *) IDL_TYP_INT},
{"HR",0,(void *) IDL_TYP_INT},
{"MT",0,(void *) IDL_TYP_INT},
{"SC",0,(void *) IDL_TYP_DOUBLE},
0};
static IDL_STRUCT_TAG_DEF gridprm[]={
{"STME",0,NULL}, /* 0 */
{"ETME",0,NULL}, /* 1 */
{"STNUM",0,(void *) IDL_TYP_LONG}, /* 2 */
{"VCNUM",0,(void *) IDL_TYP_LONG}, /* 3 */
{"XTD",0,(void *) IDL_TYP_INT}, /* 4 */
0};
static IDL_MEMINT ilDims[IDL_MAX_ARRAY_DIM];
gridprm[0].type=IDL_MakeStruct("GRIDTIME",ttime);
gridprm[1].type=IDL_MakeStruct("GRIDTIME",ttime);
s=IDL_MakeStruct("GRIDPRM",gridprm);
ilDims[0]=1;
return (struct GridIDLPrm *) IDL_MakeTempStruct(s,1,ilDims,vptr,TRUE);
}
IDL_StructDefPtr IDLStruct::MakeStructDef(
vector<IDL_STRUCT_TAG_DEF>& tagdefs)
{
IDL_StructDefPtr defptr=NULL;
if (M_DEBUG) cout<<"Making the substruct definition"<<endl;
defptr = (IDL_StructDefPtr) IDL_MakeStruct(NULL, &tagdefs[0]);
return(defptr);
}
int IDL_Load(void) {
IDL_StructDefPtr mg_mysql_field_sdef;
/*
These tables contain information on the functions and procedures
that make up the MySQL DLM. The information contained in these
tables must be identical to that contained in mg_mysql.dlm.
*/
static IDL_SYSFUN_DEF2 function_addr[] = {
{ IDL_mg_mysql_get_client_info, "MG_MYSQL_GET_CLIENT_INFO", 0, 0, 0, 0 },
{ IDL_mg_mysql_get_client_version, "MG_MYSQL_GET_CLIENT_VERSION", 0, 0, 0, 0 },
{ IDL_mg_mysql_get_proto_info, "MG_MYSQL_GET_PROTO_INFO", 1, 1, 0, 0 },
{ IDL_mg_mysql_get_host_info, "MG_MYSQL_GET_HOST_INFO", 1, 1, 0, 0 },
{ IDL_mg_mysql_get_server_info, "MG_MYSQL_GET_SERVER_INFO", 1, 1, 0, 0 },
{ IDL_mg_mysql_get_server_version, "MG_MYSQL_GET_SERVER_VERSION", 1, 1, 0, 0 },
{ IDL_mg_mysql_info, "MG_MYSQL_INFO", 1, 1, 0, 0 },
{ IDL_mg_mysql_init, "MG_MYSQL_INIT", 0, 0, 0, 0 },
{ IDL_mg_mysql_options, "MG_MYSQL_OPTIONS", 3, 3, 0, 0 },
{ IDL_mg_mysql_list_tables, "MG_MYSQL_LIST_TABLES", 1, 2, 0, 0 },
{ IDL_mg_mysql_list_dbs, "MG_MYSQL_LIST_DBS", 1, 2, 0, 0 },
{ IDL_mg_mysql_real_connect, "MG_MYSQL_REAL_CONNECT", 8, 8, 0, 0 },
{ IDL_mg_mysql_select_db, "MG_MYSQL_SELECT_DB", 2, 2, 0, 0 },
{ IDL_mg_mysql_query, "MG_MYSQL_QUERY", 2, 2, 0, 0 },
{ IDL_mg_mysql_error, "MG_MYSQL_ERROR", 1, 1, 0, 0 },
{ IDL_mg_mysql_errno, "MG_MYSQL_ERRNO", 1, 1, 0, 0 },
{ IDL_mg_mysql_store_result, "MG_MYSQL_STORE_RESULT", 1, 1, 0, 0 },
{ IDL_mg_mysql_num_fields, "MG_MYSQL_NUM_FIELDS", 1, 1, 0, 0 },
{ IDL_mg_mysql_num_rows, "MG_MYSQL_NUM_ROWS", 1, 1, 0, 0 },
{ IDL_mg_mysql_fetch_row, "MG_MYSQL_FETCH_ROW", 1, 1, 0, 0 },
{ IDL_mg_mysql_field_count, "MG_MYSQL_FIELD_COUNT", 1, 1, 0, 0 },
{ IDL_mg_mysql_get_field, "MG_MYSQL_GET_FIELD", 2, 2, 0, 0 },
{ IDL_mg_mysql_get_blobfield, "MG_MYSQL_GET_BLOBFIELD", 3, 3, 0, 0 },
{ IDL_mg_mysql_insert_id, "MG_MYSQL_INSERT_ID", 1, 1, 0, 0 },
{ IDL_mg_mysql_fetch_field, "MG_MYSQL_FETCH_FIELD", 1, 1, 0, 0 },
{ IDL_mg_mysql_fetch_lengths, "MG_MYSQL_FETCH_LENGTHS", 1, 1, 0, 0 },
{ IDL_mg_mysql_next_result, "MG_MYSQL_NEXT_RESULT", 1, 1, 0, 0 },
{ IDL_mg_mysql_real_escape_string, "MG_MYSQL_REAL_ESCAPE_STRING", 4, 4, 0, 0 },
{ IDL_mg_mysql_real_query, "MG_MYSQL_REAL_QUERY", 3, 3, 0, 0 },
};
static IDL_SYSFUN_DEF2 procedure_addr[] = {
{ (IDL_SYSRTN_GENERIC) IDL_mg_mysql_close, "MG_MYSQL_CLOSE", 1, 1, 0, 0 },
{ (IDL_SYSRTN_GENERIC) IDL_mg_mysql_free_result, "MG_MYSQL_FREE_RESULT", 1, 1, 0, 0 },
};
mg_mysql_field_sdef = IDL_MakeStruct("MG_MYSQL_FIELD", mg_mysql_field);
/*
Register our routines. The routines must be specified exactly the same
as in mg_mysql.dlm.
*/
return IDL_SysRtnAdd(procedure_addr, FALSE, IDL_CARRAY_ELTS(procedure_addr))
&& IDL_SysRtnAdd(function_addr, TRUE, IDL_CARRAY_ELTS(function_addr));
}
idl_tag_info *pgsql_get_idl_tag_info(IDL_STRUCT_TAG_DEF *tagdefs)
{
idl_tag_info *ti;
int32 i, tag;
char *tagName;
ti = (idl_tag_info *) calloc(1, sizeof(idl_tag_info));
ti->sdef = (IDL_StructDefPtr) IDL_MakeStruct(0, tagdefs);
/* get offsets and descriptions */
ti->ntags = IDL_StructNumTags(ti->sdef);
ti->tagOffsets = calloc(ti->ntags, sizeof(IDL_MEMINT));
ti->tagDesc = calloc(ti->ntags, sizeof(IDL_VPTR));
ti->tagNelts = calloc(ti->ntags, sizeof(int32));
i=0;
for (tag=0; tag< ti->ntags; tag++)
{
tagName =
IDL_StructTagNameByIndex(ti->sdef, tag,
IDL_MSG_INFO, NULL);
ti->tagOffsets[tag] =
IDL_StructTagInfoByIndex(ti->sdef,
tag,
IDL_MSG_LONGJMP,
&(ti->tagDesc[tag]) );
if (VERBOSE)
printf(" Tag %d = \"%s\" ", tag, tagName);
/* Is this an array? */
if ( (ti->tagDesc[tag]->flags & IDL_V_ARR) != 0)
{
ti->tagNelts[tag] = ti->tagDesc[tag]->value.arr->n_elts;
if (VERBOSE)
printf(" ARRAY[%d] ", ti->tagNelts[tag]);
}
else
{
ti->tagNelts[tag] = 1;
if (VERBOSE)
printf(" SCALAR ");
}
if (VERBOSE)
printf("\n");
}
return(ti);
}
//
// idlpgr_GetCameraInfo
//
// Returns a subset of the fc2CameraInfo structure
//
IDL_VPTR IDL_CDECL idlpgr_GetCameraInfo(int argc, IDL_VPTR argv[])
{
fc2Error error;
fc2Context context;
fc2CameraInfo camerainfo;
IDL_StructDefPtr sdef;
char *pd;
IDL_MEMINT one = 1;
IDL_VPTR idl_camerainfo;
context = (fc2Context) IDL_ULong64Scalar(argv[0]);
error = fc2GetCameraInfo(context, &camerainfo);
if (error)
IDL_MessageFromBlock(msgs, M_IDLPGR_ERRORCODE, IDL_MSG_LONGJMP,
"Could not read camera info",
error);
static IDL_STRUCT_TAG_DEF tags[] = {
{ "SERIALNUMBER", 0, (void *) IDL_TYP_ULONG },
{ "ISCOLORCAMERA", 0, (void *) IDL_TYP_LONG },
{ "MODELNAME", 0, (void *) IDL_TYP_STRING },
{ "VENDORNAME", 0, (void *) IDL_TYP_STRING },
{ "SENSORINFO", 0, (void *) IDL_TYP_STRING },
{ "SENSORRESOLUTION", 0, (void *) IDL_TYP_STRING },
{ "DRIVERNAME", 0, (void *) IDL_TYP_STRING },
{ "FIRMWAREVERSION", 0, (void *) IDL_TYP_STRING },
{ 0 }
};
sdef = IDL_MakeStruct("fc2CameraInfo", tags);
pd = IDL_MakeTempStruct(sdef, 1, &one, &idl_camerainfo, TRUE);
*(IDL_ULONG *) pd = camerainfo.serialNumber;
pd += sizeof(IDL_ULONG);
*(IDL_LONG *) pd = camerainfo.isColorCamera;
pd += sizeof(IDL_LONG);
IDL_StrStore((IDL_STRING *) pd, camerainfo.modelName);
pd += sizeof(IDL_STRING);
IDL_StrStore((IDL_STRING *) pd, camerainfo.vendorName);
pd += sizeof(IDL_STRING);
IDL_StrStore((IDL_STRING *) pd, camerainfo.sensorInfo);
pd += sizeof(IDL_STRING);
IDL_StrStore((IDL_STRING *) pd, camerainfo.sensorResolution);
pd += sizeof(IDL_STRING);
IDL_StrStore((IDL_STRING *) pd, camerainfo.driverName);
pd += sizeof(IDL_STRING);
IDL_StrStore((IDL_STRING *) pd, camerainfo.firmwareVersion);
return idl_camerainfo;
}
struct GridIDLGVec *IDLMakeGridGVec(int nvec,IDL_VPTR *vptr) {
void *s=NULL;
static IDL_STRUCT_TAG_DEF value[]={
{"MEDIAN",0,(void *) IDL_TYP_FLOAT},
{"SD",0,(void *) IDL_TYP_FLOAT},
0};
static IDL_STRUCT_TAG_DEF gridgvec[]={
{"MLAT",0, (void *) IDL_TYP_FLOAT}, /* 0 */
{"MLON",0, (void *) IDL_TYP_FLOAT}, /* 1 */
{"AZM",0,(void *) IDL_TYP_FLOAT}, /* 2 */
{"VEL",0,NULL}, /* 3 */
{"PWR",0,NULL}, /* 4 */
{"WDT",0,NULL}, /* 5 */
{"ST_ID",0,(void *) IDL_TYP_INT}, /* 6 */
{"CHN",0,(void *) IDL_TYP_INT}, /* 7 */
{"INDEX",0,(void *) IDL_TYP_LONG}, /* 8 */
0};
static IDL_MEMINT ilDims[IDL_MAX_ARRAY_DIM];
gridgvec[3].type=IDL_MakeStruct("GRIDVALUE",value);
gridgvec[4].type=IDL_MakeStruct("GRIDVALUE",value);
gridgvec[5].type=IDL_MakeStruct("GRIDVALUE",value);
s=IDL_MakeStruct("GRIDGVEC",gridgvec);
ilDims[0]=nvec;
return (struct GridIDLGVec *) IDL_MakeTempStruct(s,1,ilDims,vptr,TRUE);
}
struct GridIDLInx *IDLMakeGridInx(int num,IDL_VPTR *vptr) {
void *s=NULL;
static IDL_MEMINT idim[1]={0};
static IDL_STRUCT_TAG_DEF grdinx[]={
{"TIME",0,(void *) IDL_TYP_DOUBLE},
{"OFFSET",0,(void *) IDL_TYP_LONG},
0};
s=IDL_MakeStruct("GRDINX",grdinx);
idim[0]=num;
return (struct GridIDLInx *) IDL_MakeTempStruct(s,1,idim,vptr,TRUE);
}
struct OldCnvMapIDLInx *IDLMakeOldCnvMapInx(int num,IDL_VPTR *vptr) {
void *s=NULL;
static IDL_MEMINT idim[1]={0};
static IDL_STRUCT_TAG_DEF mapinx[]={
{"ST_TIME",0,(void *) IDL_TYP_DOUBLE},
{"ED_TIME",0,(void *) IDL_TYP_DOUBLE},
{"OFFSET",0,(void *) IDL_TYP_LONG},
0};
s=IDL_MakeStruct("OLDCNVMAPINX",mapinx);
idim[0]=num;
return (struct OldCnvMapIDLInx *) IDL_MakeTempStruct(s,1,idim,vptr,TRUE);
}
//
// idlpgr_GetPropertyInfo
//
// Get information about property
//
// Reference: FlyCapture2Defs_C.h
//
IDL_VPTR IDL_CDECL idlpgr_GetPropertyInfo(int argc, IDL_VPTR argv[])
{
fc2Error error;
fc2Context context;
fc2PropertyInfo info;
static IDL_MEMINT one = 1;
static IDL_MEMINT r[] = {1, 8};
static IDL_MEMINT s[] = {1, MAX_STRING_LENGTH};
IDL_VPTR idl_info;
IDL_StructDefPtr sdef;
char *pd;
context = (fc2Context) IDL_ULong64Scalar(argv[0]);
info.type = (fc2PropertyType) IDL_LongScalar(argv[1]);
error = fc2GetPropertyInfo(context, &info);
if (error)
IDL_MessageFromBlock(msgs, M_IDLPGR_ERRORCODE, IDL_MSG_LONGJMP,
"Could not get requested property information",
error);
static IDL_STRUCT_TAG_DEF tags[] = {
{ "TYPE", 0, (void *) IDL_TYP_LONG },
{ "PRESENT", 0, (void *) IDL_TYP_LONG },
{ "AUTOSUPPORTED", 0, (void *) IDL_TYP_LONG },
{ "MANUALSUPPORTED", 0, (void *) IDL_TYP_LONG },
{ "ONOFFSUPPORTED", 0, (void *) IDL_TYP_LONG },
{ "ONEPUSHSUPPORTED", 0, (void *) IDL_TYP_LONG },
{ "ABSVALSUPPORTED", 0, (void *) IDL_TYP_LONG },
{ "READOUTSUPPORTED", 0, (void *) IDL_TYP_LONG },
{ "MIN", 0, (void *) IDL_TYP_ULONG },
{ "MAX", 0, (void *) IDL_TYP_ULONG },
{ "ABSMIN", 0, (void *) IDL_TYP_FLOAT },
{ "ABSMAX", 0, (void *) IDL_TYP_FLOAT },
{ "PUNITS", s, (void *) IDL_TYP_BYTE },
{ "PUNITABBR", s, (void *) IDL_TYP_BYTE },
{ "RESERVED", r, (void *) IDL_TYP_ULONG },
{ 0 }
};
sdef = IDL_MakeStruct("fc2PropertyInfo", tags);
pd = IDL_MakeTempStruct(sdef, 1, &one, &idl_info, TRUE);
memcpy(pd, (char *) &info, sizeof(fc2PropertyInfo));
return idl_info;
}
//
// idlpgr_GetProperty
//
// Read property values from camera
//
// Reference: FlyCapture2Defs_C.h
//
IDL_VPTR IDL_CDECL idlpgr_GetProperty(int argc, IDL_VPTR argv[])
{
fc2Error error;
fc2Context context;
fc2Property property;
static IDL_MEMINT r[] = {1, 8};
static IDL_MEMINT one = 1;
IDL_VPTR idl_property;
IDL_StructDefPtr sdef;
char *pd;
context = (fc2Context) IDL_ULong64Scalar(argv[0]);
property.type = (fc2PropertyType) IDL_LongScalar(argv[1]);
error = fc2GetProperty(context, &property);
if (error)
IDL_MessageFromBlock(msgs, M_IDLPGR_ERRORCODE, IDL_MSG_LONGJMP,
"Could not get requested property",
error);
static IDL_STRUCT_TAG_DEF tags[] = {
{ "TYPE", 0, (void *) IDL_TYP_LONG },
{ "PRESENT", 0, (void *) IDL_TYP_LONG },
{ "ABSCONTROL", 0, (void *) IDL_TYP_LONG },
{ "ONEPUSH", 0, (void *) IDL_TYP_LONG },
{ "ONOFF", 0, (void *) IDL_TYP_LONG },
{ "AUTOMANUALMODE", 0, (void *) IDL_TYP_LONG },
{ "VALUEA", 0, (void *) IDL_TYP_ULONG },
{ "VALUEB", 0, (void *) IDL_TYP_ULONG },
{ "ABSVALUE", 0, (void *) IDL_TYP_FLOAT },
{ "RESERVED", r, (void *) IDL_TYP_ULONG },
{ 0 }
};
sdef = IDL_MakeStruct("fc2Property", tags);
pd = IDL_MakeTempStruct(sdef, 1, &one, &idl_property, TRUE);
memcpy(pd, (char *) &property, sizeof(fc2Property));
return idl_property;
}
struct GridIDLStVec *IDLMakeGridStVec(int nvec,IDL_VPTR *vptr) {
void *s=NULL;
static IDL_STRUCT_TAG_DEF noise[]={
{"MEAN",0,(void *) IDL_TYP_FLOAT},
{"SD",0,(void *) IDL_TYP_FLOAT},
0};
static IDL_STRUCT_TAG_DEF limit[]={
{"MIN",0,(void *) IDL_TYP_FLOAT},
{"MAX",0,(void *) IDL_TYP_FLOAT},
0};
static IDL_STRUCT_TAG_DEF gridstvec[]={
{"ST_ID",0, (void *) IDL_TYP_INT}, /* 0 */
{"CHN",0, (void *) IDL_TYP_INT}, /* 1 */
{"NPNT",0, (void *) IDL_TYP_INT}, /* 2 */
{"FREQ",0, (void *) IDL_TYP_FLOAT}, /* 3 */
{"MAJOR_REVISION",0, (void *) IDL_TYP_INT}, /* 4 */
{"MINOR_REVISION",0, (void *) IDL_TYP_INT}, /* 5 */
{"PROG_ID",0, (void *) IDL_TYP_INT}, /* 6 */
{"GSCT",0, (void *) IDL_TYP_INT}, /* 7 */
{"NOISE",0,NULL}, /* 8 */
{"VEL",0,NULL}, /* 9 */
{"PWR",0,NULL}, /* 10 */
{"WDT",0,NULL}, /* 11 */
{"VERR",0,NULL}, /* 12 */
0};
static IDL_MEMINT ilDims[IDL_MAX_ARRAY_DIM];
gridstvec[8].type=IDL_MakeStruct("GRIDNOISE",noise);
gridstvec[9].type=IDL_MakeStruct("GRIDLIMIT",limit);
gridstvec[10].type=IDL_MakeStruct("GRIDLIMIT",limit);
gridstvec[11].type=IDL_MakeStruct("GRIDLIMIT",limit);
gridstvec[12].type=IDL_MakeStruct("GRIDLIMIT",limit);
s=IDL_MakeStruct("GRIDSVEC",gridstvec);
ilDims[0]=nvec;
return (struct GridIDLStVec *) IDL_MakeTempStruct(s,1,ilDims,vptr,TRUE);
}
IDL_VPTR rdObjmask(int argc, IDL_VPTR *argv, char *argk) {
/* the desired atlas image. */
ATLAS_IMAGE *ai;
/* The fits file */
FITS *fits;
char *atlasFileName; // The input file name
IDL_VPTR idlistVptr; // optional idlist input keyword
IDL_MEMINT* idlist;
IDL_MEMINT nid=0;
int idiscopy=0;
IDL_MEMINT nrows=0; // actual number of rows in file
IDL_MEMINT i=0, j=0;
IDL_VPTR result; // The result and temporary copies
char* resptr;
char* rowptr;
char* elptr;
IDL_LONG elval;
int elsize;
// Structure definition
void* sdef;
// offsets structure
offsetstruct os;
// First make sure IDL_LONG is 4-byte int
elsize=sizeof(IDL_LONG);
if (elsize != 4)
{
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_LONGJMP, "sizeof(IDL_LONG) must be 4");
}
/* Get the keywords */
(void) IDL_KWProcessByOffset(argc, argv, argk, kw_pars,
(IDL_VPTR *) 0, 1, &kw);
/* Check arguments */
if (nParams(argc) < 1)
{
IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO,
"Syntax: struct = rdObjmask(atlasFile, idlist=, status=)");
setStatus(FAILURE);
return(IDL_GettmpInt(-1));
}
/* get file name and open fits file */
atlasFileName = getFileNameVal(argv[0]);
if((fits = open_fits_table(atlasFileName, 1)) == NULL) {
/* Memory is cleaned up in open_fits_table() */
setStatus(FAILURE);
return(IDL_GettmpInt(-1));
}
nrows = fits->naxis2;
// See if idlist was sent, else generate a list of all
if (kw.idlist_there)
{
/* make sure it is a MEMINT. Copy if needed */
idlistVptr = getAsMEMINT(argv[1], &idiscopy);
IDL_VarGetData(idlistVptr, &nid, (char **) &idlist, IDL_TRUE);
}
else
{
idiscopy=1;
nid=nrows;
idlist = (IDL_MEMINT *) calloc(nrows, sizeof(IDL_MEMINT));
for (i=1;i<=nrows;i++)
idlist[i-1] = i;
}
/* structure definition and create output */
sdef = IDL_MakeStruct(0, stags);
resptr = IDL_MakeTempStructVector(sdef, nid, &result, IDL_TRUE);
os = GetOffsets(sdef);
/* Copy in the info */
for (i=0;i<nid;i++)
{
// Point to the appropriate row in output data
rowptr = (char *) result->value.s.arr->data + i*( result->value.arr->elt_len );
// Copy id. Do it here since if the object has no atlas image
// it wouldn't be copied
elval = (IDL_LONG) idlist[i];
elptr = rowptr + os.id;
memcpy(elptr, &elval, elsize);
// Read the atlas image
ai = read_atlas_image(fits, (int) idlist[i]);
// In what follows, copy -1 if the ai is invalid
if (ai != NULL)
{
// Copy run
elval = (IDL_LONG) ai->run;
elptr = rowptr + os.run;
memcpy(elptr, &elval, elsize);
// Copy rerun
elval = (IDL_LONG) ai->rerun;
elptr = rowptr + os.rerun;
memcpy(elptr, &elval, elsize);
// Copy camcol
elval = (IDL_LONG) ai->camCol;
elptr = rowptr + os.camcol;
memcpy(elptr, &elval, elsize);
// Copy field
elval = (IDL_LONG) ai->field;
elptr = rowptr + os.field;
memcpy(elptr, &elval, elsize);
// Copy id
//elval = (IDL_LONG) ai->id;
//elptr = rowptr + os.id;
//memcpy(elptr, &elval, elsize);
// Copy parent
elval = (IDL_LONG) ai->parent;
elptr = rowptr + os.parent;
memcpy(elptr, &elval, elsize);
// copy row0
elptr = rowptr + os.row0;
for (j=0;j<5;j++)
{
if (ai->id > 0)
elval = (IDL_LONG) (ai->master_mask->rmin + ai->drow[j]);
else
elval=-1;
memcpy(elptr, &elval, elsize);
elptr+=elsize;
}
// copy col0
elptr = rowptr + os.col0;
for (j=0;j<5;j++)
{
if (ai->id > 0)
elval = (IDL_LONG) (ai->master_mask->cmin + ai->dcol[j]);
else
elval=-1;
memcpy(elptr, &elval, elsize);
elptr+=elsize;
}
// copy rowmax
elptr = rowptr + os.rowmax;
for (j=0;j<5;j++)
{
if (ai->id > 0)
elval = (IDL_LONG) (ai->master_mask->rmax + ai->drow[j]);
else
elval=-1;
memcpy(elptr, &elval, elsize);
elptr+=elsize;
}
// copy colmax
elptr = rowptr + os.colmax;
for (j=0;j<5;j++)
{
if (ai->id > 0)
elval = (IDL_LONG) (ai->master_mask->cmax + ai->dcol[j]);
else
elval=-1;
memcpy(elptr, &elval, elsize);
elptr+=elsize;
}
// copy drow
elptr = rowptr + os.drow;
for (j=0;j<5;j++)
{
if (ai->id > 0)
elval = (IDL_LONG) (ai->drow[j]);
else
elval = -1;
memcpy(elptr, &elval, elsize);
elptr+=elsize;
}
// copy dcol
elptr = rowptr + os.dcol;
for (j=0;j<5;j++)
{
if (ai->id > 0)
elval = (IDL_LONG) (ai->dcol[j]);
else
elval = -1;
memcpy(elptr, &elval, elsize);
elptr+=elsize;
}
phAtlasImageDel(ai,1);
}
}
/* clean up */
phFitsDel(fits);
if (kw.idlist_there & idiscopy)
IDL_Deltmp(idlistVptr);
else
free(idlist);
/* Clean up the keyword info */
IDL_KW_FREE;
setStatus(SUCCESS);
//return(IDL_GettmpInt(-1));
return(result);
}
static IDL_VPTR IDLOldRawOpen(int argc,IDL_VPTR *argv) {
IDL_VPTR vrawfp;
struct OldRawIDLFp *irawfp;
struct OldRawFp *rawfp;
void *s;
int st;
static IDL_MEMINT hdim[]={1,80};
static IDL_MEMINT ddim[]={1,32};
static IDL_MEMINT edim[]={1,256};
static IDL_STRUCT_TAG_DEF trawfp[]={
{"RAWUNIT",0,(void *) IDL_TYP_LONG},
{"INXUNIT",0,(void *) IDL_TYP_LONG},
{"RAW_RECL",0,(void *) IDL_TYP_LONG},
{"INX_RECL",0,(void *) IDL_TYP_LONG},
{"BLEN",0,(void *) IDL_TYP_LONG},
{"INX_SREC",0,(void *) IDL_TYP_LONG},
{"INX_EREC",0,(void *) IDL_TYP_LONG},
{"CTIME",0,(void *) IDL_TYP_DOUBLE},
{"STIME",0,(void *) IDL_TYP_DOUBLE},
{"ETIME",0,(void *) IDL_TYP_DOUBLE},
{"TIME",0,(void *) IDL_TYP_LONG},
{"HEADER",hdim,(void *) IDL_TYP_BYTE},
{"DATE",ddim,(void *) IDL_TYP_BYTE},
{"EXTRA",edim,(void *) IDL_TYP_BYTE},
{"MAJOR_REV",0,(void *) IDL_TYP_BYTE},
{"MINOR_REV",0,(void *) IDL_TYP_BYTE},
{"RAWREAD",0,(void *) IDL_TYP_LONG},
{"BNUM",0,(void *) IDL_TYP_LONG},
0};
static IDL_MEMINT ilDims[IDL_MAX_ARRAY_DIM];
IDL_VARIABLE unit;
IDL_VPTR fargv[2];
IDL_FILE_STAT stat;
int ffd=-1,ifd=-1;
IDL_ENSURE_STRING(argv[0]);
if (argc>1) IDL_ENSURE_STRING(argv[1]);
s=IDL_MakeStruct("RAWFP",trawfp);
ilDims[0]=1;
irawfp=(struct OldRawIDLFp *) IDL_MakeTempStruct(s,1,ilDims,&vrawfp,TRUE);
unit.type=IDL_TYP_LONG;
unit.flags=0;
fargv[0]=&unit;
fargv[1]=argv[0];
IDL_FileGetUnit(1,fargv);
IDL_FileOpen(2,fargv,NULL,IDL_OPEN_R,IDL_F_STDIO,1,0);
irawfp->rawunit=IDL_LongScalar(&unit);
irawfp->inxunit=-1;
st=IDL_FileEnsureStatus(IDL_MSG_RET,irawfp->rawunit,IDL_EFS_USER);
if (st==FALSE) {
st=0;
IDL_Deltmp(vrawfp);
return (IDL_GettmpLong(st));
}
if (argc>1) {
fargv[1]=argv[1];
IDL_FileGetUnit(1,fargv);
IDL_FileOpen(2,fargv,NULL,IDL_OPEN_R,IDL_F_STDIO,1,0);
irawfp->inxunit=IDL_LongScalar(&unit);
st=IDL_FileEnsureStatus(IDL_MSG_RET,irawfp->rawunit,IDL_EFS_USER);
if (st==FALSE) { /* free unit for index but continue */
IDL_FileFreeUnit(1,argv);
irawfp->inxunit=-1;
}
}
IDL_FileStat(irawfp->rawunit,&stat);
ffd=fileno(stat.fptr);
if (irawfp->inxunit !=-1) {
IDL_FileStat(irawfp->inxunit,&stat);
ifd=fileno(stat.fptr);
}
rawfp=OldRawOpenFd(ffd,ifd);
OldRawRawFpToIDL(rawfp,irawfp);
free(rawfp);
return vrawfp;
}
// MYSQL_FIELD * STDCALL mysql_fetch_fields(MYSQL_RES *res);
static IDL_VPTR IDL_mg_mysql_fetch_field(int argc, IDL_VPTR *argv) {
static IDL_MEMINT nfields = 1;
MYSQL_FIELD *field = mysql_fetch_field((MYSQL_RES *)argv[0]->value.ptrint);
typedef struct field {
IDL_STRING name;
IDL_STRING org_name;
IDL_STRING table;
IDL_STRING org_table;
IDL_STRING db;
IDL_STRING catalog;
IDL_STRING def;
IDL_ULONG64 length;
IDL_ULONG64 max_length;
IDL_ULONG name_length;
IDL_ULONG org_name_length;
IDL_ULONG table_length;
IDL_ULONG org_table_length;
IDL_ULONG db_length;
IDL_ULONG catalog_length;
IDL_ULONG def_length;
IDL_ULONG flags;
IDL_ULONG decimals;
IDL_ULONG charsetnr;
IDL_ULONG type;
#if MYSQL_VERSION_ID >= 50100
IDL_PTRINT extension;
#endif
} MG_Field;
MG_Field *mg_field_data = (MG_Field *) calloc(nfields, sizeof(MG_Field));
void *idl_field_data;
IDL_StrStore(&mg_field_data->name, field->name);
IDL_StrStore(&mg_field_data->org_name, field->org_name);
IDL_StrStore(&mg_field_data->table, field->table);
IDL_StrStore(&mg_field_data->org_table, field->org_table);
IDL_StrStore(&mg_field_data->db, field->db);
IDL_StrStore(&mg_field_data->catalog, field->catalog);
IDL_StrStore(&mg_field_data->def, field->def);
mg_field_data->length = field->length;
mg_field_data->max_length = field->max_length;
mg_field_data->name_length = field->name_length;
mg_field_data->org_name_length = field->org_name_length;
mg_field_data->table_length = field->table_length;
mg_field_data->org_table_length = field->org_table_length;
mg_field_data->db_length = field->db_length;
mg_field_data->catalog_length = field->catalog_length;
mg_field_data->def_length = field->def_length;
mg_field_data->flags = field->flags;
mg_field_data->decimals = field->decimals;
mg_field_data->charsetnr = field->charsetnr;
mg_field_data->type = field->type;
#if MYSQL_VERSION_ID >= 50100
mg_field_data->extension = (IDL_PTRINT)field->extension;
#endif
idl_field_data = IDL_MakeStruct(0, mg_mysql_field);
IDL_VPTR result = IDL_ImportArray(1,
&nfields,
IDL_TYP_STRUCT,
(UCHAR *) mg_field_data,
0,
idl_field_data);
return result;
}
