Micro Focus Studio Enterprise Edition for UNIX > Programming > Data Access > File Handling > File Handling Guide > File Organizations > The Library Command Line Interface > Accessing Files in Libraries

Accessing Files in Libraries

The following program operations obtain access to files in libraries:

Calling a library opening routine.
Calling a program.
Using a COPY statement at compilation time.

Files within libraries can be found only if the library is open. There are several ways to open a library:

Calling program-name.
Calling a filename without an extension causes all libraries currently opened to be searched for a program of that name. If the program is not found, and a library of that name exists, that library is opened. The program of that name within that library is run.

For example, if a library contains the program myprog.gnt, the root name of the library is also myprog, and there is no program outside of the library with the same name, then a CALL to myprog causes the library to be opened.

The library is left open, so it is added to the list of libraries which will be searched in a future CALL statement.
Calling library-name.lbr.
This opens library-name.lbr. It loads the catalog of the library into memory, thus making all the files and entry points that it contains available to the program.

The Directory Facility provides options for calling and canceling libraries explicitly. This can be useful during development and testing. See the chapter Directory Facility for details.
Using a COPY statement. For example,
```
copy "textname.ext" of "library-name.lbr"
```
This opens library-name.lbr, reads textname.ext from it, and depending on the CANCELLBR directive, leaves it open for the rest of the compilation, so that the OF phrase can be omitted from the following COPY statements. See the topic CANCELLBR for information on CANCELLBR.

If the program is compiled with the COPYLBR directive, then:
```
copy "textname.ext" of "library-name"
```
is equivalent to the above, since this directive tells the Compiler that the name after OF in a COPY statement is a library-name, not a path.
Opening a file using a filename of the following form:
```
path/library-name.lbr/filename.ext
```
This opens library-name.lbr on path and takes filename.ext from it. If the library does not exist or does not contain the file, a file not found error is returned.

Note:

If you create a library while working in 64-bit mode, the library cannot be used by the 32-bit version of Library, nor by a 32-bit application. Similarly, a 32-bit library file, created in 32-bit mode or using an earlier version of Server Express or Object COBOL Developer Suite, cannot be used by the 64-bit version of Library, nor by a 64-bit application.
Attempting to open a library that is already open has no effect.
If you open a data file for input, and do not specify a device, all libraries currently open are searched. If you do specify a device, that device only is searched; libraries are not searched. This applies both to files declared using COBOL syntax and to byte-stream files (see the chapter Byte-stream File Handling in your Library Routines).
If multiple libraries are called, and each library contains a program of the same name, if that program is subsequently called, the copy of the program in the last library called is loaded and run. For example, if you call liba.lbr, libb.lbr, and libc.lbr, all of which contain the program myprog.gnt, and then call myprog.gnt, the copy in libc.lbr is loaded and run.
However, we strongly recommend that your applications are not designed to depend upon this behavior.
Once open, a library file remains open until it is canceled by the statement:
```
cancel "library-name.lbr" 
```
or a STOP RUN is executed. If any programs from the library file are in memory when the library file is canceled they remain in memory until they too are canceled.
If any programs in the library file have been called, and the library file is then canceled, load failures may result if the run-time system has to remove the called program from memory and then has to reload it. As the library file has been canceled, the run-time system is not able to find the program.
This restriction also applies to data files which reside in library files. If you cancel a library file that contains a data file which is currently open, and perform further file operations on that file, the results are unpredictable.