/*
 * $Id: compiler.txt,v 1.1.1.1 2001/12/21 10:49:23 ronpinkas Exp $
 */

/*
 * Las siguientes partes son derechos adquiridos de sus autores individuales.
 * www - http://www.harbour-project.org
 *
 * Copyright 2000 Alejandro de Grate <alex_degarate@hotmail.com>
 * Documentacin en Espaol de:  Opciones del Compilador
 *
 * Vea doc/license.txt por los trminos de la licencia.
 *
 */


/*  $DOC$
 *  $FUNCNAME$
 *      Opciones del Compilador
 *  $CATEGORY$
 *      Documentacin
 *  $ONELINER$
 *      Opciones del Compilador
 *  $DESCRIPTION$
 *
 *      Invocando al compilador Harbour:   </par>
 *      ===============================   </par>
 *
 *         harbour <archivo[.prg]> [opciones]   </par>
 *      or                                      </par>
 *         harbour [opciones] <archivo[.prg]>    </par>
 *      or   </par>
 *         harbour [opciones] <archivo[.prg]> [opciones]   </par>
 *
 *
 *      Las opciones de la lnea de comandos debe ser separada, al menos por
 *      un espacio en blanco.   </par>
 *      Las opciones pueden comenzar con el carcter '/'  '-',    </par>
 *
 *      Opciones de la lnea de comandos de:   </par>
 *      ====================================   </par>
 *
 *      /a               Declaracin Automtica de memvar    </par>
 *      -----------------   </par>
 *          Esto causa que todas las variables declaradas por las sentencias
 *          PARAMETER, PRIVATE  PUBLIC sean automticamente declaradas como
 *          variables MEMVAR.          </par>
 *
 *      /b               Informacin de depuracin (Bug)  </par>
 *      -----------------   </par>
 *          El compilador genera toda la informacin requerida para depuracin </par>
 *
 *      /d<id>[=<val>]   #define <id>   </par>
 *      -----------------   </par>
 *
 *      /es[<nivel>]     establece la Severidad de la salida (Exit Severity) </par>
 *      -----------------   </par>
 *
 *          /es or /es0 - Todas las advertencias son ignoradas y el cdigo 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. </par>
 *          /es1        - Cualquier advertencia genera un cdigo de salida
 *                        distinto de cero, pero la salida es an creada. </par>
 *          /es2        - Cualquier advertencia es tratada como error y ningn
 *                        archivo de salida es creado. El cdigo de salida es
 *                        establecido a un valor distinto de cero.  </par>
 *
 *      /g<tipo>         Generacin del tipo de archivo de salida <type> </par>
 *      -----------------                                  </par>
 *
 *          /gc          tipo de salida: fuente de lenguaje C (.c) (defecto) </par>
 *          /gf          tipo de salida: Windows/DOS OBJ32 (.obj)      </par>
 *          /gh          tipo de salida: Objeto Portable de Harbour (.hrb) </par>
 *          /gj          tipo de salida: fuente de Java (.java)         </par>
 *          /gp          tipo de salida: fuente de Pascal (.pas)        </par>
 *          /gr          tipo de salida: recursos de Windows (.rc)      </par>
 *
 *      /i<ruta>         agrega la ruta de bsqueda de archivos #Include  </par>
 *      -----------------   </par>
 *
 *      /l               suprime la informacin del nmero de Lnea   </par>
 *      -----------------   </par>
 *          El compilador no genera el nmero de lnea del cdigo fuente
 *          en el archivo de salida. La funcin PROCLINE() retornar cero
 *          para los mdulos compilados usando esta opcin.   </par>
 *
 *      /m               compilar el Mdulo actual solamente  </par>
 *      -----------------   </par>
 *
 *      /n               sin procedimiento de inicio implcito </par>
 *      -----------------   </par>
 *          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.  </par>
 *
 *      /o<ruta>         unidad de disco y/o ruta para el archivo de salida </par>
 *      -----------------   </par>
 *
 *      /p               genera un archivo de salida Pre-procesada (.ppo) </par>
 *      -----------------   </par>
 *          El compilador solamente crea el archivo que contiene el
 *          resultado del archivo fuente pre-procesado.   </par>
 *
 *      /q               Quieto  </par>
 *      -----------------   </par>
 *          El compilador no imprime ningn mensaje durante la compilacin
 *          (excepto la informacin del copyright).   </par>
 *
 *          /q0          que permanezca realmente Quieto y no muestre ni
 *                       siquiera la informacin del copyright.   </par>
 *
 *      /r[<libreria>]   solicita al linker Revisar por <libreria> ( ninguna) </par>
 *      -----------------   </par>
 *          Actualmente no soportado en Harbour.           </par>
 *
 *      /s               solo chequeo de Sintaxis.          </par>
 *      -----------------   </par>
 *          El compilador chequea la sintaxis solamente. Ningn archivo de
 *          salida es generado.  </par>
 *
 *      /t<ruta>         ruta para la creacin de un archivo Temporario  </par>
 *      -----------------   </par>
 *          Actualmente no usado en harbour (El compilador de harbour no
 *          crea ningn archivo temporal)   </par>
 *
 *      /u[<archivo>]       Usar la definicin de comando establecido en el
 *                          <archivo> ( ninguno)   </par>
 *      -----------------   </par>
 *          An no soportado.   </par>
 *
 *      /v               las Variables son asumidas como M->   </par>
 *      -----------------   </par>
 *          Todas las variables sin declarar  unaliased son asumidas como
 *          variables MEMVAR (variables privadas  pblicas). si este switch
 *          no es usado entones el alcance de estas variables es chequeado
 *          en tiempo de ejecucin.    </par>
 *
 *      /w[<nivel>]      Establece el nmero de nivel de las advertencias
 *                       (Warnings) (0..4, por defecto es 1)   </par>
 *      -----------------   </par>
 *
 *         /w0         - sin advertencias                          </par>
 *         /w or /w1   - advertencias compatibles con Clipper      </par>
 *         /w2         - algunas advertencias tiles ausentes en Clipper </par>
 *         /w3         - advertencias generadas para extensiones al lenguaje
 *                       hechas en Harbour. Tambin habilita el chequeo de
 *                       sintaxis fuertemente tipeada pero slo advierte
 *                       contra los tipos declarados, o los tipos que pueden
 *                       ser calculados en tiempo de compilacin.    </par>
 *         /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 compilacin, junto con los tipos ya
 *                       declarados, una advertencia ser generada.   </par>
 *
 *      /x[<prefijo>]    establece el smbolo del prefijo agregado al nombre
 *                       de funcin (para archivo.c solamente)   </par>
 *      -----------------   </par>
 *          Establece el smbolo del prefijo agregado al nombre de funcin
 *          de inicio (en la salida de lenguaje C, actualmente). Esta funcin
 *          es generada automticamente para cada mdulo de PRG compilado.
 *          Este prefijo adicional puede ser usado para suprimir problemas
 *          con smbolos duplicados durante el enlazado de una aplicacin
 *          (linking) con alguna librera de terceros.   </par>
 *
 *      /y               seguimiento de la actividad de Lex & Yacc   </par>
 *      -----------------   </par>
 *          El compilador Harbour usa las utilidades FLEX y YACC para analizar
 *          el cdigo fuente y generar el archivo de salida requerido.
 *          Esta opcin sigue la actividad de esas utilidades. </par>
 *
 *      /z               suprime el cortocircuito lgico (.and. y .or.) </par>
 *      -----------------   </par>
 *
 *      /10              restringe la longitud de smbolos a 10 caracteres. </par>
 *      -----------------   </par>
 *          Todos los nombres de variables y de funciones son cortados a un
 *          mximo de 10 caracteres.  </par>
 *
 *
 *      Compilacin en modo lote (batch).   </par>
 *      ================================   </par>
 *
 *       @<archivo>         compila la lista de mdulos en el <archivo>   </par>
 *      -----------------        </par>
 *          No soportado an.    </par>
 *
 *
 *
 *      Conocidas incompatibilidades entre compiladores harbour y clipper  </par>
 *      =================================================================   </par>
 *
 *      NOTE:   </par>
 *        Si desea libreras de compilacin y ejecucin 100 % compatibles,
 *      entonces Ud. debe definir: HARBOUR_STRICT_CLIPPER_COMPATIBILITY.
 *      Esta opcin debe ser definida en el archvivo ../include/hbsetup.h
 *      (en efecto esta opcin es puesta en un comentario por defecto - Ud.
 *      necesita remover los caracteres /* */ solamente. Este cambio debe ser
 *      realizado antes de invocar la utilidad make.   </par>
 *
 *
 *      Manejo de variables sin declarar </par>
 *      --------------------------------   </par>
 *        Cuando un valor es asignado a una variable no declarada y la opcin
 *      -v  de la lnea 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).   </par>
 *
 *      Cuando el valor de una variable no declarada es accedido y la opcin
 *      -v de la lnea de comandos no es usada, el compilador Harbour genera
 *      un opcode  PUSHV (push variable) para determinar el tipo de variable
 *      en tiempo de ejecucin

 *      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).   </par>
 *
 *        El compilador Harbour genera un opcode para determinar el tipo de
 *      variable en tiempo de ejecucin (POPVARIABLE or PUSHVARIABLE) en
 *      ambos casos (asignacin y acceso).   </par>
 *
 *      La diferencia puede ser chequeada por el siguiente cdigo:   </par>

 *          <fixed>
 *      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
 *     </fixed>
 *
 *      Pasando por refeerencia una variable no declarada   </par>
 *      -------------------------------------------------   </par>
 *        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 ejecucin (field or
 *      memvar). Sin embargo las variables de campo no pueden ser pasadas por
 *      referencia. Esto significa que Clipper chequea slo la variable memvar
 *      y no mira por una de campo.
 *      Esta es la razn por la cual el compilador Harbour usa el opcode
 *      habitual PUSHMEMVARREF en estos casos. Ntese que el comportamiento
 *      en tiempo de ejecucin es el mismo en Clipper y en Harbour - slo los
 *      opcodes generados son diferentes.   </par>
 *
 *
 *      Manejo de mensajes a objetos   </par>
 *      ----------------------------   </par>
 *
 *        El seteo de HARBOUR_STRICT_CLIPPER_COMPATIBILITY determina
 *      la forma en que el envo encadenado de mensajes es manejado </par>
 *
 *      Por ejemplo, el siguiente cdigo: </par>
 *
 *      a:b( COUNT() ):c += 1   </par>
 *
 *      ser manejado como:   </par>
 *
 *      a:b( COUNT() ):c := a:b( COUNT() ):c + 1   </par>
 *      en modo de compatibilidad estricta y  </par>
 *
 *      temp := a:b( COUNT() ), temp:c += 1   </par>
 *      en modo no-estricto.   </par>
 *
 *        En la prctica, Clipper llamar a la funcin COUNT() dos veces:
 *      La primera vez antes de la adicin y la segunda despus de la
 *      adicin.
 *      En Harbour, COUNT() ser llamada slo una vez, antes de la adicin. </par>
 *
 *        El mtodo Harbour (no-estricto) es:   </par>
 *      1) Ms rpido   </par>
 *      2) Garantiza que la misma variable de instancia del mismo
 *         objeto ser cambiada.  </par>
 *
 *      (Ver tambin: ../source/compiler/expropt.c)   </par>
 *
 *
 *      Inicializacin variables estticas     </par>
 *      ----------------------------------      </par>
 *
 *      Hay una diferencia en la inicializacin de las variables estticas
 *      que son inicializadas con un bloque de cdigo que refiere a una
 *      variable local. Por ejemplo:   </par>

 *      <fixed>
 *      PROCEDURE TEST()
 *
 *      LOCAL MyLocalVar
 *      STATIC MyStaticVar := {|| MyLocalVar }
 *
 *        MyLocalVar :=0
 *        ? EVAL( MyStaticVar )
 *
 *      RETURN
 *      </fixed>

 *      El cdigo de arriba compila bien en Clipper, pero ste genera un
 *      error de ejecucin:
 *           Error/BASE 1132 Bound error: array access
 *      Called from (b)STATICS$(0)   </par>
 *
 *      En Harbour este cdigo genera un error en tiempo de compilacin:
 *      Error E0009 Illegal variable (b) initializer: 'MyLocalVar'   </par>
 *
 *      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 funcin / procedimiento donde ellas son declaradas.
 *      Esto permite acceder a estas variables despues de la salida de una
 *      funcin / procedimiento. Sin embargo todas las variables estticas
 *      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 evaluacin (eval stack) donde las variables
 *      estticas son inicializadas, as ellas no pueden ser separadas.  </par>
 *
 *  $END$
 */
