Core

Un core fuerte mejorará tu técnica, fuerza, resistencia y complementará todo lo que hagas. Susan Trainor

Funciones

void	(*FPtr_remove (...))
void	(*FPtr_event_handler (...))
type*	(*FPtr_read (...))
void	(*FPtr_read_init (...))
void	(*FPtr_write (...))
void	core_start (void)
void	core_finish (void)

Tipos y Constantes

	DeclSt
	DeclPt
enum	core_event_t
enum	sstate_t
enum	vkey_t
enum	mkey_t
enum	token_t
struct	Buffer
struct	String
struct	Stream
struct	ArrSt
struct	ArrPt
struct	SetSt
struct	SetPt
struct	RegEx
struct	Event
struct	KeyBuf
struct	Listener
struct	IListener
struct	DirEntry
struct	EvFileDir
struct	ResPack
struct	ResId
struct	Clock

De igual forma que un edificio necesita una cimentación fuerte, cualquier aplicación o librería debe sustentarse sobre pilares robustos y eficientes. Es inútil invertir horas y horas en una bonita interfaz si el motor interno está quebrado. Para este cometido ha sido desarrollada la librería core (Figura 1). Proveé estructuras, utilidades y algoritmos de uso común en programación, que nos facilitarán el desarrollo de programas garantizando la máxima eficiencia y portabilidad. Core supone el tercer nivel dentro del SDK de NAppGUI y aún no tiene conocimiento sobre las posibilidades gráficas del sistema operativo, por lo que puede utilizarse en la implementación de cualquier tipo de proyecto.

Árbol de dependencias de la librería core. — Figura 1: Dependencias de *core*. Ver NAppGUI API.

Los servicios que proporciona core se han dividido en una serie de módulos.

DeclSt

Dado un struct, habilita macros para la comprobación de tipos en tiempo de compilación en Arrays y Árboles binarios de búsqueda. Uso: DeclSt(Product) inmediatamente después de la definición del struct. Ver Registros o punteros.

DeclPt

Igual que DeclSt para contenedores de punteros.

enum core_event_t

Tipos de evento en la librería core.

enum core_event_t
{
    ekEASSERT,
    ekEFILE,
    ekEENTRY,
    ekEEXIT
};

ekEASSERT	Redirección de los Asserts.
ekEFILE	Un archivo detectado mientras recorremos un directorio. hfile_dir_loop.
ekEENTRY	Entrada en un sub-directorio mientras recorremos un directorio. hfile_dir_loop.
ekEEXIT	Salida de un sub-directorio.

enum sstate_t

Estado en Streams.

enum sstate_t
{
    ekSTOK,
    ekSTEND,
    ekSTCORRUPT,
    ekSTBROKEN
};

ekSTOK	Todo bien, no errores.
ekSTEND	No hay más datos en el canal.
ekSTCORRUPT	Los datos en el canal no son válidos o no se han leído correctamente.
ekSTBROKEN	Error en el canal de comunicación.

enum vkey_t

Códigos de teclado. Ver Uso del teclado.

enum vkey_t
{
    ekKEY_UNDEF,
    ekKEY_A,
    ekKEY_S,
    ekKEY_D,
    ekKEY_F,
    ekKEY_H,
    ekKEY_G,
    ekKEY_Z,
    ekKEY_X,
    ekKEY_C,
    ekKEY_V,
    ekKEY_BSLASH,
    ekKEY_B,
    ekKEY_Q,
    ekKEY_W,
    ekKEY_E,
    ekKEY_R,
    ekKEY_Y,
    ekKEY_T,
    ekKEY_1,
    ekKEY_2,
    ekKEY_3,
    ekKEY_4,
    ekKEY_6,
    ekKEY_5,
    ekKEY_9,
    ekKEY_7,
    ekKEY_8,
    ekKEY_0,
    ekKEY_RCURLY,
    ekKEY_O,
    ekKEY_U,
    ekKEY_LCURLY,
    ekKEY_I,
    ekKEY_P,
    ekKEY_RETURN,
    ekKEY_L,
    ekKEY_J,
    ekKEY_SEMICOLON,
    ekKEY_K,
    ekKEY_QUEST,
    ekKEY_COMMA,
    ekKEY_MINUS,
    ekKEY_N,
    ekKEY_M,
    ekKEY_PERIOD,
    ekKEY_TAB,
    ekKEY_SPACE,
    ekKEY_GTLT,
    ekKEY_BACK,
    ekKEY_ESCAPE,
    ekKEY_F17,
    ekKEY_NUMDECIMAL,
    ekKEY_NUMMULT,
    ekKEY_NUMADD,
    ekKEY_NUMLOCK,
    ekKEY_NUMDIV,
    ekKEY_NUMRET,
    ekKEY_NUMMINUS,
    ekKEY_F18,
    ekKEY_F19,
    ekKEY_NUMEQUAL,
    ekKEY_NUM0,
    ekKEY_NUM1,
    ekKEY_NUM2,
    ekKEY_NUM3,
    ekKEY_NUM4,
    ekKEY_NUM5,
    ekKEY_NUM6,
    ekKEY_NUM7,
    ekKEY_NUM8,
    ekKEY_NUM9,
    ekKEY_F5,
    ekKEY_F6,
    ekKEY_F7,
    ekKEY_F3,
    ekKEY_F8,
    ekKEY_F9,
    ekKEY_F11,
    ekKEY_F13,
    ekKEY_F16,
    ekKEY_F14,
    ekKEY_F10,
    ekKEY_F12,
    ekKEY_F15,
    ekKEY_PAGEUP,
    ekKEY_HOME,
    ekKEY_SUPR,
    ekKEY_F4,
    ekKEY_PAGEDOWN,
    ekKEY_F2,
    ekKEY_END,
    ekKEY_F1,
    ekKEY_LEFT,
    ekKEY_RIGHT,
    ekKEY_DOWN,
    ekKEY_UP,
    ekKEY_LSHIFT,
    ekKEY_RSHIFT,
    ekKEY_LCTRL,
    ekKEY_RCTRL,
    ekKEY_LALT,
    ekKEY_RALT,
    ekKEY_INSERT,
    ekKEY_EXCLAM,
    ekKEY_MENU,
    ekKEY_LWIN,
    ekKEY_RWIN,
    ekKEY_CAPS,
    ekKEY_TILDE,
    ekKEY_GRAVE,
    ekKEY_PLUS
};

enum mkey_t

Teclas modificadoras.

enum mkey_t
{
    ekMKEY_NONE,
    ekMKEY_SHIFT,
    ekMKEY_CONTROL,
    ekMKEY_ALT,
    ekMKEY_COMMAND
};

enum token_t

Tipos de tokens en stm_read_token.

enum token_t
{
    ekTSLCOM,
    ekTMLCOM,
    ekTSPACE,
    ekTEOL,
    ekTLESS,
    ekTGREAT,
    ekTCOMMA,
    ekTPERIOD,
    ekTSCOLON,
    ekTCOLON,
    ekTOPENPAR,
    ekTCLOSPAR,
    ekTOPENBRAC,
    ekTCLOSBRAC,
    ekTOPENCURL,
    ekTCLOSCURL,
    ekTPLUS,
    ekTMINUS,
    ekTASTERK,
    ekTEQUALS,
    ekTDOLLAR,
    ekTPERCEN,
    ekTPOUND,
    ekTAMPER,
    ekTAPOST,
    ekTQUOTE,
    ekTCIRCUM,
    ekTTILDE,
    ekTEXCLA,
    ekTQUEST,
    ekTVLINE,
    ekTSLASH,
    ekTBSLASH,
    ekTAT,
    ekTINTEGER,
    ekTOCTAL,
    ekTHEX,
    ekTREAL,
    ekTSTRING,
    ekTIDENT,
    ekTUNDEF,
    ekTCORRUP,
    ekTEOF,
    ekTRESERVED
};

ekTSLCOM	Comentario de una sola línea, que comienza por `//`.
ekTMLCOM	Comentario multi-línea, encerrado entre `/` y `/`.
ekTSPACE	Representa una serie de espacios en blanco (`' '`, `'\t'`, `'\v'`, `'\f'`, `'\r'`).
ekTEOL	Representa el carácter nueva línea (`'\n'`).
ekTLESS	Signo menor que `'<'`.
ekTGREAT	Signo mayor que `'>'`.
ekTCOMMA	Signo coma `','`.
ekTPERIOD	Signo punto `'.'`.
ekTSCOLON	Signo punto y coma `';'`.
ekTCOLON	Signo dos puntos `':'`.
ekTOPENPAR	Paréntesis de apertura `'('`.
ekTCLOSPAR	Paréntesis de cierre `')'`.
ekTOPENBRAC	Corchete de apertura `'['`.
ekTCLOSBRAC	Corchete de cierre `']'`.
ekTOPENCURL	Llave de apertura `'{'`.
ekTCLOSCURL	Llave de cierre `'}'`.
ekTPLUS	Signo más `'+'`.
ekTMINUS	Signo menos `'-'`.
ekTASTERK	Signo asterisco `'*'`.
ekTEQUALS	Signo igual `'='`.
ekTDOLLAR	Signo dolar.
ekTPERCEN	Signo porcentaje `'%'`.
ekTPOUND	Signo almohadilla `'#'`.
ekTAMPER	Signo ampersand `'&'`.
ekTAPOST	Signo apóstrofe `'''`.
ekTQUOTE	Signo comillas `'"'`.
ekTCIRCUM	Signo acento circunflejo `'^'`.
ekTTILDE	Signo tilde `'~'`.
ekTEXCLA	Signo exclamación `'!'`.
ekTQUEST	Signo interrogación `'?'`.
ekTVLINE	Signo barra vertical `'\|'`.
ekTSLASH	Signo barra oblicua `'/'`.
ekTBSLASH	Signo barra invertida `'\'`.
ekTAT	Signo arroba `'@'`.
ekTINTEGER	Número entero. Números.
ekTOCTAL	Número octal. Números.
ekTHEX	Número hexadecimal. Números.
ekTREAL	Número real. Números.
ekTSTRING	Cadena de caracteres Unicode, entre comillas. Cadenas.
ekTIDENT	Identificador. Identificadores.
ekTUNDEF	Token desconocido.
ekTCORRUP	Error en el Streams de entrada.
ekTEOF	Final del Streams. No hay más tokens.
ekTRESERVED	Palabras clave. Al ser de propósito general, el analizador no etiqueta ningún identificador como palabra reservada. Hay que hacerlo en fases posteriores al análisis.

struct Buffer

Bloque de memoria de propósito general, reservado dinámicamente. Una vez creado, ya no se puede redimensionar. Buffers.

struct Buffer;

struct String

Cadena de caracteres UTF8 reservada dinámicamente. Son objetos "parcialmente mutables". La memoria reservada no puede crecer, pero se pueden sustituir caracteres siempre que no se desborde la capacidad inicial del buffer. Strings.

struct String;

struct Stream

Canal genérico de entrada/salida, donde es posible leer y escribir datos con formato. Streams.

struct Stream;

struct ArrSt

Array de registros. El tipo de objeto se indica entre paréntesis. Arrays.

struct ArrSt;

struct ArrPt

Array de punteros. El tipo de objeto se indica entre paréntesis. Arrays (punteros).

struct ArrPt;

struct SetSt

Conjunto de registros. El tipo de objeto se indica entre paréntesis. Árboles binarios de búsqueda.

struct SetSt;

struct SetPt

Conjunto de punteros. El tipo de objeto se indica entre paréntesis. Árboles binarios de búsqueda (punteros).

struct SetPt;

struct RegEx

Expresión regular. Expresiones regulares.

struct RegEx;

struct Event

Contiene información referente a un evento. Eventos.

struct Event;

struct KeyBuf

Búfer de teclado con el estado de cada tecla (pulsada/liberada). Búfer de teclado.

struct KeyBuf;

struct Listener

Enlaza al generador y receptor de un eventos a través de una función callback. Eventos.

struct Listener;

struct IListener

Interfaz C++ para utilizar miembros de clase como manejadores de eventos. Uso de C++.

struct IListener;

struct DirEntry

Elemento de un directorio, obtenido mediante hfile_dir_list.

struct DirEntry
{
    String* name;
    file_type_t type;
    uint64_t size;
    Date date;
};

name	Nombre del archivo o subdirectorio, sin directorios intermedios.
type	Tipo de elemento.
size	Tamaño en bytes.
date	Fecha de la última modificación.

struct EvFileDir

Parámetros del evento ekEFILE y ekEENTRY durante la navegación automática por directorios. hfile_dir_loop.

struct EvFileDir
{
    const char_t* pathname;
    uint32_t level;
};

pathname	El camino parcial desde el parámetro `pathname` de hfile_dir_loop.
level	La profundidad del directorio desde `pathname`.

struct ResPack

Paquete de recursos que serán cargados conjuntamente. Utilizar ResId para acceder a un recurso concreto. Recursos.

struct ResPack;

struct ResId

Identificador de un recurso. Son generados automáticamente por nrc NAppGUI Resource Compiler. Recursos.

struct ResId;

struct Clock

Mide el tiempo transcurrido entre dos instantes dentro de la aplicación, con precisión de micro-segundos. También es útil para lanzar eventos a intervalos regulares de tiempo.

struct Clock;

FPtr_remove

Libera la memoria de los campos de un objeto, pero no el objeto en sí mismo. Registros o punteros.

void
(*FPtr_remove)(type *obj);

obj	Puntero al objeto cuyos campos deben ser liberados.

FPtr_event_handler

Manejador de evento. Son funciones callback que serán llamadas por el generador de un evento cuando este ocurra. Eventos.

void
(*FPtr_event_handler)(type *obj,
                      Event *event);

obj	Datos generales pasados como primer parámetro de la función.
event	El evento.

FPtr_read

Crea un objeto a partir de datos leídos desde un Streams. Serialización.

type*
(*FPtr_read)(Stream *stream);

stream

El canal E/S donde está serializado el objeto.

Retorna

El objeto creado, deserializando los datos del stream.

FPtr_read_init

Similar a FPtr_read donde la memoria del objeto ya ha sido reservada, pero no inicializada. Serialización.

void
(*FPtr_read_init)(Stream *stream,
                  type *obj);

stream	El canal E/S donde está serializado el objeto.
obj	El objeto cuyos campos hay que deserializar.

FPtr_write

Escribe un objeto en un Streams. Serialización.

void
(*FPtr_write)(Stream *stream,
              const type *obj);

stream	El canal E/S donde serializar el objeto.
obj	El objeto a escribir.

core_start ()

Inicia la librería core, reservando espacio para las estructuras internas globales. Internamente llama a osbs_start.

void
core_start(void);

core_finish ()

Finaliza la librería core, liberando el espacio de las estructuras internas globales. Internamente llama a osbs_finish.

void
core_finish(void);