예제 #1
0
파일: grdidl.c 프로젝트: asreimer/VTRST3.5
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);
  
}
예제 #2
0
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);
}
예제 #3
0
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));
}
예제 #4
0
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);

}
예제 #5
0
파일: idlpgr.c 프로젝트: davidgrier/idlpgr
//
// 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;
}
예제 #6
0
파일: grdidl.c 프로젝트: asreimer/VTRST3.5
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);

}
예제 #7
0
파일: grdidl.c 프로젝트: asreimer/VTRST3.5
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);
}
예제 #8
0
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);
}
예제 #9
0
파일: idlpgr.c 프로젝트: davidgrier/idlpgr
//
// 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;
}
예제 #10
0
파일: idlpgr.c 프로젝트: davidgrier/idlpgr
//
// 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;
}
예제 #11
0
파일: grdidl.c 프로젝트: asreimer/VTRST3.5
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);

}
예제 #12
0
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);

}
예제 #13
0
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;
}
예제 #14
0
// 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;
}