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
enum	dbindst_t
struct	Buffer
struct	String
struct	ArrSt
struct	ArrPt
struct	SetSt
struct	SetPt
struct	Stream
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 proyecto software debe sustentarse sobre pilares robustos y eficientes. Para este cometido se ha desarrollado la librería core (Figura 1), que prove utilidades no gráficas de uso común. Además de ser la base de NAppGUI-SDK, también nos facilitará el desarrollo de nuestros propios programas y librerías garantizando la máxima eficiencia y portabilidad. core no tiene dependencias externas, salvo Osbs, que proveerá las llamadas elementales al sistema operativo.

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

La potencia de core radica en la gestión eficiente y segura de la memoria, unido a la automatización de operaciones sobre objetos y al manejo de colecciones basadas en arrays y árboles binarios de búsqueda (Figura 2). Todo esto estaría incompleto sin un robusto sistema de serialización, que nos permita exportar/importar datos desde/hacia la memoria, utilizando diferentes canales de comunicación.

Heap. Gestor de memoria paginado con auditor de fugas.
Buffers. Bloque genérico de memoria dinámica.
Strings. Cadenas de texto en memoria dinámica.
Arrays. Colección de elementos en posiciones contiguas de memoria.
Sets. Contenedor que optimiza la búsqueda, inserción y borrado de elementos.
Data binding. Automatización de operaciones sobre objetos.
Streams. Canales de entrada y salida. Incorpora un analizador de texto para leer tokens.

Gráfico que muestra la relación entre páginas de memoria, estructuras de datos y canales E/S. — Figura 2: Relación entre gestión de memoria, estructuras de datos y streams.

Adicionalmente, core proporciona estas utilidades:

Expresiones regulares.
Eventos. Base para el subsistema de gestión de eventos.
Operaciones con archivos. Utilidades sobre archivos y directorios.
Paquetes de recursos.
Fechas. Funciones relacionadas con fecha/hora.
Relojes. Medición precisa del tiempo.

DeclSt

Habilita macros para la comprobación de tipos en tiempo de compilación en Arrays y Sets. Uso: DeclSt(Type) inmediatamente después de la definición del struct Type.

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.

enum dbindst_t

Valores de retorno en dbind.

enum dbindst_t
{
    ekDBIND_OK,
    ekDBIND_MEMBER_EXISTS,
    ekDBIND_TYPE_EXISTS,
    ekDBIND_TYPE_USED,
    ekDBIND_ALIAS_SIZE
};

ekDBIND_OK	Operación exitosa.
ekDBIND_MEMBER_EXISTS	El miembro de una estructura ya está registrado en DBind.
ekDBIND_TYPE_EXISTS	El tipo de dato ya está registrado en DBind.
ekDBIND_TYPE_USED	El tipo de dato que se quiere eliminar está en uso.
ekDBIND_ALIAS_SIZE	El tamaño de un tipo alias no coincide con el del tipo original.

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 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. Sets.

struct SetSt;

struct SetPt

Conjunto de punteros. El tipo de objeto se indica entre paréntesis. Sets (punteros).

struct SetPt;

struct Stream

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

struct Stream;

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.

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.

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.

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.

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);