Linux kernel 0.0.1 vs 2.6.36, "ctype.h", ¿cuál es la diferencia?

¿Qué tan eficiente es el kernel de Linux 2.6.36 de 0.0.1?

0.0.1:

  1. Entiendo, en esta versión, Linus ha asignado el valor de c (variable de entrada a una función) a una variable temporal y opera en esa variable temporal dentro de la función y devuelve la variable temporal.

  2. Esto sucede en las funciones tolower/toupper.

2.6.36:

  1. Aquí en tolower/toupper lo cambió.
  2. ctype es const.
  3. Se escribe la nueva función ismask.

¿Qué quiero saber?:

¿Por qué se han hecho estos cambios?, ¿qué bien trajo a casa?

He enumerado los archivos ctype.h en las versiones de kernel de 0.0.1 y 2.6.36, respectivamente.

 **** ctype.h, linux-0.01 *****

    #ifndef _CTYPE_H
    #define _CTYPE_H

    #define _U      0x01    /* upper */
    #define _L      0x02    /* lower */
    #define _D      0x04    /* digit */
    #define _C      0x08    /* cntrl */
    #define _P      0x10    /* punct */
    #define _S      0x20    /* white space (space/lf/tab) */
    #define _X      0x40    /* hex digit */
    #define _SP     0x80    /* hard space (0x20) */

    extern unsigned char _ctype[];
    extern char _ctmp;

    #define isalnum(c) ((_ctype+1)[c]&(_U|_L|_D))
    #define isalpha(c) ((_ctype+1)[c]&(_U|_L))
    #define iscntrl(c) ((_ctype+1)[c]&(_C))
    #define isdigit(c) ((_ctype+1)[c]&(_D))
    #define isgraph(c) ((_ctype+1)[c]&(_P|_U|_L|_D))
    #define islower(c) ((_ctype+1)[c]&(_L))
    #define isprint(c) ((_ctype+1)[c]&(_P|_U|_L|_D|_SP))
    #define ispunct(c) ((_ctype+1)[c]&(_P))
    #define isspace(c) ((_ctype+1)[c]&(_S))
    #define isupper(c) ((_ctype+1)[c]&(_U))
    #define isxdigit(c) ((_ctype+1)[c]&(_D|_X))

    #define isascii(c) (((unsigned) c)<=0x7f)
    #define toascii(c) (((unsigned) c)&0x7f)   

    #define tolower(c) (_ctmp=c,isupper(_ctmp)?_ctmp+('a'+'A'):_ctmp)
    #define toupper(c) (_ctmp=c,islower(_ctmp)?_ctmp+('A'-'a'):_ctmp)


    #endif
#
****** ctype.h, linux-2.6.36 *******

#ifndef _LINUX_CTYPE_H
#define _LINUX_CTYPE_H

/*
* NOTE! This ctype does not handle EOF like the standard C
* library is required to.
*/

#define _U      0x01    /* upper */
#define _L      0x02    /* lower */
#define _D      0x04    /* digit */
#define _C      0x08    /* cntrl */
#define _P      0x10    /* punct */
#define _S      0x20    /* white space (space/lf/tab) */
#define _X      0x40    /* hex digit */
#define _SP     0x80    /* hard space (0x20) */

extern const unsigned char _ctype[];

#define __ismask(x) (_ctype[(int)(unsigned char)(x)])

#define isalnum(c)      ((__ismask(c)&(_U|_L|_D)) != 0)
#define isalpha(c)      ((__ismask(c)&(_U|_L)) != 0)
#define iscntrl(c)      ((__ismask(c)&(_C)) != 0)
#define isdigit(c)      ((__ismask(c)&(_D)) != 0)
#define isgraph(c)      ((__ismask(c)&(_P|_U|_L|_D)) != 0)
#define islower(c)      ((__ismask(c)&(_L)) != 0)
#define isprint(c)      ((__ismask(c)&(_P|_U|_L|_D|_SP)) != 0)
#define ispunct(c)      ((__ismask(c)&(_P)) != 0)
/* Note: isspace() must return false for %NUL-terminator */
#define isspace(c)      ((__ismask(c)&(_S)) != 0)
#define isupper(c)      ((__ismask(c)&(_U)) != 0)
#define isxdigit(c)     ((__ismask(c)&(_D|_X)) != 0)

#define isascii(c) (((unsigned char)(c))<=0x7f)
#define toascii(c) (((unsigned char)(c))&0x7f)

static inline unsigned char __tolower(unsigned char c)
{
       if (isupper(c))
               c -= 'A'-'a';
       return c;
}

static inline unsigned char __toupper(unsigned char c)
{
       if (islower(c))
               c -= 'a'-'A';
       return c;
}

#define tolower(c) __tolower(c)
#define toupper(c) __toupper(c)

#endif

preguntado el 03 de mayo de 12 a las 21:05

1 Respuestas

¿Por qué se han hecho estos cambios?, ¿qué bien trajo a casa?

Por un lado, no tienes que definir un ctemp variable en el código que llama a isupper por más tiempo, lo que reduce las líneas de código. Obviamente, también evita filtrar detalles de implementación.

contestado el 04 de mayo de 12 a las 05:05

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.