Пример #1
0
void _Ncl_add_udt(NclFileUDTRecord **rootudtrec,
                  int gid, int uid, NclQuark name,
                  int ncl_class, int type,
                  size_t size, size_t nfields,
                  NclQuark *mem_name, NclBasicDataTypes *mem_type)
{
    NclFileUDTRecord *udtrec = *rootudtrec;
    NclFileUDTNode   *udtnode;
    int n = 0;

  /*
   *fprintf(stderr, "\nEnter _Ncl_add_udt, file: %s, line: %d\n", __FILE__, __LINE__);
   *fprintf(stderr, "\tgid: %d, uid: %d, name: <%s>\n", gid, uid, NrmQuarkToString(name));
   */

    if(NULL == udtrec)
    {
        udtrec = _NclFileUDTAlloc(1);
        assert(udtrec);
        *rootudtrec = udtrec;

        udtrec->gid = gid;
        udtrec->uid = uid;
    }

    if(udtrec->n_udts >= udtrec->max_udts)
    {
        _NclFileUDTRealloc(udtrec);
    }

    udtnode = &(udtrec->udt_node[udtrec->n_udts]);

    udtnode->id = uid;
    udtnode->name = name;
    udtnode->type = type;
    udtnode->size = size;
    udtnode->ncl_class = ncl_class;
    udtnode->max_fields = nfields;
    udtnode->n_fields = nfields;

    udtnode->mem_name = (NclQuark *)NclCalloc(nfields, sizeof(NclQuark));
    assert(udtnode->mem_name);
    udtnode->mem_type = (NclBasicDataTypes *)NclCalloc(nfields, sizeof(NclBasicDataTypes));
    assert(udtnode->mem_type);

    for(n = 0; n < nfields; n++)
    {
        udtnode->mem_name[n] = mem_name[n];
        udtnode->mem_type[n] = mem_type[n];
    }

    udtrec->n_udts ++;
  /*
   *fprintf(stderr, "Leave _Ncl_add_udt, file: %s, line: %d\n\n", __FILE__, __LINE__);
   */
}
Пример #2
0
NclFileAttNode *GetAttInfoFromVarNode(NclFileVarNode *varnode, NclQuark att_name)
{
    NclFileAttNode *attnode;
    NclFileAttNode *tmp = NULL;
    int n;

    if(NULL != varnode->att_rec)
    {
        for(n = 0; n < varnode->att_rec->n_atts; n++)
        {
            attnode = &(varnode->att_rec->att_node[n]);
            if(attnode->name != att_name)
                continue;

            tmp = (NclFileAttNode *)NclCalloc(1, sizeof(NclFileAttNode));
            assert(tmp);

            memcpy(tmp, attnode, sizeof(NclFileAttNode));

            if(attnode->n_elem)
            {
                memcpy(tmp->value, attnode->value,
                    attnode->n_elem * _NclSizeOf(attnode->type));
            }

            return(tmp);
        }
    }

    return(tmp);
}
Пример #3
0
NclQuark *GetVarAttNamesFromGrp(void *therec, NclQuark thevar, int *num_atts)
{
    NclFileGrpNode *grpnode = (NclFileGrpNode *)therec;
    NclFileVarNode *varnode;
    NclQuark *out_list = NULL;
    int n;

    *num_atts = 0;
    varnode = _getVarNodeFromNclFileGrpNode(grpnode, thevar);
    if(NULL != varnode)
    {
        if(varnode->att_rec->n_atts)
        {
            *num_atts = varnode->att_rec->n_atts;
            out_list = (NclQuark *)NclCalloc((*num_atts), sizeof(NclQuark));
            assert(out_list);

            for(n = 0; n < varnode->att_rec->n_atts; n++)
            {
                out_list[n] = varnode->att_rec->att_node[n].name;
            }
        }
    }

    return(out_list);
}
Пример #4
0
void guiNhlRLSetMDFloatArray(int id, char *resname, float *data, int num_dimensions, int *len_dimensions)
{
    int n;
    ng_size_t *dimsizes = (ng_size_t *)NclCalloc(num_dimensions, sizeof(ng_size_t));
    for(n = 0; n < num_dimensions; ++n)
        dimsizes[n] = (ng_size_t)len_dimensions[n];

    NhlRLSetMDFloatArray(id, (NhlString)resname, data, num_dimensions, dimsizes);

    NclFree(dimsizes);
}
Пример #5
0
NclQuark *GetGrpDimNames(void *therec, int *num_dims)
{
    NclFileGrpNode *grpnode = (NclFileGrpNode *) therec;
    NclQuark *out_quarks = NULL;
    NclQuark *tmp_quarks = NULL;
    int i, n, nv;

    *num_dims = 0;
    if(NULL != grpnode->dim_rec)
    {
        if(grpnode->dim_rec->n_dims)
        {
            out_quarks = (NclQuark*)NclCalloc(grpnode->dim_rec->n_dims,
                                           sizeof(NclQuark));
            assert(out_quarks);

            for(i = 0; i < grpnode->dim_rec->n_dims; i++)
            {
                out_quarks[i] = grpnode->dim_rec->dim_node[i].name;
            }

            *num_dims = grpnode->dim_rec->n_dims;
        }
    }

    if(NULL != grpnode->grp_rec)
    {
        if(grpnode->grp_rec->n_grps)
        {
            for(n = 0; n < grpnode->grp_rec->n_grps; n++)
            {
                tmp_quarks = GetGrpDimNames((void *)grpnode->grp_rec->grp_node[n], &nv);

                if(nv)
                {
                    out_quarks = (NclQuark*)realloc(out_quarks,
                                                (*num_dims + nv) * sizeof(NclQuark));
                    assert(out_quarks);

                    for(i = 0; i < nv; i++)
                    {
                        out_quarks[*num_dims + i] = tmp_quarks[i];
                    }
                    NclFree(tmp_quarks);
                }

                *num_dims += nv;
            }
        }
    }
    return(out_quarks);
}
Пример #6
0
NclFileAttNode *GetAttInfoFromGrpNode(NclFileGrpNode *grpnode, NclQuark att_name)
{
    NclFileAttNode *attnode;
    NclFileAttNode *tmp = NULL;
    int n;

    if(NULL != grpnode->att_rec)
    {
        for(n = 0; n < grpnode->att_rec->n_atts; n++)
        {
            attnode = &(grpnode->att_rec->att_node[n]);
            if(attnode->name != att_name)
                continue;

            tmp = (NclFileAttNode *)NclCalloc(1, sizeof(NclFileAttNode));
            assert(tmp);

            memcpy(tmp, attnode, sizeof(NclFileAttNode));

            if(attnode->n_elem)
                memcpy(tmp->value, attnode->value,
                       attnode->n_elem * _NclSizeOf(attnode->type));

            return(tmp);
        }
    }

    if(NULL != grpnode->grp_rec)
    {
        for(n = 0; n < grpnode->grp_rec->n_grps; n++)
        {
            tmp = GetAttInfoFromGrpNode(grpnode->grp_rec->grp_node[n], att_name);
            if(NULL != tmp)
                return tmp;
        }
    }

    return(tmp);
}
Пример #7
0
NclQuark *GetGrpAttNames(void* therec, int *num_atts)
{
    NclFileGrpNode *grpnode = (NclFileGrpNode *)therec;
    NclQuark *out_list = NULL;
    int i;

    *num_atts = 0;

    if(grpnode->att_rec)
    {
        if(grpnode->att_rec->n_atts)
        {
            out_list = (NclQuark*)NclCalloc(grpnode->att_rec->n_atts, sizeof(NclQuark));
            for(i = 0; i < grpnode->att_rec->n_atts; i++)
            {
                out_list[i] = grpnode->att_rec->att_node[i].name;
            }
            *num_atts = grpnode->att_rec->n_atts;
        }
    }
    return(out_list);
}
Пример #8
0
NclFDimRec *GetDimInfo(void* therec, NclQuark dim_name)
{
    NclFileGrpNode *grpnode = (NclFileGrpNode *)therec;
    NclFileDimNode *dimnode;
    NclFDimRec *tmp = NULL;
    int n;

    if(NULL != grpnode->dim_rec)
    {
        for(n = 0; n < grpnode->dim_rec->n_dims; n++)
        {
            dimnode = &(grpnode->dim_rec->dim_node[n]);
            if(dimnode->name != dim_name)
                continue;

            tmp = (NclFDimRec *)NclCalloc(1, sizeof(NclFDimRec));
            assert(tmp);

            tmp->dim_name_quark = dimnode->name;
            tmp->dim_size = dimnode->size;
            tmp->is_unlimited  = dimnode->is_unlimited;

            return tmp;
        }
    }

    if(NULL != grpnode->grp_rec)
    {
        for(n = 0; n < grpnode->grp_rec->n_grps; n++)
        {
            tmp = GetDimInfo(grpnode->grp_rec->grp_node[n], dim_name);
            if(NULL != tmp)
                return tmp;
        }
    }

    return tmp;
}
Пример #9
0
void _NclAddIntrinsics
#if	NhlNeedProto
(void)
#else 
()
#endif
{
	NclArgTemplate *args;

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = NULL;
	args[0].is_dimsizes = 0;
	_NclRegisterProc(_NclIPrint,args,"print",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = NULL;
	args[0].is_dimsizes = 0;
	_NclRegisterProc(_NclIDelete,args,"delete",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 0;
	_NclRegisterProc(_NclIDraw,args,"NhlDraw",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 0;
	_NclRegisterProc(_NclIDraw,args,"draw",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 0;
	_NclRegisterProc(_NclIDestroy,args,"NhlDestroy",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 0;
	_NclRegisterProc(_NclIDestroy,args,"destroy",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 0;
	_NclRegisterProc(_NclIUpdate,args,"NhlUpdateWorkstation",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 0;
	_NclRegisterProc(_NclIUpdate,args,"update",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 0;
	_NclRegisterProc(_NclIFrame,args,"NhlFrame",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 0;
	_NclRegisterProc(_NclIFrame,args,"frame",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 0;
	_NclRegisterProc(_NclIClear,args,"NhlClearWorkstation",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 0;
	_NclRegisterProc(_NclIClear,args,"clear",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].is_dimsizes = 1;
	args[0].dim_sizes[0] = 1;
	args[0].n_dims = 1;
	_NclRegisterProc(_NclIDumpStk,args,"dump",1,PIPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("integer");
	args[0].is_dimsizes = 1;
	args[0].dim_sizes[0] = 1;
	args[0].n_dims = 1;
	_NclRegisterProc(_NclIPSetRL,args,"setrl",1,PIPROC);

	args = NclCalloc(2,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].is_dimsizes = 1;
	args[0].dim_sizes[0] = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("string");
	args[1].is_dimsizes = 1;
	args[1].dim_sizes[0] = 1;
	args[1].n_dims = 1;
	_NclRegisterProc(_NclIAddFile,args,"addfile",2,IFUNC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = NULL;
	args[0].is_dimsizes = 0;
	_NclRegisterFunc(_NclISizeOf,args,"sizeof",1,IFUNC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = NULL;
	args[0].is_dimsizes = 0;
	_NclRegisterFunc(_NclIDimSizes,args,"dimsizes",1,IFUNC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("logical");
	args[0].is_dimsizes = 0;
	_NclRegisterFunc(_NclIAny,args,"any",1,IFUNC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("logical");
	args[0].is_dimsizes = 0;
	_NclRegisterFunc(_NclIAll,args,"all",1,IFUNC);

	args = NclCalloc(2,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 1;
	args[0].dim_sizes[0] = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("graphic");
	args[1].is_dimsizes = 1;
	args[1].dim_sizes[0] = 1;
	args[1].n_dims = 1;
	_NclRegisterProc(_NclIAddToOverlay,args,"overlay",2,IPROC);

	args = NclCalloc(3,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 1;
	args[0].dim_sizes[0] = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("graphic");
	args[1].is_dimsizes = 1;
	args[1].dim_sizes[0] = 1;
	args[1].n_dims = 1;
	args[2].arg_data_type = _NclLookUp("graphic");
	args[2].is_dimsizes = 1;
	args[2].dim_sizes[0] = 1;
	args[2].n_dims = 1;
	_NclRegisterProc(_NclIAddToOverlayAfter,args,"NhlAddOverlay",3,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = NULL;
	args[0].is_dimsizes = 0;
	_NclRegisterFunc(_NclIIsMissing,args,"ismissing",1,IFUNC);

	args = NclCalloc(5,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 1;
	args[0].dim_sizes[0] = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("float");
	args[1].is_dimsizes = 0;
	args[1].n_dims = 1;
	args[2].arg_data_type = _NclLookUp("float");
	args[2].is_dimsizes = 0;
	args[2].n_dims = 1;
	args[3].arg_data_type = _NclLookUp("float");
	args[3].is_dimsizes = 0;
	args[3].n_dims = 1;
	args[4].arg_data_type = _NclLookUp("float");
	args[4].is_dimsizes = 0;
	args[4].n_dims = 1;
	_NclRegisterProc(_NclINhlDataToNDC,args,"NhlDataToNDC",5,IPROC);

	args = NclCalloc(5,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 1;
	args[0].dim_sizes[0] = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("float");
	args[1].is_dimsizes = 0;
	args[1].n_dims = 1;
	args[2].arg_data_type = _NclLookUp("float");
	args[2].is_dimsizes = 0;
	args[2].n_dims = 1;
	args[3].arg_data_type = _NclLookUp("float");
	args[3].is_dimsizes = 0;
	args[3].n_dims = 1;
	args[4].arg_data_type = _NclLookUp("float");
	args[4].is_dimsizes = 0;
	args[4].n_dims = 1;
	_NclRegisterProc(_NclINhlDataToNDC,args,"datatondc",5,IPROC);

	args = NclCalloc(5,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 0;
	args[1].arg_data_type = _NclLookUp("float");
	args[1].is_dimsizes = 0;
	args[1].n_dims = 1;
	args[2].arg_data_type = _NclLookUp("float");
	args[2].is_dimsizes = 0;
	args[2].n_dims = 1;
	args[3].arg_data_type = _NclLookUp("float");
	args[3].is_dimsizes = 0;
	args[3].n_dims = 1;
	args[4].arg_data_type = _NclLookUp("float");
	args[4].is_dimsizes = 0;
	args[4].n_dims = 1;
	_NclRegisterProc(_NclINhlNDCToData,args,"ndctodata",5,IPROC);

	args = NclCalloc(5,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("graphic");
	args[0].is_dimsizes = 0;
	args[1].arg_data_type = _NclLookUp("float");
	args[1].is_dimsizes = 0;
	args[1].n_dims = 1;
	args[2].arg_data_type = _NclLookUp("float");
	args[2].is_dimsizes = 0;
	args[2].n_dims = 1;
	args[3].arg_data_type = _NclLookUp("float");
	args[3].is_dimsizes = 0;
	args[3].n_dims = 1;
	args[4].arg_data_type = _NclLookUp("float");
	args[4].is_dimsizes = 0;
	args[4].n_dims = 1;
	_NclRegisterProc(_NclINhlNDCToData,args,"NhlNDCToData",5,IPROC);

	_NclRegisterProc(_NclIListVariables,NULL,"list_vars",0,IPROC);
	_NclRegisterProc(_NclIListFiles,NULL,"list_files",0,IPROC);
	_NclRegisterProc(_NclIListFuncs,NULL,"list_procfuncs",0,IPROC);
	_NclRegisterProc(_NclIListHLUObjs,NULL,"list_hlus",0,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("file");
	args[0].is_dimsizes = 1;
	args[0].dim_sizes[0] = 1;
	args[0].n_dims = 1;
	_NclRegisterProc(_NclIListFileVariables,args,"list_filevars",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("file");
	args[0].is_dimsizes = 1;
	args[0].dim_sizes[0] = 1;
	args[0].n_dims = 1;
	_NclRegisterFunc(_NclIGetFileVarNames,args,"getfilevarnames",1,IFUNC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("file");
	args[0].is_dimsizes = 1;
	args[0].dim_sizes[0] = 1;
	args[0].n_dims = 1;
	_NclRegisterFunc(_NclIGetFileGrpNames,args,"getfilegrpnames",1,IFUNC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("numeric");
	args[0].is_dimsizes = 0;
	args[0].n_dims = 1;
	_NclRegisterProc(_NclIqsort,args,"qsort",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].is_dimsizes = 0;
	args[0].n_dims = 1;
	_NclRegisterProc(_NclIqsort,args,"sqsort",1,IPROC);

	args = NclCalloc(2,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("numeric");
	args[0].is_dimsizes = 0;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("numeric");
	args[1].dim_sizes[0] = 1;
	args[1].is_dimsizes = 1;
	args[1].n_dims = 1;
	_NclRegisterFunc(_NclIbsearch,args,"bsearch",2,IFUNC);

	args = NclCalloc(3,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("numeric");
	args[1].is_dimsizes = 0;
	args[1].n_dims = 1;
	args[2].arg_data_type = _NclLookUp("string");
	args[2].is_dimsizes = 1;
	args[2].dim_sizes[0] = 1;
	args[2].n_dims = 1;
	_NclRegisterFunc(_NclIcbinread,args,"cbinread",3,IFUNC);

	args = NclCalloc(4,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("integer");
	args[1].dim_sizes[0] = 1;
	args[1].is_dimsizes = 1;
	args[1].n_dims = 1;
	args[2].arg_data_type = _NclLookUp("numeric");
	args[2].is_dimsizes = 1;
	args[2].n_dims = 1;
	args[2].dim_sizes[0] = -1;
	args[3].arg_data_type = _NclLookUp("string");
	args[3].is_dimsizes = 1;
	args[3].dim_sizes[0] = 1;
	args[3].n_dims = 1;
	_NclRegisterFunc(_NclIfbindirread,args,"fbindirread",4,IFUNC);

	args = NclCalloc(4,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("integer");
	args[1].dim_sizes[0] = 1;
	args[1].is_dimsizes = 1;
	args[1].n_dims = 1;
	args[2].arg_data_type = _NclLookUp("numeric");
	args[2].is_dimsizes = 1;
	args[2].n_dims = 1;
	args[2].dim_sizes[0] = -1;
	args[3].arg_data_type = _NclLookUp("string");
	args[3].is_dimsizes = 1;
	args[3].dim_sizes[0] = 1;
	args[3].n_dims = 1;
	_NclRegisterFunc(_NclIfbinrecread,args,"fbinrecread",4,IFUNC);

	args = NclCalloc(3,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("integer");
	args[1].dim_sizes[0] = 1;
	args[1].is_dimsizes = 1;
	args[1].n_dims = 1;
	args[2].arg_data_type = NULL;
	args[2].is_dimsizes = 0;
	_NclRegisterFunc(_NclIfbinrecwrite,args,"fbinrecwrite",3,IPROC);
	
	args = NclCalloc(4,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("integer");
	args[1].dim_sizes[0] = 1;
	args[1].is_dimsizes = 1;
	args[1].n_dims = 1;
	args[2].arg_data_type = _NclLookUp("numeric");
	args[2].is_dimsizes = 0;
	args[2].n_dims = 1;
	args[3].arg_data_type = _NclLookUp("string");
	args[3].is_dimsizes = 1;
	args[3].dim_sizes[0] = 1;
	args[3].n_dims = 1;
	_NclRegisterFunc(_NclICrayBinRecRead,args,"craybinrecread",4,IFUNC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	_NclRegisterFunc(_NclICrayBinNumRec,args,"craybinnumrec",1,IFUNC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	_NclRegisterFunc(_NclIfbinnumrec,args,"fbinnumrec",1,IFUNC);


	args = NclCalloc(3,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("numeric");
	args[1].is_dimsizes = 0;
	args[1].n_dims = 1;
	args[2].arg_data_type = _NclLookUp("string");
	args[2].is_dimsizes = 0;
	args[2].dim_sizes[0] = 1;
	args[2].n_dims = 1;
	_NclRegisterFunc(_NclIfbinread,args,"fbinread",3,IFUNC);

	args = NclCalloc(3,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("numeric");
	args[1].is_dimsizes = 0;
	args[1].n_dims = 1;
	args[2].arg_data_type = _NclLookUp("string");
	args[2].dim_sizes[0] = 1;
	args[2].is_dimsizes = 1;
	args[2].n_dims = 1;
	_NclRegisterFunc(_NclIasciiread,args,"asciiread",3,IFUNC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	_NclRegisterProc(_NclIchngdir,args,"chngdir",1,IPROC);

	args = NclCalloc(2,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("numeric");
	args[1].is_dimsizes = 0;
	_NclRegisterProc(_NclIfbindirwrite,args,"fbindirwrite",2,IPROC);

	args = NclCalloc(2,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("numeric");
	args[1].is_dimsizes = 0;
	_NclRegisterProc(_NclIcbinwrite,args,"cbinwrite",2,IPROC);

	args = NclCalloc(2,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = NULL;
	args[1].is_dimsizes = 0;
	_NclRegisterProc(_NclIasciiwrite,args,"asciiwrite",2,IPROC);

	args = NclCalloc(2,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	args[1].arg_data_type = _NclLookUp("numeric");
	args[1].is_dimsizes = 0;
	_NclRegisterProc(_NclIfbinwrite,args,"fbinwrite",2,IPROC);

	_NclRegisterFunc(_NclIrand,NULL,"rand",0,IFUNC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("integer");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	_NclRegisterProc(_NclIsrand,args,"srand",1,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("integer");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	_NclRegisterProc(_NclIsleep,args,"sleep",1,IPROC);
	
	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	_NclRegisterFunc(_NclIprompt,args,"prompt",1,IFUNC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	_NclRegisterFunc(_NclIncargpath,args,"ncargpath",1,IFUNC);

	_NclRegisterProc(_NclIncargversion,NULL,"ncargversion",0,IPROC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("string");
	args[0].dim_sizes[0] = 1;
	args[0].is_dimsizes = 1;
	args[0].n_dims = 1;
	_NclRegisterFunc(_NclIgetenv,args,"getenv",1,IFUNC);

	args = NclCalloc(1,sizeof(NclArgTemplate));
	args[0].arg_data_type = _NclLookUp("snumeric");
	args[0].is_dimsizes = 0;
	_NclRegisterFunc(_NclIabs,args,"abs",1,IFUNC);
	
	return;
}
Пример #10
0
NhlErrorTypes AddNewGrp(void *rec, NclQuark grpname, size_t id)
{
    NclFileGrpNode *rootgrpnode = (NclFileGrpNode *) rec;
    NhlErrorTypes ret = NhlNOERROR;
    NclFileGrpNode   *grpnode;
    NclFileGrpRecord *grprec;
    int n = -1;
    char buffer[2 * NC_MAX_NAME + 1];

    ret = _addNclGrpNodeToGrpNode(rootgrpnode, grpname);

    grprec = rootgrpnode->grp_rec;

    for(n = 0; n < grprec->n_grps; n++)
    {
        grpnode = grprec->grp_node[n];
        if(grpname == grpnode->name)
        {
            break;
        }
        else
            grpnode = NULL;
    }

    if(NULL == grpnode)
    {
        NHLPERROR((NhlFATAL,NhlEUNKNOWN,
            "AddNewGrp: can not find group (%s)",
             NrmQuarkToString(grpname)));
        return (NhlFATAL);
    }

    grpnode->gid = id;
    grpnode->fid = id;
    grpnode->pid = rootgrpnode->gid;
    
    grpnode->pname = rootgrpnode->name;
    grpnode->path = rootgrpnode->path;
    grpnode->extension = rootgrpnode->extension;
    grpnode->file_format = rootgrpnode->file_format;
    grpnode->status = rootgrpnode->status;
    grpnode->open = rootgrpnode->open;
    grpnode->format = rootgrpnode->format;
    grpnode->define_mode = rootgrpnode->define_mode;
    grpnode->compress_level = rootgrpnode->compress_level;
    grpnode->is_chunked = rootgrpnode->is_chunked;
    grpnode->use_cache = rootgrpnode->use_cache;
    grpnode->cache_size = rootgrpnode->cache_size;
    grpnode->cache_nelems = rootgrpnode->cache_nelems;
    grpnode->cache_preemption = rootgrpnode->cache_preemption;

    if(strcmp("/", NrmQuarkToString(grpnode->pname)))
    {
	    sprintf(buffer, "/%s", NrmQuarkToString(grpname));
    }
    else
    {
            sprintf(buffer, "%s%s", NrmQuarkToString(rootgrpnode->real_name),  NrmQuarkToString(grpname));
    }
    grpnode->real_name = NrmStringToQuark(buffer);

    grpnode->n_options = rootgrpnode->n_options;
    grpnode->options = (NCLOptions *)NclCalloc(rootgrpnode->n_options, sizeof(NCLOptions));
    assert(grpnode->options);
    memcpy(grpnode->options, rootgrpnode->options, rootgrpnode->n_options * sizeof(NCLOptions));

    grpnode->chunk_dim_rec = NULL;
    grpnode->unlimit_dim_rec = NULL;
    grpnode->dim_rec = NULL;
    grpnode->att_rec = NULL;
    grpnode->var_rec = NULL;
    grpnode->coord_var_rec = NULL;
    grpnode->grp_rec = NULL;
    grpnode->udt_rec = NULL;
    grpnode->parent = rootgrpnode;

    return ret;
}
Пример #11
0
NclFileVarNode *GetVarNodeFromGrpNode(void *therec, NclQuark var_name)
{
    NclFileGrpNode *grpnode = (NclFileGrpNode *) therec;
    NclFileVarNode *varnode;
    NclFileVarNode *tmp = NULL;
    int n, j;

    if(NULL != grpnode->var_rec)
    {
        for(n = 0; n < grpnode->var_rec->n_vars; n++)
        {
            varnode = &(grpnode->var_rec->var_node[n]);

            if((varnode->name != var_name) && (varnode->real_name != var_name))
                continue;

            tmp = (NclFileVarNode *)NclCalloc(1, sizeof(NclFileVarNode));
            assert(tmp);

            memcpy(tmp, varnode, sizeof(NclFileVarNode));

          /*
           *if(NULL != varnode->dimid)
           *{
           *    tmp->dimid = (int *) NclCalloc(varnode->dim_rec->n_dims, sizeof(int));
           *    assert(tmp->dimid);
           *    memcpy(&(tmp->dimid), &(varnode->dimid), varnode->dim_rec->n_dims * sizeof(int));
           *}
           */

            if(NULL != varnode->dim_rec)
            {
                tmp->dim_rec = _NclFileDimAlloc(varnode->dim_rec->n_dims);
                tmp->dim_rec->gid = varnode->dim_rec->gid;
                memcpy(&(tmp->dim_rec), &(varnode->dim_rec), sizeof(NclFileDimRecord));
                for(j = 0; j < varnode->dim_rec->n_dims; j++)
                {
                    memcpy(&(tmp->dim_rec->dim_node[j]), &(varnode->dim_rec->dim_node[j]),
                             sizeof(NclFileDimNode));
                }
            }

            if(NULL != varnode->chunk_dim_rec)
            {
                tmp->chunk_dim_rec = _NclFileDimAlloc(varnode->chunk_dim_rec->n_dims);
                tmp->chunk_dim_rec->gid = varnode->chunk_dim_rec->gid;
                memcpy(&(tmp->chunk_dim_rec), &(varnode->chunk_dim_rec), sizeof(NclFileDimRecord));
                for(j = 0; j < varnode->chunk_dim_rec->n_dims; j++)
                {
                    memcpy(&(tmp->chunk_dim_rec->dim_node[j]), &(varnode->chunk_dim_rec->dim_node[j]),
                             sizeof(NclFileDimNode));
                }
            }

            if(NULL != varnode->att_rec)
            {
                tmp->att_rec = _NclFileAttAlloc(varnode->att_rec->n_atts);
                memcpy(tmp->att_rec, varnode->att_rec, sizeof(NclFileAttRecord));
                for(j = 0; j < varnode->att_rec->n_atts; j++)
                {
                    memcpy(&(tmp->att_rec->att_node[j]), &(varnode->att_rec->att_node[j]),
                             sizeof(NclFileAttNode));
                    if(varnode->att_rec->att_node[j].n_elem)
                    {
                        memcpy(tmp->att_rec->att_node[j].value,
                               varnode->att_rec->att_node[j].value,
                               varnode->att_rec->att_node[j].n_elem *
                               _NclSizeOf(varnode->att_rec->att_node[j].type));
                    }
                }
            }

            return(tmp);
        }
    }

    if(NULL != grpnode->grp_rec)
    {
        for(n = 0; n < grpnode->grp_rec->n_grps; n++)
        {
            tmp = GetVarNodeFromGrpNode(grpnode->grp_rec->grp_node[n], var_name);
            if(NULL != tmp)
                return tmp;
        }
    }

    return(tmp);
}