fficxx („eff fix”) este un generator de interfata functionala externa (FFI) haskell catre C ++.

Pentru a utiliza fficxx, scrieti un model Haskell al interfetelor publice C ++ si fficxx genereaza atat un wrapper C, cat si functii haskell asociate si clase de tip care reflecta modelul specificat al interfetelor C ++. In prezent este responsabilitatea utilizatorului sa specifice un model corect al interfetelor C ++, deoarece fficxx nu verifica in prezent corectitudinea modelului.

In timp ce haskell are un standard bine specificat pentru C FFI, realizarea haskell-C ++ FFI este un proces arbitrar si dureros. Deoarece paradigma de programare orientata pe obiecte (OOP) si paradigma de programare functionala (FP) sunt diferite, traducerea automata a bibliotecilor C ++ in bibliotecile haskell nu este o sarcina simpla. Scopul fficxx este de a minimiza aceasta disparitate si de a maximiza confortul utilizatorului, oferind ca rezultat o interfata familiara bibliotecii originale C ++.

Legarea publica Haskell-C ++ generata de fficxx este acum colectata in proiectele fficxx.

fficxx este separat in partea generatorului si partea runtime:

  • fficxx: tipuri FFI si biblioteca generatoare de legare
  • fficxx-runtime: module de runtime necesare pentru diferite rutine comune

Pachetele Haskell care sunt generate din fficxx vor depinde de fficxx-runtime.

In plus, biblioteca standard C ++ sub spatiu de nume std este generata ca pachet de la fficxx.

  • stdcxx: generat de ./stdcxx-gen/Gen.hs

fficxx este ambalat in principal in nix. shell.nix este pentru dezvoltare,

si use.nix este pentru utilizarea pachetului de legare generat.

Pentru toata constructia,

fficxx genereaza coduri haskell la nivel brut (invelis C si pointer strain haskell care se potrivesc direct cu tipurile C / C ++) si la nivel inalt (impachetare de tip nou pentru pointer de nivel brut si tipuri de tip haskell care reflecta ierarhia clasei OOP). Haskell nu are un concept de subtipare, adica nu oferim nicio modalitate usoara de a crea o noua subclasa si de a suprasarcina functiile de membru din clasele existente pe partea haskell. Cu toate acestea, din fericire, se poate descrie relatia de subclasa OOP folosind o interfata de tip de clasa ca un contract pentru ca o clasa b sa fie egala cu sau o subclasa de a. Intr-un anumit sens, clasele de tipuri sunt Limbajul de definitie a interfetei (IDL) pentru descrierea claselor OOP. Astfel, o clasa C ++ este reprezentata atat de tipul concret Haskell (pentru o clasa C ++ in sine), cat si de clasa de tip (un set de clase care pot fi egale sau o subclasa a clasei C ++).

Presupunand ca exista o clasa C ++ A. fficxx genereaza un haskell tip A. Acest haskell tip A nu este altceva decat un nou tip de ambalare ForeignPtr etichetat de RawA.

date RawA nou tip A = A (ForeignPtr RawA)

RawA exista numai in scopul unui tip fantoma care sa fie folosit ca etichete pentru Ptr in importurile FFI (declaratii de import straine.) Cand se programeaza cu cod generat de fficxx la nivel inalt, programatorii ar trebui sa intalneasca rareori tipuri Raw. Un obiect de instanta din clasa C ++ A este o valoare de tip haskell A. Pentru a crea o instanta, fficxx furnizeaza un constructor inteligent (newA) daca este specificat cu un constructor corespunzator.

Prin urmare, se poate crea o instanta dintr-un tip haskell concret si o poate transmite oricarei functii care au nevoie de ele. Pe partea Haskell, functiile membre ale unei clase C ++ nu sunt altceva decat functii al caror prim argument este acelasi cu tipul haskell corespunzator clasei. De exemplu, daca clasa A are o functie membru foo de semnatura void A :: foo (int param), atunci fficxx genereaza o functie de nivel inalt

foo :: A -> CInt -> IO ()

care este un wrapper pentru un apel FFI de nivel brut definit de

import foriegn ccall “A_foo” c_foo :: Ptr RawA -> CInt -> IO ()

unde A_foo este o functie generata C shim pentru A :: foo.

negros follando a blancas masajes eroticos camara oculta
feet hentai descargar videos porno gratis
pelis porno español online follando con abuelas
porno español dinero porno senegal
le pilla masturbandose sexo casero españa
incesto gratis vecina mirona
sexo videos caseros ver sexo gratis
masajes eroticos con final feliz videos porno online
folladas caseras reales porno gay castellano
incesto xxx se folla a
hombres corriendose voyeur playa
maduras enculadas mamadas en la playa
metiendo mano en el bus porno espaniol
porno español abuelas hermanos españoles follando
incesto ruso viejas tetonas
tetas playa supertetas
sexo playa nudista cornudos consentidos
xxx incesto real porno violada
violacion real porno pornografia gratis
maduras.com violada xxx

Deci se poate traduce urmatorul cod C ++

A * a = nou A (); a-> foo (3);

la codul haskell (in blocul do al monadei IO)

Haskell tip A poate fi utilizat in pozitia argumentului arbitrar. Sa presupunem ca exista o alta bara functionala a lui A care ia un obiect al lui A ca argument ca golul A :: bar (A * a). Atunci noi avem

pentru care x-> bar (y) (x, y sunt din clasa A) corespunde bara x y.

In acest exemplu, C ++ clasa A poate avea urmatoarea declaratie:

clasa A {public: A (); virtual voo foo (int); bara de gol virtual (A *); };

Pentru a reflecta relatiile de subtip, fficxx creeaza o clasa de interfata IA pentru A, care este definita ca

clasa IA a unde foo :: a -> CInt -> IO () bar :: (IA b) => a -> b -> IO ()

care declara toate functiile virtuale C ++ ca membri. Apoi, haskell tip A este o instanta de clasa a IA:

exemplu IA A unde – foo :: A -> CInt -> IO () foo = … – bar :: (IA b) => A -> b -> IO () bar = …

astfel incat functiile foo si bar pe care le-am considerat in exemplul de mai sus au fost de fapt definite in definitia instantei IA a lui A. Retineti ca semnatura de tip a barei permite instantele generice de tip clasa ale IA ca argument (paraterizat de b).

Acum luati in considerare o alta clasa C ++ B care este o subclasa a lui A:

clasa B: public A {public: B (); virtual int baz (); }

Din nou, vom avea un haskell concret de tip B si un obiect al lui B va fi creat ca valoare din functia constructor newB. De asemenea, este generata o clasa de tip IB si reflecta relatia de mostenire pentru clasa C ++ ca constrangeri:

clasa (IA b) => IB b unde baz :: b -> IO CInt

Datorita constrangerilor (IA b) => din declaratie, fiecare instanta a IB trebuie sa aiba implementare IA. Acest lucru este valabil si pentru B. Deci genereaza fficxx

instanta IA B unde foo = … bar = … instanta IB B unde baz = …

Aceasta generatie de instanta ( implementarea clasei C ++ ) este realizata automat de fficxx, dar nu este garantata pentru subclasarea viitoare. Orice tip care implementeaza instante de IA si IB poate fi considerat ca o subclasa de B, dar nu se face automat asa cum avem in OOP. Scopul fficxx este de a genera astfel de implementari numai pentru clasele C ++ existente.

Pentru moment, pentru a vedea cum sa utilizati biblioteca haskell generata, verificati exemple pentru HROOT: http://ianwookim.org/HROOT/gallery.html (daca faceti clic pe exemple, atunci puteti vedea codul sursa pentru acestea.)

Folosim trucuri C Macro descrise in cele ce urmeaza:

  • http://jhnet.co.uk/articles/cpp_magic
  • https://stackoverflow.com/questions/45585903/c-macros-how-to-map-another-macro-to-variadic-arguments
  • https://github.com/pfultz2/Cloak/wiki/C-Preprocessor-tricks,-tips,-and-idioms
  • https://gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments/
  • https://stackoverflow.com/questions/3046889/optional-parameters-with-c-macros/3048361#3048361
  • https://en.cppreference.com/w/cpp/language/template_argument_deduction
  • http://anderberg.me/2016/08/01/c-variadic-templates/
  • https://crascit.com/2015/03/21/practical-uses-for-variadic-templates/
  • https://stackoverflow.com/questions/2354210/can-ac-class-member-function-template-be-virtual

ARTICOLE SIMILAREDE LA ACELAȘI AUTOR