OpenCOBOL Manual †

===========================================================

Noticias de última hora: 23 de enero 2010

Gary Cutler ha publicado un impresionante Guía del OpenCOBOL programador .

http://opencobol.add1tocobol.com/OpenCOBOL% 20Programmers% 20Guide.pdf (3.3M)

Documentos 1.1pre versión-lanzamiento de OpenCOBOL con algunas grandes ideas y detalles

COBOL.

Impresionante.

===========================================================

OpenCOBOL es un código abierto de COBOL, que traduce los programas COBOL con el código C
y lo compila con el compilador C nativo.

Este manual corresponde a OpenCOBOL 1,0 (espero).

 UserManual / 1
 Introducción
 Hello World!
 UserManual/2_1
 Compilar
 Opciones del compilador
 Construir Target
 Formato Fuente
 Opciones de advertencia
 UserManual/2_2
 Múltiples fuentes
 Vinculación estática
 Enlazado dinámico
 Edificio de la Biblioteca
 Usando Biblioteca
 UserManual/2_3
 C Interface
 Programa Principal C
 Estático C a COBOL
 Dinámica C a COBOL
 COBOL estático para C
 Dinámica COBOL a C
 UserManual / 3
 Personalizar
 Personalizar Compilador
 Personalización de Biblioteca
 UserManual / 4
 Optimizar
 Opciones Optimizar
 Optimizar Llame
 Optimizar Binary
 UserManual / 5
  Depurar
Opciones de depuración
 UserManual / copia
 Manual OpenCOBOL
Introducción †

Hello World! †

Este es un programa de ejemplo que muestra "Hello World":

El I de identificación debe estar en la columna 8 (7 espacios antes).

---- Hello.cob -------------------------

* Programa COBOL de ejemplo
DIVISIÓN DE IDENTIFICACIÓN.
PROGRAMA-ID. hola.
PROCEDURE DIVISION.
DISPLAY "Hello World!".
PARADA ejecución.
----------------------------------------

El compilador es COBC, que se ejecuta de la siguiente manera:

$ COBC-x hello.cob
$. / Hola
Hello World!

El nombre del archivo ejecutable (es decir, hola en este caso) se determina mediante la
eliminación de la extensión del nombre de archivo fuente.

Se puede especificar el nombre del archivo ejecutable, especificando la opción de compilador-o

de la siguiente manera:

$ COBC-o hola-mundo hello.cob

$. / Hola-mundo
Hello World!
Compilar †

En este capítulo se describe cómo compilar programas COBOL utilizando OpenCOBOL.

Opciones del compilador †

El compilador COBC acepta las opciones descritas en esta sección.

Construir Target †

Las siguientes opciones especifican el tipo de destino producida por el compilador:

-E

Sólo preproceso. Se ejecutan las directivas del compilador. Se eliminan líneas de

comentario. Sentencias COPY se expanden. La salida va a la norma-out.

-C

Traducción solamente. Archivos de código fuente COBOL se convierten en archivos de

C. La salida se guarda en el archivo *. C.

-S

Recopilar solamente. Archivos traducidos C son compilados por cc. La salida se guarda
en el archivo *. S.

-C

Compilar y ensamblar. Esto es equivalente a cc-c. La salida se guarda en el archivo *. O.

-M

Compilar, ensamblar y construir un módulo dinámico de enlaces (es decir, una biblioteca
compartida). La salida se guarda en el archivo *. Así. (Por defecto)

-X

Compilar, ensamblar y construir un ejecutable.

Sin ningún tipo de opciones anteriores, el compilador intenta construir un módulo.

Si usted le da la opción-x con-C, verá la función principal en el archivo C generado.

Formato Fuente †

OpenCOBOL apoya tanto fijos como formato de código libre.

El formato por defecto es el formato fijo. Esto puede ser explícitamente sobrescritos por una de
las siguientes opciones:
 Libres

Formato libre.

-Fijado

Formato fijo.
↑

Opciones advertencia †

-Wall

Habilitar todas las advertencias

-Wcolumn-overflow

Advierta a cualquier texto después de la columna 72

-Wend a evaluar

Avisar carece de FIN-EVALUAR

-Wend-si

Warn carece de END-IF

-Wparentheses

Warn carece de paréntesis, alrededor y dentro de O

Múltiples fuentes †

Un programa consiste a menudo en varios archivos de código fuente. En esta sección se describe
cómo compilar varios archivos de origen.

En esta sección también se describe cómo crear una biblioteca compartida que puede ser
utilizado por todos los programas COBOL y cómo usar librerías externas de los programas
COBOL.

Vinculación estática †

La forma más fácil de combinar varios archivos es compilar en un solo ejecutable.

Recopilar todos los archivos con la opción-c, y vincularlos al final. El programa de nivel superior
se debe compilar con la opción-fmain:

$ COBC-c subr1.cob
$ COBC-c subr2.cob
$ COBC-c-fmain main.cob
$ COBC-o prog main.o subr1.o subr2.o

Puede enlazar rutinas C, así:

$ Cc-c subrs.c
$ COBC-c-fmain main.cob
$ COBC-o prog main.o subrs.o

Cualquier número de funciones puede estar contenida en un solo archivo de C.

Los programas vinculados serán llamados dinámicamente, es decir, el símbolo se resolverá en

tiempo de ejecución. Por ejemplo, la siguiente instrucción COBOL

LLAME "subr" USO X.

se convertirá en un código de C equivalente así:

int (* func) () = cob_resolve ("subr");

if (fun! = NULL)
func (X);

Con el compilador opciones Finicial de guardia, un código más eficiente será generado de esta
manera:

subr (X);
Tenga en cuenta que esta opción sólo es eficaz cuando la llamada nombre del programa es un
literal (como CALL "subr."). Con un nombre de datos (como SUBR CALL.), El programa todavía
se llama dinámica.

La vinculación dinámica †

El programa principal y subprogramas se pueden compilar por separado.

El programa principal está compilado como siempre:

$ COBC-x main.cob

Los subprogramas se compilan con la opción-m:

$ COBC-m subr.cob

Esto crea un archivo de módulo subr.so (La extensión varía en función de su anfitrión.).

Antes de ejecutar el programa principal, instale los archivos de módulo en el directorio de la

biblioteca:

$ Cp subr.so / su / cobol / lib

Ahora, la variable de entorno COB_LIBRARY_PATH a su directorio de la librería, y ejecutar el

programa principal:

$ Export COB_LIBRARY_PATH = / su / cobol / lib

$. / Main
↑

Library Building †

Usted puede construir una biblioteca compartida mediante la combinación de varios programas
COBOL y hasta rutinas de C:

$ COBC-c subr1.cob
$ COBC-c subr2.cob
$ Cc-c subr3.c
$ Cc-shared-o libsubrs.so subr1.o subr2.o subr3.o
↑

Usando Biblioteca †

Puede utilizar una biblioteca compartida, relacionándola con su programa principal.

Antes de vincular la biblioteca, se debe instalar en el directorio de biblioteca del sistema:

 $ Cp libsubrs.so / usr / lib

o instalarlo en otro lugar y establecer LD_LIBRARY_PATH:

$ Cp libsubrs.so / su / cobol / lib

$ Export LD_LIBRARY_PATH = / su / cobol / lib

A continuación, compilar el programa principal, que une la biblioteca de la siguiente manera:

$ COBC main.cob -L/your/cobol/lib-lsubrs

Múltiples fuentes †

Un programa consiste a menudo en varios archivos de código fuente. En esta sección se describe
cómo compilar varios archivos de origen.

En esta sección también se describe cómo crear una biblioteca compartida que puede ser
utilizado por todos los programas COBOL y cómo usar librerías externas de los programas
COBOL.

Vinculación estática †

La forma más fácil de combinar varios archivos es compilar en un solo ejecutable.

Recopilar todos los archivos con la opción-c, y vincularlos al final. El programa de nivel superior
se debe compilar con la opción-fmain:

$ COBC-c subr1.cob
$ COBC-c subr2.cob
$ COBC-c-fmain main.cob
$ COBC-o prog main.o subr1.o subr2.o

Puede enlazar rutinas C, así:

$ Cc-c subrs.c
$ COBC-c-fmain main.cob
$ COBC-o prog main.o subrs.o

Cualquier número de funciones puede estar contenida en un solo archivo de C.

Los programas vinculados serán llamados dinámicamente, es decir, el símbolo se resolverá en

tiempo de ejecución. Por ejemplo, la siguiente instrucción COBOL

LLAME "subr" USO X.

se convertirá en un código de C equivalente así:

 int (* func) () = cob_resolve ("subr");
if (fun! = NULL)
func (X);

Con el compilador opciones Finicial de guardia, un código más eficiente será generado de esta
manera:

subr (X);

Tenga en cuenta que esta opción sólo es eficaz cuando la llamada nombre del programa es un
literal (como CALL "subr."). Con un nombre de datos (como SUBR CALL.), El programa todavía
se llama dinámica.

La vinculación dinámica †

El programa principal y subprogramas se pueden compilar por separado.

El programa principal está compilado como siempre:

$ COBC-x main.cob

Los subprogramas se compilan con la opción-m:

$ COBC-m subr.cob

Esto crea un archivo de módulo subr.so (La extensión varía en función de su anfitrión.).

Antes de ejecutar el programa principal, instale los archivos de módulo en el directorio de la

biblioteca:

$ Cp subr.so / su / cobol / lib

Ahora, la variable de entorno COB_LIBRARY_PATH a su directorio de la librería, y ejecutar el

programa principal:

$ Export COB_LIBRARY_PATH = / su / cobol / lib

$. / Main
↑

Library Building †

Usted puede construir una biblioteca compartida mediante la combinación de varios programas
COBOL y hasta rutinas de C:

$ COBC-c subr1.cob
$ COBC-c subr2.cob
 $ Cc-c subr3.c
$ Cc-shared-o libsubrs.so subr1.o subr2.o subr3.o
↑

Usando Biblioteca †

Puede utilizar una biblioteca compartida, relacionándola con su programa principal.

Antes de vincular la biblioteca, se debe instalar en el directorio de biblioteca del sistema:

$ Cp libsubrs.so / usr / lib

o instalarlo en otro lugar y establecer LD_LIBRARY_PATH:

$ Cp libsubrs.so / su / cobol / lib

$ Export LD_LIBRARY_PATH = / su / cobol / lib

A continuación, compilar el programa principal, que une la biblioteca de la siguiente manera:

$ COBC main.cob -L/your/cobol/lib-lsubrs

C Interface †

En este capítulo se describe cómo combinar los programas en C con programas COBOL.

Programa Principal C †

Incluya libcob.h en su programa de C. Llame cob_init antes de usar cualquier módulo COBOL:

# Include <libcob.h>

int
main (int argc, char ** argv)
{
/ * Inicializar el programa * /
...

/ * Inicializar la biblioteca de tiempo de ejecución COBOL * /

cob_init (argc, argv);

/ * Resto del programa * /

...
}

Puedes escribir cobc_init (0, NULL), y si usted no desea pasar argumentos de línea de comandos
para COBOL.

El cob_set_library_path función sobrescribirá la configuración de usuario de la variable de

entorno COB_LIBRARY_PATH.

Usted puede compilar su programa en C de la siguiente manera:

$ Cc-c `cob-config - cflags` main.c

El objeto compilado debe estar vinculada con libcob la siguiente manera:

$ Cc-o principales main.o `cob-config - libs`

↑

Estático C a COBOL †

Digamos que el módulo COBOL siguiente de un programa en C:

---- Say.cob ---------------------------

DIVISIÓN DE IDENTIFICACIÓN.
PROGRAMA-ID. decir.
División de Medio Ambiente.
DIVISION DE DATOS.
VINCULACIÓN SECCIÓN.
01 HOLA PIC X (6).
01 MUNDO PIC X (6).
 DIVISIÓN DE PROCEDIMIENTO DE USAR EL MUNDO HOLA.
DISPLAY HELLO WORLD.
Salir del programa.
----------------------------------------

Recuerde que el código tiene que empezar en la columna 9.

Este programa acepta dos argumentos, los muestra, y salir.

Desde el punto de vista de C, esto es equivalente a una función que tiene la siguiente prototipo:

extern int decir (char * hola, mundo char *);

Por lo tanto, el programa principal se verá como la siguiente:

---- Hello.c ---------------------------

# Include <stdio.h>
# Include <libcob.h>

extern int decir (char * hola, mundo char *);

int
main ()
{
int ret;
carbón hola [6] = "Hola";
Char mundo [6] = "Mundo";

cob_init (0, NULL);

ret = decir (hola mundo);

volver ret;
}
----------------------------------------

Recopilar estos programas, a saber:

$ Cc-c `cob-config - cflags` hello.c

$ Say.cob COBC-c-estática
$ COBC-x-o hola hello.o say.o
$. / Hola
Hello World!
↑

Dinámica C para COBOL †

Usted puede encontrar un módulo COBOL tener un programa de identificación específica

utilizando un cob_resolve función C, que toma el nombre del módulo como una cadena y
devuelve un puntero a la función del módulo.

cob_resolve devuelve NULL si no hay ningún módulo. En este caso, la cob_resolve_error función
devuelve el mensaje de error.
Vamos a ver un ejemplo:

---- Hola-dynamic.c -------------------

# Include <stdio.h>
# Include <stdlib.h>
# Include <libcob.h>

static int (* digamos) (char * hola, mundo char *);

int
main ()
{
int ret;
carbón hola [6] = "Hola";
Char mundo [6] = "Mundo";

cob_init (0, NULL);

/ * Encontrar el módulo con PROGRAM-ID "decir". * /

decir = cob_resolve ("palabra");

/ * Si no existe tal módulo, muestra el error y la salida * /

if (decir == NULL) {
fprintf (stderr, "% s \ n", cob_resolve_error ());
exit (1);
}

/ * Llamada al módulo encontrado y salir con el código de retorno * /

ret = decir (hola mundo);

volver ret;
}
----------------------------------------

Recopilar estos programas, a saber:

$ Cc-c `cob-config - cflags` hola-dynamic.c

$ COBC-x-o hello hello-dynamic.o
$ COBC-m say.cob
$ Export COB_LIBRARY_PATH =.
$. / Hola
Hello World!
↑

COBOL estático para C †

Vamos a llamar a la siguiente función C de COBOL:

---- Say.c -----------------------------

# Include <stdio.h>
int
decir (char * hola, char * mundo)
{
int i;
for (i = 0; i <6, i + +)
putchar (hola [i]);
for (i = 0; i <6, i + +)
putchar (mundo [i]);
 putchar ('\ n');
return 0;
}
----------------------------------------

Este programa es equivalente a la say.cob anterior.

Tenga en cuenta que, a diferencia de C, los argumentos que se pasan de los programas COBOL
no se terminan con el carácter nulo (es decir, \ 0).

Si quieres llamarlo en ambientes WIN nativos (no hace daño si lo hace en todos los casos) el
código debe ser cambiado a

---- Say.c -----------------------------

# Include <stdio.h>
# Ifndef C_EXTERN
# If defined (_WIN32) | | define (__CYGWIN__)
# Define C_EXTERN __ declspec extern (dllexport)
# Else
# Define extern C_EXTERN
# Endif
# Endif
C_EXTERN int
decir (char * hola, char * mundo)
{
int i;
for (i = 0; i <6, i + +)
putchar (hola [i]);
for (i = 0; i <6, i + +)
putchar (mundo [i]);
putchar ('\ n');
return 0;
}
----------------------------------------

Usted puede llamar a esta función de la misma manera que llame programas COBOL:

---- Hello.cob -------------------------

DIVISIÓN DE IDENTIFICACIÓN.
PROGRAMA-ID. hola.
División de Medio Ambiente.
DIVISION DE DATOS.
WORKING-STORAGE SECTION.
01 HOLA PIC X (6) VALOR "Hello".
01 MUNDO PIC X (6) VALOR "World".
PROCEDURE DIVISION.
LLAME "decir" usar HELLO WORLD.
PARADA ejecución.
----------------------------------------

Recopilar estos programas, a saber:

$ Cc-c say.c
$ COBC-c-static-fmain hello.cob => desde OC 1.0: (. Fmain archivo está
obsoleto cf NEWS) no se debe hacer
 $ COBC-x-o hola hello.o say.o => desde OC 1.0: $ COBC-x-o hola hello.cob
say.o
$. / Hola
Hello World!
↑

Dinámica COBOL a C †

Usted puede crear un módulo dinámico de enlaces desde un programa C pasando una opción
común para el compilador de C:

$ Cc-shared-o say.so say.c

$ COBC-x-o hola hello.cob
$ Export COB_LIBRARY_PATH =.
$. / Hola
Hello World!
Personalizar †

Personalizar Compilador †

Estos ajustes son efectivos en tiempo de compilación.

Las variables de entorno (valor por defecto):

COB_CC

Compilador de C ("gcc")

COB_CFLAGS

Banderas pasan al compilador de C ("-I $ (prefijo) / include")

COB_LDFLAGS

Banderas pasan al compilador de C ("")

COB_LIBS

Bibliotecas estándar vinculados con el programa ("-L $ (prefijo) / lib-LCOB")

COB_LDADD

Bibliotecas adicionales relacionados con el programa ("")

↑

Personalizar Biblioteca †

Estos ajustes son efectivos en tiempo de ejecución.

Las variables de entorno (valor por defecto):

COB_LIBRARY_PATH

Dinámica de enlaces vía módulo (":. $ (Prefijo) / lib / open-cobol")

Optimizar †
 ↑

Optimizar Opciones †

Hay dos opciones de compilador de optimización:-O y O2. Estas opciones permiten a los niveles
de compilación (C hasta el montaje).

La opción-O o-O2 se pasa al compilador de C como es y utilizados para la optimización de nivel C.

Optimizar Llame †

Cuando se ejecuta una instrucción CALL, el programa llamado se vincula en tiempo de ejecución. Al
especificar la opción de compilador-Finicial-llamada, puede enlazar estáticamente el programa en
tiempo de compilación y llame de manera eficiente. (Consulte Vinculación estática)

Optimizar Binary †

De forma predeterminada, los elementos de datos de BINARIO uso o COMP se almacenan en

formato big-endian. En las máquinas cuya orden de bytes nativo es little-endian, no es
eficiente. Considere cambiar PIC a COMP-5 o al uso BINARIO-xxx 2002 estándar, en el que xxx es
CHAR de 1 byte, short de 2 bytes, LONG de 4 bytes y dobles (sic) de 8 bytes.

Además, el establecimiento de la opción binaria de tamaño a 2-4-8 o 1-2-4-8 es más eficaz que
otros.

Depurar †

Depurar Opciones †

La opción de compilador-debug se puede utilizar durante el desarrollo de sus programas. Permite

que todos la comprobación de errores en tiempo de ejecución, como subíndice controles de
frontera y controles de datos numéricos, y muestra los errores en tiempo de ejecución con los
lugares de origen.

La opción de compilador-g incluye directivas de línea en la salida. Esto ayuda a depurar sus
programas COBOL utilizando "gdb".