00001 c 00002 c*********************************************************************** 00003 c R1: Get Children names of a Node. Return the name of children nodes 00004 c directly associated with a parent node. The names of the children 00005 c are NOT guaranteed to be returned in any particular order. If a 00006 c new child is added, it is NOT guaranteed to be returned as the last 00007 c child. Note: To start with the first child, use an istart value of 1. 00008 c 00009 c f77: ADFCNAM( ID, istart, inum, inamlen, inumret, names, ierr ) 00010 c input: real*8 ID. The ID of the Node to use. 00011 c input: integer istart. The Nth child's name to start with (first=1). 00012 c input: integer inum. Maximum number of names to return. 00013 c input: integer inamlen. Length of names. 00014 c output: integer inumret. The number of names returned. 00015 c output: character*(*) names Array of names. 00016 c output: integer ierr. 00017 c*********************************************************************** 00018 subroutine ADFCNAM( ID, istart, inum, inamlen, inumret, names, 00019 1 ierr ) 00020 IMPLICIT NONE 00021 real*8 ID 00022 integer istart 00023 integer inum 00024 integer inamlen 00025 integer inumret 00026 character*(*) names 00027 integer ierr 00028 00029 call ADFCNA2( ID, istart, inum, inamlen, len(names), inumret, 00030 1 names, ierr ) 00031 return 00032 end 00033 00034 c*********************************************************************** 00035 c R1: Create a Node. Create a new node (not a link-node) as a child 00036 c of a given parent. Default values in this new node are: label=blank, 00037 c number of sub-nodes = 0, data-type = "MT", number of dimensions 00038 c = 0, data = NULL. 00039 c 00040 c f77: ADFCRE( PID, name, ID, ierr ) 00041 c input: real*8 PID. The ID of the parent node, to whom we are 00042 c creating a new child node. 00043 c input: character*(*) name. 00044 c output: real*8 ID. The ID of the newly created node. 00045 c output: integer ierr. 00046 c*********************************************************************** 00047 subroutine ADFCRE( PID, name, ID, ierr ) 00048 IMPLICIT NONE 00049 real*8 PID 00050 character*(*) name 00051 real*8 ID 00052 integer ierr 00053 00054 call ADFCRE2( PID, name, LEN( name ), ID, ierr ) 00055 return 00056 end 00057 00058 c*********************************************************************** 00059 c R1: Close an opened database. If the ADF database spans multiple 00060 c files then all files used will also be closed. If an ADF file which 00061 c is linked to by this database is also opened through another 00062 c database, only the opened file stream associated with this database 00063 c will be closed. 00064 c 00065 c f77: ADFDCLO( RootID, ierr ) 00066 c input: real*8 RootID Root ID of the database. 00067 c output: integer ierr. 00068 c*********************************************************************** 00069 subroutine ADFDCLO( RootID, ierr ) 00070 IMPLICIT NONE 00071 real*8 RootID 00072 integer ierr 00073 00074 call ADFDCL2( RootID, ierr ) 00075 return 00076 end 00077 00078 c*********************************************************************** 00079 c Rn: Delete an existing database. This will delete one or more ADF 00080 c files which are linked together under file top ADF file named 00081 c "filename". 00082 c 00083 c f77: ADFDDEL( filename, ierr ) 00084 c input: character*(*) filename 00085 c output: integer ierr. 00086 c*********************************************************************** 00087 subroutine ADFDDEL( filename, ierr ) 00088 IMPLICIT NONE 00089 character*(*) filename 00090 integer ierr 00091 00092 call ADFDDE2( filename, LEN( filename ), ierr ) 00093 return 00094 end 00095 00096 c*********************************************************************** 00097 c R2: Delete a Node. If the node is NOT a link, then the specified 00098 c node and all 00099 c sub-nodes anywhere under it are also deleted. For a link, and also 00100 c for links farther down in the tree, the link-node will be deleted, 00101 c but the node which the link is linked to is not affected. When a 00102 c node is deleted, other link-nodes which point to it are left 00103 c dangling. For example, if N13 is deleted, then L1 and L2 point to a 00104 c non-existing node. This is OK until L1 and L2 are used. 00105 c 00106 c f77: ADFDEL( PID, ID, ierr ) 00107 c input: real*8 PID. The ID of the node's parent. 00108 c input: real*8 ID. The ID of the node to use. 00109 c output: integer ierr. 00110 c*********************************************************************** 00111 subroutine ADFDEL( PID, ID, ierr ) 00112 IMPLICIT NONE 00113 real*8 PID 00114 real*8 ID 00115 integer ierr 00116 00117 call ADFDEL2( PID, ID, ierr ) 00118 return 00119 end 00120 00121 c*********************************************************************** 00122 c Rn: Garbage Collection. Redistribute data in the file to use free- 00123 c space which is not located at the end of the file. Neighboring free 00124 c spaces will be merged. Note: For better file compaction a utility 00125 c could be written to copy an ADF file, creating a new ADF file 00126 c without any wasted space. 00127 c 00128 c f77: ADFDGC( ID, ierr ) 00129 c input: real*8 ID. The ID of a node in the ADF file in which to do 00130 c garbage collection. 00131 c output: integer ierr. 00132 c*********************************************************************** 00133 subroutine ADFDGC( ID, ierr ) 00134 IMPLICIT NONE 00135 real*8 ID 00136 integer ierr 00137 00138 call ADFDGC2( ID, ierr ) 00139 return 00140 end 00141 00142 c*********************************************************************** 00143 c R1: Get the data format used in an existing database. 00144 c 00145 c f77: ADFDGF( RootID, format, ierr ) 00146 c input: real*8 RootID The rootID of the ADF file. 00147 c output: character*20 format. See format for ADFDOPN. 00148 c output: integer ierr. 00149 c*********************************************************************** 00150 subroutine ADFDGF( RootID, format, ierr ) 00151 IMPLICIT NONE 00152 real*8 RootID 00153 character*(*) format 00154 integer ierr 00155 00156 call ADFDGF2( RootID, format, LEN( format ), ierr ) 00157 return 00158 end 00159 00160 c*********************************************************************** 00161 c R1: Open a database. Open either a new or an existing ADF file. 00162 c If links to other ADF files are used, these additional files will be 00163 c opened automatically as required. 00164 c 00165 c f77: ADFDOPN( filename, status, format, rootID, ierr) 00166 c input: character*(*) filename. Not used if status SCRATCH is 00167 c used. Filename must be a legal name and may 00168 c include a relative or absolute path. It must be 00169 c directly usable by the C fopen() system 00170 c routine (no environment expansion is done). 00171 c input: character*(*) status. Like FORTRAN OPEN() status. 00172 c This field is required. Allowable values are: 00173 c READ_ONLY - File must exist. Writing NOT allowed. 00174 c OLD - File must exist. Reading and writing allowed. 00175 c NEW - File must not exist. 00176 c SCRATCH - New file. Filename is ignored. 00177 c UNKNOWN - OLD if file exists, else NEW is used. 00178 c input: character*(*) format. Specifies the numeric format for 00179 c the file. If blank, the machine's native 00180 c format is used. This field is only used when a 00181 c file is created. 00182 c NATIVE - Determine the format on the machine. If the 00183 c native format is not one of the formats 00184 c supported, the created file cannot be used on 00185 c other machines. 00186 c IEEE_BIG - Use the IEEE big ENDIAN format. 00187 c IEEE_LITTLE - Use the IEEE little ENDIAN format. 00188 c CRAY - Use the native Cray format. 00189 c output: real*8 rootID 00190 c output: integer ierr. 00191 c*********************************************************************** 00192 subroutine ADFDOPN( filename, status, format, rootID, ierr) 00193 IMPLICIT NONE 00194 character*(*) filename 00195 character*(*) status 00196 character*(*) format 00197 real*8 rootID 00198 integer ierr 00199 00200 call ADFDOP2( filename, len( filename ), status, len( status ), 00201 1 format, len( format ), rootID, ierr ) 00202 return 00203 end 00204 00205 c*********************************************************************** 00206 c R1: Set the data format used in an existing database. 00207 c Note: Use with extreme caution. Needed only 00208 c for data conversion utilities and NOT intended 00209 c for the general user!!! 00210 c 00211 c f77: ADFDSF( RootID, format, ierr ) 00212 c input: real*8 RootID The rootID if the ADF file. 00213 c input: character*(*) format. See format for ADFDOPN. 00214 c output: integer ierr. 00215 c*********************************************************************** 00216 subroutine ADFDSF( RootID, format, ierr ) 00217 IMPLICIT NONE 00218 real*8 RootID 00219 character*(*) format 00220 integer ierr 00221 00222 call ADFDSF2( RootID, format, len( format ), ierr ) 00223 return 00224 end 00225 00226 c*********************************************************************** 00227 c R1: Get ADF File Version ID. This is the version number of the ADF 00228 c library routines which created an ADF database. Modified ADF databases 00229 c will take on the version ID of the current ADF library version if 00230 c it is higher than the version indicated in the file. 00231 c The format of the version ID is: "ADF Database Version 000.01" 00232 c 00233 c f77: ADFDVER( RootID, version, cdate, mdate, ierr ) 00234 c input: real*8 RootID. The ID of the root node in the ADF file. 00235 c output: character(32) version. A 32-byte character string 00236 c containing the version ID. 00237 c output: character(32) cdate. A 32-byte character string 00238 c containing the creation date of the file. 00239 c output: character(32) mdate. A 32-byte character 00240 c string containing the last modification date of the file. 00241 c output: integer ierr. 00242 c*********************************************************************** 00243 subroutine ADFDVER( RootID, version, cdate, mdate, ierr ) 00244 IMPLICIT NONE 00245 real*8 RootID 00246 character*(*) version 00247 character*(*) cdate 00248 character*(*) mdate 00249 integer ierr 00250 00251 call ADFDVE2( RootID, version, cdate, mdate, 00252 1 len( version ), len( cdate ), len( mdate ), ierr ) 00253 return 00254 end 00255 00256 c*********************************************************************** 00257 c R1: Return Error Message. Given an ierr from an ADF routine, 00258 c get a textual description of the error. 00259 c 00260 c f77: ADFERR( ierr, errstr ) 00261 c input: integer ierr. 00262 c output: character(80) errstr. An 80-byte description of 00263 c the specified error. If the number is bad, the 00264 c string "Unknown error #nnn" is returned. 00265 c*********************************************************************** 00266 subroutine ADFERR( ierr, errstr ) 00267 IMPLICIT NONE 00268 integer ierr 00269 character*(*) errstr 00270 00271 call ADFERR2( ierr, errstr, len( errstr ) ) 00272 return 00273 end 00274 00275 c*********************************************************************** 00276 c R1: Flush data to disk. This routine is used to force any modified 00277 c information to be flushed to the physical disk. This ensures that 00278 c data will not be lost if a program aborts. This control of when to 00279 c flush all data to disk is provided to the user rather than to flush 00280 c the data every time it is modified, which would result in reduced 00281 c performance. 00282 c 00283 c f77: ADFFTD( ID, ierr ) 00284 c input: real*8 ID. The ID of a node in the ADF file in which to flush. 00285 c output: integer ierr. 00286 c*********************************************************************** 00287 subroutine ADFFTD( ID, ierr ) 00288 IMPLICIT NONE 00289 real*8 ID 00290 integer ierr 00291 00292 call ADFFTD2( ID, ierr ) 00293 return 00294 end 00295 00296 c*********************************************************************** 00297 c R1: Get Data Type. Return the 32 character string in a node's data- 00298 c type field. In C, the data-type will be null terminated after the last 00299 c non-blank character. A maximum of 33 characters may be used 00300 c (32 for the data-type plus 1 for the null). 00301 c 00302 c f77: ADFGDT( ID, dtype, ierr ) 00303 c input: real*8 ID. The ID of the node to use. 00304 c output: character*(*) dtype. The 32-character data-type of the node. 00305 c output: integer ierr. 00306 c*********************************************************************** 00307 subroutine ADFGDT( ID, dtype, ierr ) 00308 IMPLICIT NONE 00309 real*8 ID 00310 character*(*) dtype 00311 integer ierr 00312 00313 call ADFGDT2( ID, dtype, len( dtype ), ierr ) 00314 return 00315 end 00316 00317 c*********************************************************************** 00318 c R1: Get Dimension Values. Return the dimension values for a node. 00319 c Values will only be returned for the number of dimensions defined in 00320 c the node. If the number of dimensions for the node is zero, an 00321 c error is returned. 00322 c 00323 c f77: ADFGDV( ID, dvals, ierr ) 00324 c input: real*8 ID. The ID of the node to use. 00325 c output: integer dvals(12). 00326 c output: integer ierr. 00327 c*********************************************************************** 00328 subroutine ADFGDV( ID, dvals, ierr ) 00329 IMPLICIT NONE 00330 real*8 ID 00331 integer dvals(12) 00332 integer ierr 00333 00334 call ADFGDV2( ID, dvals, ierr ) 00335 return 00336 end 00337 00338 c*********************************************************************** 00339 c R1 Get Error State. Return the active error state. 00340 c 00341 c f77: ADFGES( estate, ierr ) 00342 c output: integer estate. Flag for ABORT on error (1) or return 00343 c error status (0). Set on a per database basis. 00344 c output: integer ierr. 00345 c*********************************************************************** 00346 subroutine ADFGES( estate, ierr ) 00347 IMPLICIT NONE 00348 integer estate 00349 integer ierr 00350 00351 call ADFGES2( estate, ierr ) 00352 return 00353 end 00354 00355 c*********************************************************************** 00356 c R1: Get Label. Return the 32 character string in a node's label field. 00357 c In C, the label will be null terminated after the last non-blank 00358 c character. A maximum of 33 characters may be used (32 for the 00359 c label plus 1 for the null). 00360 c 00361 c f77: ADFGLB( ID, label, ierr ) 00362 c input: real*8 ID. The ID of the node to use. 00363 c output: character*(*) label. The 32-character label of the node. 00364 c output: integer ierr. 00365 c*********************************************************************** 00366 subroutine ADFGLB( ID, label, ierr ) 00367 IMPLICIT NONE 00368 real*8 ID 00369 character*(*) label 00370 integer ierr 00371 00372 call ADFGLB2( ID, label, len( label ), ierr ) 00373 return 00374 end 00375 00376 c*********************************************************************** 00377 c R1: Get path information from a link. If the node is a link-node, 00378 c return the path information. Else, return an error. 00379 c If the link is in the same file, then a blank filename is returned. 00380 c 00381 c f77: ADFGLKP( ID, file, name, ierr ) 00382 c input: real*8 ID. The ID of the node to use. 00383 c output: character*(*) file. The filename. 00384 c output: character*(*) name. The name of node. 00385 c output: integer ierr. 00386 c*********************************************************************** 00387 subroutine ADFGLKP( ID, file, name, ierr ) 00388 IMPLICIT NONE 00389 real*8 ID 00390 character*(*) file 00391 character*(*) name 00392 integer ierr 00393 00394 call ADFGLK2( ID, file, len( file ), name, len( name ), ierr ) 00395 return 00396 end 00397 00398 c*********************************************************************** 00399 c R1: Get Name of a Node. Given a node's ID, return the 32 character 00400 c name of that node. In C, the name will be null terminated after the 00401 c last non-blank character. A maximum of 33 characters may be used 00402 c (32 for the name plus 1 for the null). 00403 c 00404 c f77: ADFGNAM( ID, name, ierr ) 00405 c input: real*8 ID. The ID of the node to use. 00406 c output: character*(*) name. The simple name of the node. 00407 c output: integer ierr. 00408 c*********************************************************************** 00409 subroutine ADFGNAM( ID, name, ierr ) 00410 IMPLICIT NONE 00411 real*8 ID 00412 character*(*) name 00413 integer ierr 00414 00415 call ADFGNA2( ID, name, len( name ), ierr ) 00416 return 00417 end 00418 00419 c*********************************************************************** 00420 c R1: Get Number of Dimensions. Return the number of data dimensions 00421 c used in a node. Valid values are from 0 to 12. 00422 c 00423 c f77: ADFGND( ID, ndims, ierr ) 00424 c input: real*8 ID. The ID of the node to use. 00425 c output: integer ndims. 00426 c output: integer ierr. 00427 c*********************************************************************** 00428 subroutine ADFGND( ID, ndims, ierr ) 00429 IMPLICIT NONE 00430 real*8 ID 00431 integer ndims 00432 integer ierr 00433 00434 call ADFGND2( ID, ndims, ierr ) 00435 return 00436 end 00437 00438 c*********************************************************************** 00439 c R1: Get Unique-Identifier of a Node. Given a parent node ID and a 00440 c a name of child node, return the ID of the child. To return the ID 00441 c of the root-node in an ADF file, use any known ID in the ADF file 00442 c and a name of "/". 00443 c 00444 c f77: ADFGNID( PID, name, ID, ierr ) 00445 c input: real*8 PID. The ID of the Node's parent. 00446 c input: character*(*) name. The name of the node. Compound 00447 c names including path information use a slash 00448 c "/" notation between node names. If a 00449 c leading slash is used, then PID can be any 00450 c valid node ID in the ADF database. 00451 c output: real*8 ID. The ID of the named node. 00452 c output: integer ierr. 00453 c*********************************************************************** 00454 subroutine ADFGNID( PID, name, ID, ierr ) 00455 IMPLICIT NONE 00456 real*8 PID 00457 character*(*) name 00458 real*8 ID 00459 integer ierr 00460 00461 call ADFGNI2( PID, name, len( name ), ID, ierr ) 00462 return 00463 end 00464 00465 c*********************************************************************** 00466 c R1: Get root-ID for an ADF system from any ID in the system. 00467 c 00468 c f77: ADFGRID( ID, RootID, ierr ) 00469 c input: real*8 ID. The ID of the node to use. 00470 c output: real*8 RootID. The ID of the root node. 00471 c output: integer ierr. 00472 c*********************************************************************** 00473 subroutine ADFGRID( ID, RootID, ierr ) 00474 IMPLICIT NONE 00475 real*8 ID 00476 real*8 RootID 00477 integer ierr 00478 00479 call ADFGRI2( ID, RootID, ierr ) 00480 return 00481 end 00482 00483 c*********************************************************************** 00484 c R1: Test if a Node is a link. If the actual data-type of the node 00485 c is "LK" (created with ADF_Link), return the link path length. 00486 c Otherwise, return 0. 00487 c 00488 c f77: ADFISLK( ID, lplen, ierr ) 00489 c input: real*8 ID. The ID of the node to use. 00490 c input: integer lplen. 0 if the node is NOT a link. If 00491 c the node is a link, the length of the path string is returned. 00492 c output: integer ierr. 00493 c*********************************************************************** 00494 subroutine ADFISLK( ID, lplen, ierr ) 00495 IMPLICIT NONE 00496 real*8 ID 00497 integer lplen 00498 integer ierr 00499 00500 call ADFISL2( ID, lplen, ierr ) 00501 return 00502 end 00503 00504 c*********************************************************************** 00505 c R1: Create a link. Note: The Node linked to does not have to exist 00506 c when the link is created (but it may exist and that is OK). However, 00507 c when the link is used, an error will occur if the linked to node does 00508 c not exist. 00509 c 00510 c f77: ADFLINK( PID, name, file, nfile, ID, ierr ) 00511 c input: real*8 PID. The ID of the Node's parent. 00512 c input: character*(*) name. The name of the link node. 00513 c input: character*(*) file. The filename to use for the link 00514 c (directly usable by a C open() routine). If 00515 c blank (null), the link will be within the same file. 00516 c input: character*(*) nfile. The name of the node which 00517 c the link will point to. This can be a simple or 00518 c compound name. 00519 c output: real*8 ID. The ID of the link-node. 00520 c output: integer ierr. 00521 c*********************************************************************** 00522 subroutine ADFLINK( PID, name, file, nfile, ID, ierr ) 00523 IMPLICIT NONE 00524 real*8 PID 00525 character*(*) name 00526 character*(*) file 00527 character*(*) nfile 00528 real*8 ID 00529 integer ierr 00530 00531 call ADFLIN2( PID, name, file, nfile, len( name ), 00532 1 len( file ), len( nfile ), ID, ierr ) 00533 return 00534 end 00535 00536 c*********************************************************************** 00537 c R1: Get ADF Library Version ID. This is the version number of the 00538 c ADF library routines which your program is currently using. 00539 c The format of the version ID is: "ADF Library Version 000.01" 00540 c Note: There is a double space between Library and Version. This 00541 c lines up the number with the Database Version string. 00542 c 00543 c f77: ADFLVER( version, ierr ) 00544 c output: character(32) version. A 32-byte character string 00545 c containing the ADF Library version ID information. 00546 c output: integer ierr. 00547 c*********************************************************************** 00548 subroutine ADFLVER( version, ierr ) 00549 IMPLICIT NONE 00550 character*(*) version 00551 integer ierr 00552 00553 call ADFLVE2( version, len( version ), ierr ) 00554 return 00555 end 00556 00557 c*********************************************************************** 00558 c R2: Change Parent (move a Child Node). The node and the 2 parents 00559 c must all exist within a single ADF file. If the node is pointed to 00560 c by a link-node, changing the node's parent will break the link. 00561 c 00562 c f77: ADFMOVE( PID, ID, NPID, ierr ) 00563 c input: real*8 PID. The ID of the Node's parent. 00564 c input: real*8 ID. The ID of the node to use. 00565 c input: real*8 NPID. The ID of the Node's New Parent 00566 c output: integer ierr. 00567 c*********************************************************************** 00568 subroutine ADFMOVE( PID, ID, NPID, ierr ) 00569 IMPLICIT NONE 00570 real*8 PID 00571 real*8 ID 00572 real*8 NPID 00573 integer ierr 00574 00575 call ADFMOV2( PID, ID, NPID, ierr ) 00576 return 00577 end 00578 00579 c*********************************************************************** 00580 c R1: Get Number of Children of a Node. Return the number of children 00581 c nodes directly associated with a parent node. 00582 c 00583 c f77: ADFNCLD( ID, numcld, ierr ) 00584 c input: real*8 ID. The ID of the node to use. 00585 c output: integer numcld. The number of children directly 00586 c associated with this node. 00587 c output: integer ierr. 00588 c*********************************************************************** 00589 subroutine ADFNCLD( ID, numcld, ierr ) 00590 IMPLICIT NONE 00591 real*8 ID 00592 integer numcld 00593 integer ierr 00594 00595 call ADFNCL2( ID, numcld, ierr ) 00596 return 00597 end 00598 00599 c*********************************************************************** 00600 c R1: Set/change the data-type and Dimension Information of a Node. 00601 c Valid user-definable data-types are: 00602 c 00603 c No data MT 00604 c Integer 32 I4 00605 c Integer 64 I8 00606 c Unsigned Int 32 U4 00607 c Unsigned Int 64 U8 00608 c Real 32 R4 00609 c Real 64 R8 00610 c Complex 64 X4 00611 c Complex 128 X8 00612 c Character (unsigned byte) C1 00613 c Byte (unsigned byte) B1 00614 c Compound data-types can be used which combine types 00615 c ("I4,I4,R8"), define an array ("I4[25]"), or a combination of these 00616 c ("I4,C1[20],R8[3]"). 00617 c dims can be a number from 0 to 12. 00618 c dim_vals is an array of integers. The number of integers used is 00619 c determined by the dims argument. If dims is zero, the dim_values 00620 c are not used. Valid range for dim_values are from 1 to 00621 c 2,147,483,648. The total data size, calculated by the data-type-size 00622 c times the dimension value(s), cannot exceed 2,147,483,648. 00623 c Note: When this routine is called and the data-type or the 00624 c number of dimensions changes, any data currently associated 00625 c with the node is lost!! The dimension values can be changed and 00626 c the data space will be extended as needed. 00627 c- 00628 c f77: ADFPDIM( ID, dtype, dims, dvals, ierr) 00629 c input: real*8 ID. The ID of the node. 00630 c input: character*(*) dtype. 00631 c input: integer dims. The number of dimensions this node has. 00632 c input: integer dvals(12). The dimension values for this node. 00633 c output: integer ierr. 00634 c*********************************************************************** 00635 subroutine ADFPDIM( ID, dtype, dims, dvals, ierr) 00636 IMPLICIT NONE 00637 real*8 ID 00638 character*(*) dtype 00639 integer dims 00640 integer dvals(12) 00641 integer ierr 00642 00643 call ADFPDI2( ID, dtype, len( dtype ), dims, dvals, ierr) 00644 return 00645 end 00646 00647 c*********************************************************************** 00648 c R2: Put (change) Name of a Node. Warning: If the node is pointed 00649 c to by a link-node, changing the node's name will break the link. 00650 c 00651 c f77: ADFPNAM( PID, ID, name, ierr ) 00652 c input: real*8 PID. The ID of the Node's parent. 00653 c input: real*8 ID. The ID of the node to use. 00654 c input: character*(*) name. The new name of the node. 00655 c output: integer ierr. 00656 c*********************************************************************** 00657 subroutine ADFPNAM( PID, ID, name, ierr ) 00658 IMPLICIT NONE 00659 real*8 PID 00660 real*8 ID 00661 character*(*) name 00662 integer ierr 00663 00664 call ADFPNA2( PID, ID, name, len( name ), ierr ) 00665 return 00666 end 00667 00668 c*********************************************************************** 00669 c R1 Set Error State. For all ADF calls, set the error handling 00670 c convention; either return error codes, or abort the program on an error. 00671 c The default state for the ADF interface is to return error codes and NOT 00672 c abort. 00673 c 00674 c f77: ADFSES( estate, ierr ) 00675 c input: integer estate. Flag for ABORT on error (1) or return 00676 c error status (0). Set on a per database basis. 00677 c output: integer ierr. 00678 c*********************************************************************** 00679 subroutine ADFSES( estate, ierr ) 00680 IMPLICIT NONE 00681 integer estate 00682 integer ierr 00683 00684 call ADFSES2( estate, ierr ) 00685 return 00686 end 00687 00688 c*********************************************************************** 00689 c R1: Set Label. Set the 32 character string in a node's label field. 00690 c 00691 c f77: ADFSLB( ID, label, ierr ) 00692 c input: real*8 ID. The ID of the node to use. 00693 c input: character*(*) label. The 32-character label of the node. 00694 c output: integer ierr. 00695 c*********************************************************************** 00696 subroutine ADFSLB( ID, label, ierr ) 00697 IMPLICIT NONE 00698 real*8 ID 00699 character*(*) label 00700 integer ierr 00701 00702 call ADFSLB2( ID, label, len( label ), ierr ) 00703 return 00704 end