bm_file.c#206   int ret = 0;


#209   if ((ret = nc_inq_attname(ncid1, varid, a, name)))


#210      return ret;


#211   if ((ret = nc_inq_att(ncid1, varid, name, &typeid, &len)))


#212      return ret;


#213   if ((ret = nc_inq_att(ncid2, varid, name, &typeid2, &len2)))


#214      return ret;


#217   if ((ret = nc_inq_type(ncid1, typeid, NULL, &typelen)))


#218      return ret;


#227	 ret = NOMEM;


#230      if ((ret = nc_get_att(ncid1, varid, name, d)))


#232      if ((ret = nc_get_att(ncid2, varid, name, d2)))


#237	 ret = BAD;


#247   return ret;


#275   int ret = NC_NOERR;


#283      if ((ret = nc_open_par(file1, 0, MPI_COMM_WORLD, MPI_INFO_NULL, &ncid1)))


#284	 ERR1(ret);


#287      if ((ret = nc_open_par(file2, 0, MPI_COMM_WORLD, MPI_INFO_NULL, &ncid2)))


#288	 ERR1(ret);


#296      if ((ret = nc_open(file1, 0, &ncid1)))


#297	 ERR1(ret);


#299      if ((ret = nc_open(file2, 0, &ncid2)))


#300	 ERR1(ret);


#310   if ((ret = nc_inq(ncid1, &ndims, &nvars, &natts, &unlimdimid)))


#311      ERR1(ret);


#312   if ((ret = nc_inq(ncid1, &ndims2, &nvars2, &natts2, &unlimdimid2)))


#313      ERR1(ret);


#321      if ((ret = nc_inq_dim(ncid1, d, name, &len)))


#322	 ERR1(ret);


#323      if ((ret = nc_inq_dim(ncid2, d, name2, &len2)))


#324	 ERR1(ret);


#331      if ((ret = check_att(ncid1, ncid2, NC_GLOBAL, a)))


#332	 ERR1(ret);


#338      if ((ret = nc_inq_var(ncid1, v, name, &xtype, &ndims, dimids, &natts)))


#339	 return ret;


#340      if ((ret = nc_inq_var(ncid2, v, name2, &xtype2, &ndims2, dimids2, &natts2)))


#341	 return ret;


#352	 if ((ret = check_att(ncid1, ncid2, v, a)))


#353	    ERR1(ret);


#375	 if ((ret = nc_inq_dimlen(ncid1, dimids[d], &dimlen[d])))


#376	    ERR1(ret);


#382      if ((ret = get_starts_counts(ndims, dimlen, p, my_rank, slow_count, use_scs,


#385	 return ret;


#395      if ((ret = nc_inq_type(ncid1, xtype, NULL, &type_size)))


#396	 return ret;


#407      for (step = 0; !ret && step < num_steps; step++)


#451   if ((ret = nc_close(ncid1)))


#452      ERR1(ret);


#453   if ((ret = nc_close(ncid2)))


#454      ERR1(ret);


#475   int ret;


#485      if ((ret = nc_open_par(file_name_in, 0, MPI_COMM_WORLD, MPI_INFO_NULL, &ncid_in)))


#486	 ERR1(ret);


#495      if ((ret = nc_open(file_name_in, 0, &ncid_in)))


#496	 ERR1(ret);


#505   if ((ret = nc_inq_format(ncid_in, in_format)))


#506      ERR1(ret);


#515	 if ((ret = nc_create_par(file_name_out, cmode_out, MPI_COMM_WORLD,


#517	    ERR1(ret);


#527	 if ((ret = nc_set_chunk_cache(SIXTEEN_MEG, NELEMS, PREEMPTION)))


#528	    ERR1(ret);


#529	 if ((ret = nc_create(file_name_out, cmode_out, &ncid_out)))


#530	    ERR1(ret);


#534   if ((ret = nc_inq(ncid_in, &ndims, &nvars, &natts, &unlimdimid)))


#535      ERR1(ret);


#542	 if ((ret = nc_inq_dim(ncid_in, d, name, &len)))


#543	    ERR1(ret);


#546	    if ((ret = nc_def_dim(ncid_out, name, len, NULL)))


#547	       ERR1(ret);


#551	    if ((ret = nc_def_dim(ncid_out, name,


#554	       ERR1(ret);


#574	 int ret = NC_NOERR;


#577	 if ((ret = nc_inq_var(ncid_in, v, name, &xtype, &ndims, dimids, &natts)))


#578	    return ret;


#620      if ((ret = nc_enddef(ncid_out)))


#621	 ERR1(ret);


#646      int ret = NC_NOERR;


#654      if ((ret = nc_inq_var(ncid_in, v, name, &xtype, &ndims, dimids, &natts)))


#655	 return ret;


#658      if ((ret = nc_inq_type(ncid_in, xtype, type_name, &type_size)))


#659	 return ret;


#670	 if ((ret = nc_inq_dimlen(ncid_in, dimids[d], &dimlen[d])))


#671	    ERR1(ret);


#691      if ((ret = get_starts_counts(ndims, dimlen, p, my_rank, slow_count, use_scs,


#694	 return ret;


#708      for (step = 0; !ret && step < num_steps; step++)


#724	 if ((ret = nc_get_vara(ncid_in, v, start, count, data)))


#725	    ERR1(ret);


#746	    if ((ret = nc_put_vara(ncid_out, v, start, count, data)))


#747	       ERR1(ret);


#837   int ret;


#1060   if ((ret = copy_file(file_in, file_out, cmode, num_vo, vo, &meta_read_us, &meta_write_us,


#1064      return ret;


#1073      if ((ret = cmp_file(file_in, file_out, &meta_read2_us, &data_read2_us,


#1076	 return ret;


chunkspec.c#47    int ret;


#100	    ret = nc_inq_dimid2(ncid, dimname, &dimid);


#101	    if(ret != NC_NOERR)


#108		ret = nc_inq_dimlen(ncid, dimid, &dimlen);


#109		if(ret != NC_NOERR)


#110		    return(ret);


dcopy.c#19   int ret = NC_NOERR;


#38      int i, ret, equal1;


#54      if ((ret = nc_inq_user_type(ncid1, typeid1, name1, &size1,


#56	 return ret;


#57      if ((ret = nc_inq_user_type(ncid2, typeid2, name2, &size2,


#59	 return ret;


#69	    if((ret = NC_compare_nc_types(ncid1, base1, ncid2,


#71	       return ret;


#90	       if ((ret = nc_inq_enum_member(ncid1, typeid1, i, name1,


#92		   (ret = nc_inq_enum_member(ncid2, typeid2, i, name2,


#98		  return ret;


#112	       if ((ret = nc_inq_compound_field(ncid1, typeid1, i, name1, &offset1,


#114		  return ret;


#115	       if ((ret = nc_inq_compound_field(ncid2, typeid2, i, name2, &offset2,


#117		  return ret;


#125	       if((ret = NC_compare_nc_types(ncid1, ftype1, ncid2, ftype2,


#127		  return ret;


#137   return ret;


#145   int i,ret = NC_NOERR;


#152   if ((ret = nc_inq_typeids(ncid2, &nids, NULL)))


#153      return ret;


#158      if ((ret = nc_inq_typeids(ncid2, &nids, ids)))


#159	 return ret;


#163	 if ((ret = NC_compare_nc_types(ncid1, tid1, ncid2, ids[i], &equal)))


#164	    return ret;


#177   if ((ret = nc_inq_grps(ncid1, &nids, NULL)))


#178      return ret;


#183      if ((ret = nc_inq_grps(ncid1, &nids, ids)))


#186	 return ret;


#190	 ret = NC_rec_find_nc_type(ncid1, tid1, ids[i], tid2);


#191	 if (ret && ret != NC_EBADTYPE)


#209   int ret = NC_NOERR;


#226   ret = NC_rec_find_nc_type(ncid1, xtype1 , ncid2, xtype2);


#227   return ret;


dv2i.c#874		int ret = NC_NOERR;


#878		ret = nc_inq_varndims(ncid, varid, &ndims);


#879		if(ret) return ret;


#880		ret = nc_inq_vartype(ncid, varid, &type);


#881		if(ret) return ret;


#931		int ret = NC_NOERR;


#935		ret = nc_inq_varndims(ncid, varid, &ndims);


#936		if(ret) return ret;


#937		ret = nc_inq_vartype(ncid, varid, &type);


#938		if(ret) return ret;


dvlen.c#54   int ret;


#58      if ((ret = nc_free_vlen(&vlens[i])))


#59	 return ret;


nc4dim.c#189   int ret = NC_NOERR;


#194   if ((ret = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))


#195      return ret;


#201   if ((ret = nc4_find_dim(grp, dimid, &dim, &dim_grp)))


#202      return ret;


#219	 if ((ret = nc4_find_dim_len(dim_grp, dimid, &lenp)))


#220	    return ret;


#226	    ret = NC_EDIMSIZE;


#234   return ret;


nc4file.c#691   int ret = 0;


#697   if ((coord_attid = H5Aopen_name(var->hdf_datasetid, COORDINATES)) < 0) ret++;


#698   if (!ret && (coord_att_typeid = H5Aget_type(coord_attid)) < 0) ret++;


#701   if (!ret && (spaceid = H5Aget_space(coord_attid)) < 0) ret++;


#705   if (!ret && (npoints = H5Sget_simple_extent_npoints(spaceid)) < 0) ret++;


#709   if (!ret && npoints != var->ndims) ret++;


#711   if (!ret && H5Aread(coord_attid, coord_att_typeid, var->dimids) < 0) ret++;


#721   if (spaceid >= 0 && H5Sclose(spaceid) < 0) ret++;


#725   if (coord_att_typeid >= 0 && H5Tclose(coord_att_typeid) < 0) ret++;


#726   if (coord_attid >= 0 && H5Aclose(coord_attid) < 0) ret++;


#727   return ret ? NC_EATTMETA : NC_NOERR;


#1361            htri_t ret;


#1367            if ((ret = H5Tis_variable_str(hdf_typeid)) < 0)


#1369            if (ret)


nc4grp.c#246   int i, ret = NC_NOERR;


#267   for (i = 1; i < g && !ret; i++)


#268      ret = NC4_inq_grp_parent(gid[i - 1], &gid[i]);


#271   for (i = g - 1; !ret && i >= 0 && !ret; i--)


#273      if ((ret = NC4_inq_grpname(gid[i], grp_name)))


#281   if (!ret && lenp)


#285   if (!ret && full_name)


#291   return ret;


#335   int ret;


#341   if ((ret = nc4_find_grp_h5(ncid, &grp, &h5)))


#342      return ret;


#368	 if ((ret = NC4_inq_ncid(id1, cp, &id2)))


#371	    return ret;


nc4hdf.c#1453  int ret = 0;


#1457  if ((c_spaceid = H5Screate_simple(1, coords_len, coords_len)) < 0) ret++;


#1461  if (!ret && (c_attid = H5Acreate(var->hdf_datasetid, COORDINATES, H5T_NATIVE_INT,


#1462                                   c_spaceid, H5P_DEFAULT)) < 0) ret++;


#1463  if (!ret && H5Awrite(c_attid, H5T_NATIVE_INT, var->dimids) < 0) ret++;


#1466  if (c_spaceid > 0 && H5Sclose(c_spaceid) < 0) ret++;


#1470  if (c_attid > 0 && H5Aclose(c_attid) < 0) ret++;


#1471  return ret ? NC_EHDFERR : 0;


nc4info.c#48    int ret = NC_NOERR;


#71	    {ret = NC_EINVAL; goto done;}


#94    return ret;


nc4internal.c#1010   int ret;


#1023      if ((ret = nc4_att_list_del(&var->att, att)))


#1024	 return ret;


nc4var.c#184   int ret;


#186   if ((ret = NC4_get_var_chunk_cache(ncid, varid, &real_size,


#188      return ret;


nc_iter.c#188    int ret = 1;


#201      ret = 0;


#202    return ret;


ncd2dispatch.c#2246    int ret;


#2247    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2248    ret = nc_inq_base_pe(getnc3id(drno), pe);


#2249    return THROW(ret);


#2256    int ret = NC_NOERR;


#2257    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2258    ret = nc_inq_format(getnc3id(drno), formatp);


#2259    return THROW(ret);


#2266    int ret;


#2267    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2268    ret = nc_inq(getnc3id(drno), ndimsp, nvarsp, nattsp, unlimdimidp);


#2269    return THROW(ret);


#2276    int ret;


#2277    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2278    ret = nc_inq_type(getnc3id(drno), p2, p3, p4);


#2279    return THROW(ret);


#2286    int ret;


#2287    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2288    ret = nc_inq_dimid(getnc3id(drno), name, idp);


#2289    return THROW(ret);


#2296    int ret;


#2297    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2298    ret = nc_inq_dim(getnc3id(drno), dimid, name, lenp);


#2299    return THROW(ret);


#2306    int ret;


#2307    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2308    ret = nc_inq_unlimdim(getnc3id(drno), unlimdimidp);


#2309    return THROW(ret);


#2316    int ret;


#2317    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2318    ret = nc_rename_dim(getnc3id(drno), dimid, name);


#2319    return THROW(ret);


#2327    int ret;


#2328    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2329    ret = nc_inq_att(getnc3id(drno), varid, name, xtypep, lenp);


#2330    return THROW(ret);


#2337    int ret;


#2338    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2339    ret = nc_inq_attid(getnc3id(drno), varid, name, idp);


#2340    return THROW(ret);


#2347    int ret;


#2348    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2349    ret = nc_inq_attname(getnc3id(drno), varid, attnum, name);


#2350    return THROW(ret);


#2357    int ret;


#2358    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2359    ret = nc_rename_att(getnc3id(drno), varid, name, newname);


#2360    return THROW(ret);


#2367    int ret;


#2368    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2369    ret = nc_del_att(getnc3id(drno), varid, p3);


#2370    return THROW(ret);


#2377    int ret;


#2378    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2379    ret = NCDISPATCH_get_att(getnc3id(drno), varid, name, value, t);


#2380    return THROW(ret);


#2392    int ret;


#2393    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2394    ret = NCDISPATCH_inq_var_all(getnc3id(drno), varid, name, xtypep,


#2400    return THROW(ret);


#2407    int ret;


#2408    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2409    ret = nc_inq_varid(getnc3id(drno),name,varidp);


#2410    return THROW(ret);


#2417    int ret;


#2418    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2419    ret = nc_rename_var(getnc3id(drno), varid, name);


#2420    return THROW(ret);


#2436    int ret;


#2437    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2438    ret = nc_inq_ncid(getnc3id(drno), name, grp_ncid);


#2439    return THROW(ret);


#2446    int ret;


#2447    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2448    ret = nc_show_metadata(getnc3id(drno));


#2449    return THROW(ret);


#2456    int ret;


#2457    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2458    ret = nc_inq_grps(getnc3id(drno), p2, p3);


#2459    return THROW(ret);


#2466    int ret;


#2467    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2468    ret = nc_inq_grpname(getnc3id(drno), p);


#2469    return THROW(ret);


#2477    int ret;


#2478    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2479    ret = nc_inq_unlimdims(getnc3id(drno), p2, p3);


#2480    return THROW(ret);


#2487    int ret;


#2488    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2489    ret = nc_inq_grpname_full(getnc3id(drno), p2, p3);


#2490    return THROW(ret);


#2497    int ret;


#2498    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2499    ret = nc_inq_grp_parent(getnc3id(drno), p);


#2500    return THROW(ret);


#2507    int ret;


#2508    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2509    ret = nc_inq_grp_full_ncid(getnc3id(drno), p2, p3);


#2510    return THROW(ret);


#2517    int ret;


#2518    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2519    ret = nc_inq_varids(getnc3id(drno), nvars, p);


#2520    return THROW(ret);


#2527    int ret;


#2528    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2529    ret = nc_inq_dimids(getnc3id(drno), ndims, p3, p4);


#2530    return THROW(ret);


#2537    int ret;


#2538    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2539    ret = nc_inq_typeids(getnc3id(drno), ntypes, p);


#2540    return THROW(ret);


#2547    int ret;


#2548    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2549    ret = nc_inq_type_equal(getnc3id(drno), t1, p3, t2, p5);


#2550    return THROW(ret);


#2558    int ret;


#2559    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2560    ret = nc_inq_user_type(getnc3id(drno), t, p3, p4, p5, p6, p7);


#2561    return THROW(ret);


#2568    int ret;


#2569    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2570    ret = nc_inq_typeid(getnc3id(drno), name, t);


#2571    return THROW(ret);


#2578    int ret;


#2579    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2580    ret = nc_def_grp(getnc3id(drno), p2, p3);


#2581    return THROW(ret);


#2588    int ret;


#2589    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2590    ret = nc_rename_grp(getnc3id(drno), p);


#2591    return THROW(ret);


#2598    int ret;


#2599    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2600    ret = nc_def_compound(getnc3id(drno), p2, p3, t);


#2601    return THROW(ret);


#2608    int ret;


#2609    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2610    ret = nc_insert_compound(getnc3id(drno), t1, p3, p4, t2);


#2611    return THROW(ret);


#2619    int ret;


#2620    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2621    ret = nc_insert_array_compound(getnc3id(drno), t1, p3, p4,  t2, p6, p7);


#2622    return THROW(ret);


#2631    int ret;


#2632    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2633    ret = nc_inq_compound_field(getnc3id(drno), xtype, fieldid, name, offsetp, field_typeidp, ndimsp, dim_sizesp);


#2634    return THROW(ret);


#2642    int ret;


#2643    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2644    ret = nc_inq_compound_fieldindex(getnc3id(drno), xtype, name, fieldidp);


#2645    return THROW(ret);


#2652    int ret;


#2653    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2654    ret = nc_def_vlen(getnc3id(drno), p2, base_typeid, t);


#2655    return THROW(ret);


#2662    int ret;


#2663    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2664    ret = nc_put_vlen_element(getnc3id(drno), p2, p3, p4, p5);


#2665    return THROW(ret);


#2672    int ret;


#2673    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2674    ret = nc_get_vlen_element(getnc3id(drno), p2, p3, p4, p5);


#2675    return THROW(ret);


#2682    int ret;


#2683    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2684    ret = nc_def_enum(getnc3id(drno), t1, p3, t);


#2685    return THROW(ret);


#2692    int ret;


#2693    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2694    ret = nc_insert_enum(getnc3id(drno), t1, p3, p4);


#2695    return THROW(ret);


#2702    int ret;


#2703    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2704    ret = nc_inq_enum_member(getnc3id(drno), t1, p3, p4, p5);


#2705    return THROW(ret);


#2712    int ret;


#2713    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2714    ret = nc_inq_enum_ident(getnc3id(drno), t1, p3, p4);


#2715    return THROW(ret);


#2722    int ret;


#2723    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2724    ret = nc_def_opaque(getnc3id(drno), p2, p3, t);


#2725    return THROW(ret);


#2732    int ret;


#2733    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2734    ret = nc_def_var_deflate(getnc3id(drno), p2, p3, p4, p5);


#2735    return THROW(ret);


#2742    int ret;


#2743    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2744    ret = nc_def_var_fletcher32(getnc3id(drno), p2, p3);


#2745    return THROW(ret);


#2752    int ret;


#2753    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2754    ret = nc_def_var_chunking(getnc3id(drno), p2, p3, p4);


#2755    return THROW(ret);


#2762    int ret;


#2763    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2764    ret = nc_def_var_fill(getnc3id(drno), p2, p3, p4);


#2765    return THROW(ret);


#2772    int ret;


#2773    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2774    ret = nc_def_var_endian(getnc3id(drno), p2, p3);


#2775    return THROW(ret);


#2782    int ret;


#2783    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2784    ret = nc_set_var_chunk_cache(getnc3id(drno), p2, p3, p4, p5);


#2785    return THROW(ret);


#2792    int ret;


#2793    if((ret = NC_check_id(ncid, (NC**)&drno)) != NC_NOERR) return THROW(ret);


#2794    ret = nc_get_var_chunk_cache(getnc3id(drno), p2, p3, p4, p5);


#2795    return THROW(ret);


nciter.c#123    int ret = 1;


#136      ret = 0;


#137    return ret;


#154    int ret = 1;


#165      ret = 0;


#166    return ret;


t_nc.c#346	int cmode=NC_CLOBBER, omode, ret;


#365	ret = nc_create_par(fname,cmode, MPI_COMM_WORLD, MPI_INFO_NULL, &id);


#367	ret = nc__create(fname,cmode, initialsz, &chunksz, &id);


#368	if(ret != NC_NOERR) {


#370		ret = nc__create(fname,cmode, initialsz, &chunksz, &id);


#373	if(ret != NC_NOERR)  {


#374		fprintf(stderr,"Error %s in file %s at line %d\n",nc_strerror(ret),__FILE__,__LINE__);


#375		exit(ret);


#467	ret = nc_close(id);


#477	ret = nc_open_par(fname,omode, MPI_COMM_WORLD, MPI_INFO_NULL, &id);


#479	ret = nc__open(fname,omode, &chunksz, &id);


#481	if(ret != NC_NOERR)


#484			nc_strerror(ret));


#670	ret = nc_close(id);


tst_dims.c#1194      int ret;


#1208      ret = nc_inq_dim(ncid, dimid, name_in, &len_in);


#1209      if ((SIZEOF_SIZE_T >= 8 && ret) ||


#1210	  (SIZEOF_SIZE_T < 8 && ret != NC_EDIMSIZE)) ERR;


tst_files.c#397   int ret;


#461   ret = nc_def_var(ncid, REDEF_VAR3_NAME, NC_UBYTE, REDEF_NDIMS,


#464	if(ret != NC_EPERM) {


#468	if(ret != NC_ENOTINDEFINE) {


#504   ret = nc_put_att_uchar(ncid, NC_GLOBAL, REDEF_ATT3_NAME, NC_BYTE, 1, &uchar_out);


#505   if (format != NC_FORMAT_NETCDF4 && ret) ERR;


#506   else if (format == NC_FORMAT_NETCDF4 && ret != NC_ERANGE) ERR;


#541   ret = nc_get_att_uchar(ncid, NC_GLOBAL, REDEF_ATT3_NAME, &uchar_in);


#544      if (ret != NC_ERANGE) ERR;


#546   else if (ret) ERR;


tst_files2.c#98   int i, d, ret;


#103   ret = nc_create(file_name, NC_NOCLOBBER|mode, &ncid);


#104   if (ret == NC_EEXIST)


#106   else if (ret)


tst_h_scalar.c#186        int ret;


tst_parallel4.c#47    int j, i, ret;


#175    if ((ret = nc_open_par(file_name, NC_NOWRITE|NC_MPIIO, comm, info, &ncid)))


#177       printf("ret = %d\n", ret);


tst_put_vars_two_unlim_dim.c#12    int ret;


#20    if ((ret = nc_create("tst_put_vars_two_unlim_dim.nc", NC_NETCDF4 | NC_CLOBBER, &ncid))) {


#21        printf("nc_create(...): error code = %d\n", ret);


#25    if ((ret = nc_def_dim(ncid, "dim1", NC_UNLIMITED, &dim1id))) {


#26        printf("nc_def_dim(...\"dim1\"...): error code = %d\n", ret);


#31    if ((ret = nc_def_dim(ncid, "dim2", NC_UNLIMITED, &dim2id))) {


#32        printf("nc_def_dim(...\"dim1\"...): error code = %d\n", ret);


#37    if ((ret = nc_def_var(ncid, "var1", NC_DOUBLE, 1, &dim1id, &var1id))) {


#38        printf("nc_def_var(...\"var1\"...): error code = %d\n", ret);


#43    if ((ret = nc_def_var(ncid, "var2", NC_DOUBLE, 1, &dim2id, &var2id))) {


#44        printf("nc_def_var(...\"var2\"...): error code = %d\n", ret);


#49    if ((ret = nc_put_vars_double(ncid, var1id, &start, &count, NULL, &vals[0])))  {


#50        printf("nc_put_var_double(...var1id...): error code = %d\n", ret);


#55    if ((ret = nc_put_vars_double(ncid, var2id, &start, &count, NULL, &vals[0])))  {


#56        printf("nc_put_var_double(...var2id...): error code = %d\n", ret);


#61    if ((ret = nc_close(ncid))) {


#62        printf("nc_close(...): error code = %d\n", ret);


tst_simplerw_coll_r.c#56    int j, i, ret;


#184    if ((ret = nc_open_par(FILE_NAME, NC_NOWRITE|NC_MPIIO, comm, info, &ncid)))


#186       printf("ret = %d\n", ret);


utils.c#65    char *ret;			/* string returned */


#77    ret = emalloc(4*strlen(cp) + 1); /* max if every char escaped */


#78    sp = ret;


#131    return ret;


#150    int ret = NC_NOERR;


#155	ret = nc_inq_dimid(ncid, dimname, dimidp);


#165      ret = nc_inq_grp_full_ncid(ncid, grpname, &grpid);


#166      if(ret == NC_NOERR) {


#167	ret = nc_inq_dimid(grpid, dimname, dimidp);


#172    return ret;


vardata.c#397    int ret = 1;


#408      ret = 0;


#409    return ret;




HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017  | Polyhedron Solutions - INTERNAL USE | COMMERCIAL  (Any O/S) SN 4AKIed