home *** CD-ROM | disk | FTP | other *** search
/ PC Media 23 / PC MEDIA CD23.iso / share / prog / anubis / mdefs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-15  |  6.5 KB  |  201 lines
  1. // ==========================================================================
  2. // MDEFS.H
  3. // (C) Anubis Software
  4. // Escrito el 5 de Enero de 1995
  5. //
  6. // Esta librería proporciona algunas definiciones y declaraciones útiles
  7. // de proposito genera.
  8. // Está sacada del libro: Lenguaje C, biblioteca de funciones.
  9. // ==========================================================================
  10.  
  11. #ifndef MDEFS.H
  12. #define MDEFS.H
  13.    
  14.    typedef unsigned char    BYTE;
  15.    typedef unsigned char    *PBYTE;
  16.    typedef unsigned int     WORD;
  17.    typedef unsigned int     *PWORD;
  18.    typedef unsigned long    DWORD;
  19.    typedef unsigned long    *PDWORD;
  20.    
  21.    #define ACTIVADO    1        //Tratamiento de un interruptor
  22.    #define DESACTIVADO 0
  23.  
  24.    typedef unsigned char boolean;
  25.    #define FALSE 0
  26.    #define TRUE !FALSE
  27.  
  28.  
  29. /*
  30.  * NOMBRE porcent(x,y)
  31.  * FUNCION: Retorna el porcentaje de x / y.
  32.  * EJEMPLOS: a=porcent(3.0,4.0); asigna a 'a' el valor 75.0
  33.  * VARIABLES UTILIZADAS: x: el dividendo.
  34.  *                       y: el divisor.
  35.  * PSEUDO CODIGO: multiplica x por 100.0 (también convierte a coma flotante)
  36.  *                divide x por y.
  37.  */
  38. #define porcent(x, y) (100.0 * x / y)
  39.  
  40. /* NOMBRE: val_abs(x)
  41.  * FUNCION: Retorna el valor absoluto del valor contenido en la variable x.
  42.  * EJEMPLOS: x = val_abs(-2);          asigna a x el valor 2
  43.  *           x = val_abs(4);           asigna a x el valor 4
  44.  *           x = val_abs(4 -13);       asigna a x el valor 9
  45.  * VARIABLES UTILIZADAS : x: la expresión de la que se retorna el valor absoluto
  46.  * PSEUDO CODIGO:  if (x es positivo)
  47.  *                    return(x)
  48.  *                 else
  49.  *                    return(-x)
  50.  */
  51. #define val_abs(x) ((x >= 0) ? x : 0 - x)
  52.  
  53. /* NOMBRE: max(x,y)
  54.  * FUNCION: Retorna el valor máximo contenido en x o y.
  55.  */
  56. //#define max(x,y) (x > y) ? x : y)
  57.  
  58. /* NOMBRE: min(x,y)
  59.  * FUNCION: Retorna el valor mínimo contenido en x o y.
  60.  */
  61. //#define min(x,y) ((x <y) ? x : y)
  62.  
  63. /* NOMBRE: es_impar(x)
  64.  * FUNCION: Retorna 1 si el valor contenido en x es impar, en otro caso retorna 0.
  65.  *          El operador mod (%) retorna el resto de la división entera de x por 2.
  66.  *          Si el resto es 0, entonces x es par. Si el resto es 1, entonces x es
  67.  *          impar.
  68.  */
  69. #define es_impar(x) ((x % 2 == 1) ? 1 : 0)
  70.  
  71. /* NOMBRE es_par(x)
  72.  * FUNCION: Retorna 1 si el valor contenido en x es par, en otro caso retorna 0.
  73.  *          El operador mod (%) retorna el resto de la división entera de x por 2.
  74.  *          Si el resto es 0, entonces x es par. si el resto es 1, entonces x es
  75.  *          impar.
  76.  */
  77. #define es_par(x) ((x % 2 == 0) ? 1 : 0)
  78.  
  79. /* NOMBRE redondea_off(x)
  80.  * FUNCION: Redondea el valor contenido en x.
  81.  */
  82. #define redondea_off(x) ((int)(x + 0.5))
  83.  
  84. /* NOMBRE: truncar(x)
  85.  * FUNCION Trunca el valor contenido en x.
  86.  */
  87. #define truncar(x) ((int)(x))
  88.  
  89. /* NOMBRE: resto(x,y)
  90.  * FUNCION: Utiliza el operador mod (%) para retornar el resto
  91.  *          de la división entera de los valores x e y.
  92.  */
  93. #define resto(x, y) (x % y)
  94.  
  95. /* NOMBRE: cuadrado(x)
  96.  * FUNCION: Retorna el cuadrado del valor contenido en x.
  97.  */
  98. #define cuadrado(x) (x*x)
  99.  
  100. /* NOMBRE: cubo(x)
  101.  * FUNCION: Retorna el cubo del valor contenido en x.
  102.  */
  103. #define cubo(x) (x*x*x)
  104.  
  105. /* NOMBRE: XOR(x, y)
  106.  * FUNCION: Retorna la or exclusiva de los bits contenidos en las variables
  107.  * x e y. La or exclusiva usa la siguiente tabla de verdad:
  108.  *             x   y    resultado
  109.  *             0   0         0
  110.  *             0   1         1
  111.  *             1   0         1
  112.  *             1   1         0   <--- Nota
  113.  */
  114. #define XOR(x, y) ((x & "y) | ("x & y))
  115.  
  116. /* NOMBRE: NOT(x)
  117.  * FUNCION: Retorna el NOT Booleano del valor contenido en x. si x es TRUE se
  118.  *          retorna FALSE. Si x es FALSE, se retorna TRUE.
  119.  */
  120. #define NOT(x) ((x != 0) ? 0 : 1)
  121.  
  122. /* NOMBRE: bit_mask(x, y)
  123.  * FUNCION: Realiza un AND bit a bit de los contenidos de x e y.
  124.  */
  125. #define bit_mask(x, y) (x & y)
  126.  
  127. /* NOMBRE: es_digit(x)
  128.  * FUNCION: Retorna 1 si x es un caracter en el rango '0' a '9'
  129.  *          en otro caso retorna 0.
  130.  */
  131. #define es_digit(x) ((x >= '0' && x <= '9') ? 1 : 0)
  132.  
  133. /* NOMBRE: es_mayuscula(x)
  134.  * FUNCION: Retorna 1 si x es una letra MAYUSCULA, en otro caso retorna el valor 0.
  135.  */
  136. #define es_mayuscula(x) ((x >= 'A' && x <= 'Z') ? 1 : 0)
  137.  
  138. /* NOMBRE: es_minuscula(x)
  139.  * FUNCION Retorna 1 si x es una letra minúscula, en otro caso retorna 0.
  140.  */
  141. #define es_minuscula(x) ((x >= 'a' && x <= 'z') ? 1 : 0)
  142.  
  143. /* NOMBRE: es_blanco(x)
  144.  * FUNCION: Retorna 1 si el valor contenido en x es un blanco, en otro caso
  145.  *          retorna 0.
  146.  */
  147. #define es_blanco(x) ((x == ' ') ? 1:0)
  148.  
  149. /* NOMBRE: a_mayuscula(x)
  150.  * FUNCION: Convierte el caracter contenido en la variable x a MAYUSCULA si
  151.  *          es minúscula, en otro caso no se modifica.
  152.  */
  153. #define a_mayuscula(x) ((es_minuscula(x)) ? x - 'a' + 'A' : x)
  154.  
  155. /* NOMBRE: a_minuscula(x)
  156.  * FUNCION: Convierte el caracter contenido en la variable x a minúscula si es
  157.  *          MAYUSCULA, en otro caso no se modifica.
  158.  */
  159. #define a_minuscula(x) ((es_mayuscula(x)) ? x + 'a' - 'A' : x)
  160.  
  161. /* NOMBRE: a_decimal(x)
  162.  * FUNCION: Convierte el dígito ASCII al valor decimal correspondiente.
  163.  *          Se supone que x ha sido verificado como un dígito.
  164.  */
  165. #define a_decimal(x) (x - '0')
  166.  
  167. /* NOMBRE: es_control(x)
  168.  * FUNCION: Retorna 1 si el valor contenido en x es una caracter de control, en
  169.  *          otro caso se retorna 0.
  170.  */
  171. #define es_control(x) ((x > 0 && x < 32) ? 1 : 0)
  172.  
  173. /* NOMBRE: es_imprimible_ascii(x)
  174.  * FUNCION: Retorna 1 si x es un caracter ASCII, o 0 si no es imprimible.
  175.  */
  176. #define es_imprimible_ascii(x) ((x > 32 && x < 127) ? 1 : 0)
  177.  
  178. /* NOMBRE: a_ascii(x)
  179.  * FUNCION: Convierte un entero en el rango 0 - 9 a representación de caracter
  180.  *          ASCII. Se retorna -1 si el valor no está en el rango 0 - 9.
  181.  */
  182. #define a_ascii(x) ((x >= 0 && x <= 9) ? x + '0' : -1)
  183.  
  184. /* NOMBRE: es_binario(x)
  185.  * FUNCION: Retorna TRUE si x contiene un '1' o '0', en otro caso se retorna
  186.  *          FALSE.
  187.  */
  188. #define es_binario(x) ((x == '0' || x == '1') ? 1 : 0)
  189.  
  190. /* NOMBRE: es_hexadecimal(x)
  191.  * FUNCION: Retorna 1 si el valor contenido en x es hexadecimal (p.ej., en el
  192.  *          rango 0 - 9 o A - F), en otro caso se retorna el valor 0.
  193.  */
  194. #define es_hexadecimal(x) ((es_digito(x) || (x >= 'A' && x <= 'F')) ? 1 : 0)
  195.  
  196. /* NOMBRE: es_octal(x)
  197.  * FUNCION: Retorna 1 si el valor contenido en x es octal (en el rango '0' - '7'),
  198.  *          en otro caso se retorna el valor 0.
  199.  */
  200. #define es_octal(x) ((x >= '0' && x <= '7') ? 1 : 0)
  201. #endif