InteLib es una biblioteca de C ++ clases que deja usted realmente Cecea programando dentro de su C ++ programa hasta sin cualquier proceso previo adicional, sin todas aquellas convenciones de vocación etc.

Usted puede escribir un C ++ código (es decir un código que es aceptado por su C ++ compilador) pensando en "un modo de Ceceo" y el código que usted escribe se parecerá mucho al código de Ceceo altough será C puro ++.

Para darle el sentimiento esencial, el ejemplo siguiente es proporcionado.

(defun isomorphic (tree1 tree2)
(cond ((átomo tree1) (átomo tree2))
((átomo tree2) NADA)
(t ((e isomorphic (coche tree1)
(coche tree2))
(isomorphic (cdr tree1)
(cdr tree2))
))))

¿Sólo una función de Ceceo, isnt esto? Ahora mire el código siguiente:

(L|DEFUN, ISOMORPHIC, (L|TREE1, TREE2),
(L|COND,
(L | (L|ATOM, TREE1), (L|ATOM, TREE2)),
(L | (L|ATOM, TREE2), NADA),
(L|T, (L|AND,
(L|ISOMORPHIC, (L|CAR, TREE1),
(L|CAR, TREE2)),
(L|ISOMORPHIC, (L|CDR, TREE1),
(L|CDR, TREE2))
))))

Obviamente el código es exactamente igual, la sintaxis cambiada un poco, pero su todavía el mismo. ¿Bien, le sorprendo si digo que es C ++ código? Si usted que dont creen, miran lo siguiente:

//Archivo isomorph.cpp
#include "lisp/lisp.hpp"
#include "lisp/lsymbol.hpp"
#include "lfun_std.hpp"

LSymbol ISOMORPHIC ("ISOMORPHIC");

LFunctionalSymbol estático <LFunctionDefun> DEFUN ("DEFUN");
LFunctionalSymbol estático <LFunctionCond> COND ("COND");
LFunctionalSymbol estático <LFunctionAtom> ÁTOMO ("ÁTOMO");
LFunctionalSymbol estático <LFunctionAnd> ("Y Y");
LFunctionalSymbol estático <LFunctionCar> COCHE ("COCHE");
LFunctionalSymbol estático <LFunctionCdr> CDR ("CDR");

LListConstructor L;

vacíe LispInit_isomorphic () {
LSymbol estático TREE1 ("TREE1");
LSymbol estático TREE2 ("TREE2");
////////////////////////////////////////////////
//
(L|DEFUN, ISOMORPHIC, (L|TREE1, TREE2),
(L|COND,
(L | (L|ATOM, TREE1), (L|ATOM, TREE2)),
(L | (L|ATOM, TREE2), NADA),
(L|T, (L|AND,
(L|ISOMORPHIC, (L|CAR, TREE1),
(L|CAR, TREE2)),
(L|ISOMORPHIC, (L|CDR, TREE1),
(L|CDR, TREE2))
)))).Evaluate ();
//
////////////////////////////////////////////////
}
//final de archivo

Bien, este código es C completo ++ módulo y esto realmente compila bastante bien. Ninguna broma, su verdadero.

A propósito, los dont tratan de encontrar cualquier uso que hice del macroprocesador. Ningunos macros han estado usados alguna vez por InteLib (excepto aquellos para condicional compilan directivas). En cambio, sólo recuerde que la coma es un operador en C ++ y puede ser sobrecargada para tipos de datos inventados por el usuario.

Whats Nuevo en Esta Liberación:

· Algunos nuevos aspectos relacionados con el paquete son puestos en práctica, y el ÑU readline autodescubrimiento ha sido fijado.