Opciones del Compilador

Opciones del Compilador


Description


Invocando al compilador Harbour:
===============================

harbour <archivo[.prg]> [opciones]
or
harbour [opciones] <archivo[.prg]>
or
harbour [opciones] <archivo[.prg]> [opciones]


Las opciones de la línea de comandos debe ser separada, al menos por un espacio en blanco.
Las opciones pueden comenzar con el carácter '/' ó '-',

Opciones de la línea de comandos de:
====================================

/a Declaración Automática de memvar
-----------------
Esto causa que todas las variables declaradas por las sentencias PARAMETER, PRIVATE ó PUBLIC sean automáticamente declaradas como variables MEMVAR.

/b Información de depuración (Bug)
-----------------
El compilador genera toda la información requerida para depuración

/d<id>[=<val>] #define <id>
-----------------

/es[<nivel>] establece la Severidad de la salida (Exit Severity)
-----------------

/es or /es0 - Todas las advertencias son ignoradas y el código de salida retornado por el compilador (accedido por el comando de DOS ERRORLEVEL) es igual a cero si no hay errores en el archivo fuente compilado.
/es1 - Cualquier advertencia genera un código de salida distinto de cero, pero la salida es aún creada.
/es2 - Cualquier advertencia es tratada como error y ningún archivo de salida es creado. El código de salida es establecido a un valor distinto de cero.

/g<tipo> Generación del tipo de archivo de salida <type>
-----------------

/gc tipo de salida: fuente de lenguaje C (.c) (defecto)
/gf tipo de salida: Windows/DOS OBJ32 (.obj)
/gh tipo de salida: Objeto Portable de Harbour (.hrb)
/gj tipo de salida: fuente de Java (.java)
/gp tipo de salida: fuente de Pascal (.pas)
/gr tipo de salida: recursos de Windows (.rc)

/i<ruta> agrega la ruta de búsqueda de archivos #Include
-----------------

/l suprime la información del número de Línea
-----------------
El compilador no genera el número de línea del código fuente en el archivo de salida. La función PROCLINE() retornará cero para los módulos compilados usando esta opción.

/m compilar el Módulo actual solamente
-----------------

/n sin procedimiento de inicio implícito
-----------------
El compilador no crea un procedimiento con el mismo nombre que el del archivo compilado. Esto significa que algunas declaraciones puestas antes de la primera sentencia de PROCEDURE ó FUNCTION tienen el alcance del archivo y pueden ser accedidas/usadas en todas las funciones/procedimientos definidos en el archivo fuente compilado. Todas las sentencias ejecutables puestas al principio del archivo y antes de la primera sentencia de PROCEDURE ó FUNCTION son ignoradas.

/o<ruta> unidad de disco y/o ruta para el archivo de salida
-----------------

/p genera un archivo de salida Pre-procesada (.ppo)
-----------------
El compilador solamente crea el archivo que contiene el resultado del archivo fuente pre-procesado.

/q Quieto
-----------------
El compilador no imprime ningún mensaje durante la compilación (excepto la información del copyright).

/q0 que permanezca realmente Quieto y no muestre ni siquiera la información del copyright.

/r[<libreria>] solicita al linker Revisar por <libreria> (ó ninguna)
-----------------
Actualmente no soportado en Harbour.

/s solo chequeo de Sintaxis.
-----------------
El compilador chequea la sintaxis solamente. Ningún archivo de salida es generado.

/t<ruta> ruta para la creación de un archivo Temporario
-----------------
Actualmente no usado en harbour (El compilador de harbour no crea ningún archivo temporal)

/u[<archivo>] Usar la definición de comando establecido en el <archivo> (ó ninguno)
-----------------
Aún no soportado.

/v las Variables son asumidas como M->
-----------------
Todas las variables sin declarar ó unaliased son asumidas como variables MEMVAR (variables privadas ó públicas). si este switch no es usado entones el alcance de estas variables es chequeado en tiempo de ejecución.

/w[<nivel>] Establece el número de nivel de las advertencias (Warnings) (0..4, por defecto es 1)
-----------------

/w0 - sin advertencias
/w or /w1 - advertencias compatibles con Clipper
/w2 - algunas advertencias útiles ausentes en Clipper
/w3 - advertencias generadas para extensiones al lenguaje hechas en Harbour. También habilita el chequeo de sintaxis fuertemente tipeada pero sólo advierte contra los tipos declarados, o los tipos que pueden ser calculados en tiempo de compilación.
/w4 - habilita advertencias acerca de operaciones que son sospechosas, lo cual significa que si se mezclan tipos sin declarar ó tipos que no pueden ser calculados en tiempo de compilación, junto con los tipos ya declarados, una advertencia será generada.

/x[<prefijo>] establece el símbolo del prefijo agregado al nombre de función (para archivo.c solamente)
-----------------
Establece el símbolo del prefijo agregado al nombre de función de inicio (en la salida de lenguaje C, actualmente). Esta función es generada automáticamente para cada módulo de PRG compilado. Este prefijo adicional puede ser usado para suprimir problemas con símbolos duplicados durante el enlazado de una aplicación (linking) con alguna librería de terceros.

/y seguimiento de la actividad de Lex & Yacc
-----------------
El compilador Harbour usa las utilidades FLEX y YACC para analizar el código fuente y generar el archivo de salida requerido. Esta opción sigue la actividad de esas utilidades.

/z suprime el cortocircuito lógico (.and. y .or.)
-----------------

/10 restringe la longitud de símbolos a 10 caracteres.
-----------------
Todos los nombres de variables y de funciones son cortados a un máximo de 10 caracteres.


Compilación en modo lote (batch).
================================

@<archivo> compila la lista de módulos en el <archivo>
-----------------
No soportado aún.



Conocidas incompatibilidades entre compiladores harbour y clipper
=================================================================

NOTE:
Si desea librerías de compilación y ejecución 100 % compatibles, entonces Ud. debe definir: HARBOUR_STRICT_CLIPPER_COMPATIBILITY. Esta opción debe ser definida en el archvivo ../include/hbsetup.h (en efecto esta opción es puesta en un comentario por defecto - Ud. necesita remover los caracteres /* */ solamente. Este cambio debe ser realizado antes de invocar la utilidad make.


Manejo de variables sin declarar
--------------------------------
Cuando un valor es asignado a una variable no declarada y la opción -v de la línea de comandos no es usada, entonces el compilador Clipper asume que la variable es una variable PRIVATE ó PUBLIC y genera un opcode POPM (pop memvar).

Cuando el valor de una variable no declarada es accedido y la opción -v de la línea de comandos no es usada, el compilador Harbour genera un opcode PUSHV (push variable) para determinar el tipo de variable en tiempo de ejecución

Si un campo con el nombre requerido existe en el area de trabajo actual, entonces este valor es usado. Si no existe el campo, entones una variable PRIVATE ó PUBLIC es usada (si existe).

El compilador Harbour genera un opcode para determinar el tipo de variable en tiempo de ejecución (POPVARIABLE or PUSHVARIABLE) en ambos casos (asignación y acceso).

La diferencia puede ser chequeada por el siguiente código:

PROCEDURE MAIN() PRIVATE myname DBCREATE( "TEST", { { "MYNAME", "C", 10, 0} } ) USE test NEW SELECT test APPEND BLANK FIELD->myname := "FIELD" MEMVAR->myname := "MEMVAR" myname := myname + " assigned" // In Clipper: "FIELD", In Harbour: "FIELD assigned" ? FIELD->myname // In Clipper: "MEMVAR assigned", In Harbour: "MEMVAR" ? MEMVAR->myname USE RETURN

Pasando por refeerencia una variable no declarada
-------------------------------------------------
El compilador Harbour usa un opcode especial PUSHP para pasar una referencia a una variable no declarada ( el operador '@' ). El tipo de la variable pasada es chequeada en tiempo de ejecución (field or memvar). Sin embargo las variables de campo no pueden ser pasadas por referencia. Esto significa que Clipper chequea sólo la variable memvar y no mira por una de campo. Esta es la razón por la cual el compilador Harbour usa el opcode habitual PUSHMEMVARREF en estos casos. Nótese que el comportamiento en tiempo de ejecución es el mismo en Clipper y en Harbour - sólo los opcodes generados son diferentes.


Manejo de mensajes a objetos
----------------------------

El seteo de HARBOUR_STRICT_CLIPPER_COMPATIBILITY determina la forma en que el envío encadenado de mensajes es manejado

Por ejemplo, el siguiente código:

a:b( COUNT() ):c += 1

será manejado como:

a:b( COUNT() ):c := a:b( COUNT() ):c + 1
en modo de compatibilidad estricta y

temp := a:b( COUNT() ), temp:c += 1
en modo no-estricto.

En la práctica, Clipper llamará a la función COUNT() dos veces: La primera vez antes de la adición y la segunda después de la adición. En Harbour, COUNT() será llamada sólo una vez, antes de la adición.

El método Harbour (no-estricto) es:
1) Más rápido
2) Garantiza que la misma variable de instancia del mismo objeto será cambiada.

(Ver también: ../source/compiler/expropt.c)


Inicialización variables estáticas
----------------------------------

Hay una diferencia en la inicialización de las variables estáticas que son inicializadas con un bloque de código que refiere a una variable local. Por ejemplo:

PROCEDURE TEST() LOCAL MyLocalVar STATIC MyStaticVar := {|| MyLocalVar } MyLocalVar :=0 ? EVAL( MyStaticVar ) RETURN

El código de arriba compila bien en Clipper, pero éste genera un error de ejecución: Error/BASE 1132 Bound error: array access
Called from (b)STATICS$(0)

En Harbour este código genera un error en tiempo de compilación: Error E0009 Illegal variable (b) initializer: 'MyLocalVar'

Ambos Clipper y Harbour estan manejando todas las variables locales usadas en una forma especial: ellas son separadas de la pila (stack) local de la función / procedimiento donde ellas son declaradas. Esto permite acceder a estas variables despues de la salida de una función / procedimiento. Sin embargo todas las variables estáticas
son inicializadas en un procedimiento separado ('STATICS$' en Clipper y '(_INITSTATICS)' en Harbour) antes del procedimiento principal y antes de todos los procedimientos INIT. Las variables locales no existen en la pila de evaluación (eval stack) donde las variables estáticas son inicializadas, así ellas no pueden ser separadas.