+---------------------------------------------------©
       *Pequeno libro de ERSTilo para la programacion en C.¦
       *                V 2.0 - 11-9-1991.                 ¦
       ----------------------------------------------------»


* 1.- Nominacion de identificadores.
------------------------------------

     Los nombres de las funciones seran todo  lo  largos  que  sea
necesario. Si contienen varias palabras, estas no iran separadas y
cada una comenzara por mayuscula.

     Los nombres de las macros, como es tradicion, en mayusculas y
con las palabras separadas por '_'.

     En cuanto a las los de las variables,  en  minusculas.  Y  si
constan de varias palabras, estas se separaran con subrayados '_'.


* 2.- Declaracion de funciones: predeclaracion y cabeceras.
-----------------------------------------------------------

     Todas las funciones  se  predeclararan  (esto  es,  se  daran
prototipos), indicando en el prototipo no solamente  el  tipo  que
devuelve la funcion, sino tambien  los  tipos  de  los  parametros
(especificando  void  si no tiene).  La excepcion a  esta regla se
hara cuando se busque compatibilidad UNIX.


* 3.- Espaciado horizontal.
---------------------------

     Entre cada dos funciones se incluiran dos lineas en blanco y,
claro  esta,  la  cabecera  de  la  segunda  funcion.  Entre   las
declaraciones externas, #defines e #includes y la primera funcion,
se  incluira el mismo  separador. Dentro de las declaraciones solo
se incluiran lineas en blanco. En el codigo se incluiran lineas de
separacion entre cada porcion independiente.


* 4.- Indentacion.
------------------

     Cada bloque debe estar indentado tres espacios  con  respecto
al anterior. Dentro del concepto de bloque se incluyen los bloques
sin corchetes (compuestos por una sola instruccion).

     Las llaves de apertura y fin de bloque ('{'  y  '}')  estaran
en el mismo nivel de indentacion que las instrucciones del  bloque
y solas en la linea.

     ¿Un ejemplo? ¡Claro!:

      +----------------------+
      * void Funcion( void ) *
      *    {                 *
      *    if(...)           *
      *       {              *
      *       ...            *
      *       ...            *
      *       while(1)       *
      *          {           *
      *          ...         *
      *          ...         *
      *          }           *
      *                      *
      *       do             *
      *          {           *
      *          ...         *
      *          ...         *
      *          }           *
      *          while(1);   *
      *       }              *
      *    }                 *
      -----------------------+

     ¿Queda entendido?.


* 5.- Simbolos '=' y ','.
-------------------------

     Después de cada signo igual  de  asignacion  '='  y  de  cada
coma debe  ir  un espacio.


* 6.- Operadores.
-----------------

     A menos que la expresion  sea  muy  simple,  se  colocara  un
espacio a cada lado de los operadores binarios. Los  unarios  iran
junto al identificador sobre el que actuen.


* 7.- Punteros.
---------------

     La declaracion de punteros se hara de la siguiente manera:

                            tipo *var;

     Es decir, el asterisco ira unido a la variable y separado por
un espacio del tipo al que apunta la variable.


* 8.- Paréntesis.
-----------------

     Los paréntesis abiertos '(' iran seguidos por  un  espacio  y
pegados al identificador previo. Los paréntesis cerrados ')'  iran
precedidos y seguidos (en la mayoria de los casos) por un espacio.

     La unica excepcion se hara  cuando  en  el  interior  de  los
paréntesis solo haya un elemento y éste sea  relativamente  corto.
En este caso se eliminaran los espacios.


* 9.- Corchetes.
----------------

     Los corchetes, tanto abiertos como cerrados ('['  y  ']')  se
regiran (en general) por la misma regla que los paréntesis, aunque
aplicada con mas flexibilidad. Mas adelante  se  desarrollara  una
regla definitiva para ellos.


* 10.- Cabeceras, dedicatorias, cambios inter-versiones.
--------------------------------------------------------

     Todos los programas de importancia iran dedicados  a  alguien
de importancia.  Esta  dedicatoria  se  hara  en  la  cabecera  de
programa, que se ha de colocar al  principio  del  fichero  fuente
principal del programa. En esta cabecera se  anotara,  ademas  del
nombre del programa y su fecha de  inicio,  toda  la  historia  de
modificaciones que haya tenido. La cabecera de programa tendra  el
siguente formato:

/* <nombre-prog> - <ano> Eloy-Rafael Sanz Tapia.
   <dedicatoria>

   Version: Cambio(s):
   -------- --------------------------------------------------------
   1.0      <fecha>


   Opciones de compilacion obligatorias:

   Compatibilidad ANSI o System V:

*/


     Ademas de la cabecera de programa, cada funcion ira precedida
por una cabecera de funcion con el siguiente formato:

/*********************************************************************

   -Nombre de la funcion:

   -Parametros: <numero>
      -Nombre:
      -Tipo:
      -Significado:
      ...

   -Valor de retorno:
      -Tipo:
      -Significado:

   -Cometido:

....................................................................*/


     Cada fichero de cabecera (.h) llevara una cabecera (valga  la
redundancia) de este tipo:

/* <nombre-h> - <ano> Eloy-Rafael Sanz Tapia.

   #include:    para:
   ---------    ------------------------------------------------------
   ninguno.

*/


     Donde xxx.h debe ser cada uno de los ficheros  .h  necesarios
para la correcta interpretacion del  que  se  esta  definiendo,  y
<utilidad> es el tipo de dato,  prototipo  de  funcion,  etc.  que
provoca la necesidad de incluir xxx.h.


* 11.- Identificacion del programa y de la version: Cadena _id_prog.
--------------------------------------------------------------------

     Cada programa tendra su numero de version en la  forma  X.XX.
No hay aun un acuerdo para evaluar los incrementos del  numero  de
version. Se incrementara dependiendo de la cuantia de los  cambios
que se hayan realizado.

     Este numero de version estara contenido, junto con el  nombre
del programa, los créditos y la dedicatoria, en la  cadena  global
_id_prog. Esta cadena se imprimira  el  empezar  el  programa.  La
aparicion por pantalla de la dedicatoria es opcional.

     El formato de la cadena _id_prog es:

char *_id_prog=
     "\n<nombre-prog> <version> - <ano> Eloy-Rafael Sanz.\n\n\000"
     "<dedicatoria>";

     Como se ve, el \000 antes de <dedicatoria>  impide  que  ésta
aparezca en pantalla.


* 12.- Marcadores.
------------------

     Durante la etapa de desarrollo de un programa  se  utilizaran
unos marcadores  para  indicar  determinadas  caracteristicas  del
codigo:

     - La palabra 'REV' tras  una  apertura  de  comentario indica
que  esa linea  se  ha de  revisar  posteriormente.  El  resto del
comentario explicara por qué. El marcador es '/*REV ... */'.

     - La palabra 'INT' en la misma posicion (tras una apertura de
comentario)  indica  que el  desarrollo  del  programa  se  detuvo
momentaneamente en ese punto, y que hay que continuar a partir  de
él. El marcador quedara '/*INT ... */'.

     - La palabra 'DEP' al inicio de un comentario indica  que esa
linea  ha sido  introducida a  efectos de  depuracion y ha de  ser
eliminada de la version final. El marcador es '/*DEP ... */'.



Last modified: Thursday, 20 September 2012, 11:18 PM