[C++] Syntax stoeien, Javascript syntax in c++

[Arjan]

Mijn 'eerste' programmeertaal was Javascript en nog steeds vind ik de syntax en mogelijkheden van de taal erg mooi. Onlangs moest ik weer eens wat met JS doen en toen begon het idee dat het in C++ ( mijn 'huidige' taal ) mogelijk moest zijn om veel van JS te simuleren.

Nu begrijp ik dat dit niet echt een praktisch nut heeft, maar om iets dergelijks op te zetten dwingt je creatief te kijken naar een taal en levert vaak inzichten op die je anders nooit zou krijgen. Vandaar dat ik aan het stoeien was geslagen om te proberen JS in C++ te implementeren.

Nu heb ik een groot deel werkend, maar met name de function pointers die in JS goddelijk eenvoudig zijn krijg ik nog niet geïmplementeerd. Hierover zou ik graag met jullie discussiëren.

Ik heb het volgende bijvoorbeeld werkend:

C++:

struct Document
{
    void write( const Undefined &object )
    {
        std::cout << object << std::endl;
    }
} document;

int main( int argc, char **argv )
{
    var aap;

    document.write( aap );

    aap = 2;

    document.write( aap );

    aap = 3;

    document.write( aap );

    aap = "apen";

    document.write( aap );

    var beer = null;

    document.write( 3 + 2 + aap + 2e-3 + beer );

    var a;
    var b = null;
    var c = Object();
    var d = String();
    var e = Array();
    var f = Date();

    document.write( a );
    document.write( b );
    document.write( c );
    document.write( d );
    document.write( e );
    document.write( f );

    for ( var i = 0; i <= 5; ++i )
    {
        document.write( "The number is " + i );
    }

    return 0;
}

Dit heeft als output:

undefined
2
3
apen
5apen0.002null
undefined
null
[object Object]

[nog niet geimplementeerd]
[nog niet geimplementeerd]
The number is 0
The number is 1
The number is 2
The number is 3
The number is 4
The number is 5

Voor diegene die niet met JS bekend zijn, het volgende is mogelijk in JS:

JavaScript:

var a = function()
{
    alert( this );
}
a();

Graag zou ik zien hoe dicht ik hierbij in de buurt kan komen.
Ik kwam zelf niet verder dan het volgende:

C++:

struct Function : public Undefined { Undefined operator()()
    {
        alert( this );
        return 0;
    }
};
var a = Function();
a();

Dat zou je met wat preprocessor magic nog iets mooier kunnen maken, maar echte prijzen win je er natuurlijk niet mee... Daarnaast zitten er ook behoorlijke lastigheden aan vast wanneer je met verschillende parameters gaat werken.

Nu weet ik dat er hier genoeg mensen rondlopen die de mooiste dingen kunnen bedenken in C++, dus ik hoop dat hier een leuke oplossing uit voorkomt

[Verwijderd]

C++:

int b(int x, int y) { return x + y; }
int (*a)(int, int) = b;

http://codepad.org/w3SsFpMJ

Zou gewoon moeten werken. Function pointers zaten al in C.

In C++0x zitten zelfs lambda's, waarmee je als het goed is het volgende zou kunnen doen:

C++:

int (*b)(int, int) = [](int x, int y) { return x + y; }

[ Voor 58% gewijzigd door Verwijderd op 02-04-2011 13:43 ]

[Nvidiot]

Je zou kunnen kijken naar Lambda functies in C++0x:
Wikipedia: C++0x

[Verwijderd]

Oh, en over 'var' gesproken: C++0x heeft daar 'auto' voor.

[Gamebuster]

Hoe kom je aan die var's?
Is dat een standaard feature van C++?

Ik krijg opeens enorm veel zin in C++

[Verwijderd]

Ik gok dat hij een soort preparser gebruikt, aangezien volgens mij 'var' niet in C++ zit.
Dat, of er is magie met klassen.

[Gamebuster]

Wat het ook is, ik wil het ook

[Arjan]

Verwijderd schreef op zaterdag 02 april 2011 @ 13:39:

C++:

int b(int x, int y) { return x + y; }
int (*a)(int, int) = b;

http://codepad.org/w3SsFpMJ

Zou gewoon moeten werken. Function pointers zaten al in C.

Dat is mij bekend
Ik zoek echter naar een manier om deze zoals bij JS te gebruiken.

In C++0x zitten zelfs lambda's, waarmee je als het goed is het volgende zou kunnen doen:

C++:

int (*b)(int, int) = [](int x, int y) { return x + y; }

Dat komt al een stuk meer in de richting, aanvankelijk wilde ik het echter nog met de 'oude' c++ standaard oplossen, dat is echter verder geen vereiste natuurlijk

Verwijderd schreef op zaterdag 02 april 2011 @ 13:45:
Oh, en over 'var' gesproken: C++0x heeft daar 'auto' voor.

Tja, hier geldt hetzelfde, al kun je met auto niet precies hetzelfde bereiken, omdat verschillende types in JS bijvoorbeeld anders reageren als ze als string uitgelezen worden.

Gamebuster schreef op zaterdag 02 april 2011 @ 13:47:
Hoe kom je aan die var's?
Is dat een standaard feature van C++?

Ik krijg opeens enorm veel zin in C++

Verwijderd schreef op zaterdag 02 april 2011 @ 13:49:
Ik gok dat hij een soort preparser gebruikt, aangezien volgens mij 'var' niet in C++ zit.
Dat, of er is magie met klassen.

Dan kies ik voor de optie van 'magie met klassen'

Wat ik nu doe;

Er is een class genaamd 'BaseObject' Dit is het basis object waar alle andere klassen van afgeleid zijn. Dan is er de Undefined class, deze heeft een pointer naar een BaseObject als member.

De Undefined klasse fungeert als interface, alle operaties komen hier eerst op binnen en worden via polymorfisme naar de daadwerkelijke implementatie gestuurd.

oh, en typedef Undefined var;

[Verwijderd]

I see, netjes.

Om 'echte' javascript syntax te nabootsen, kun je ook gewoon het volgende doen:

C++:

#define function []

Zo kun je het volgende doen:

C++:

int (*a)(int, int) = function(int x, int y) { return x + y; }

[MLM]

Verwijderd schreef op zaterdag 02 april 2011 @ 18:27:
I see, netjes.

Om 'echte' javascript syntax te nabootsen, kun je ook gewoon het volgende doen:

C++:

#define function []

Zo kun je het volgende doen:

C++:

int (*a)(int, int) = function(int x, int y) { return x + y; }

Als we dan toch de C++0x gaan doen:

C++:

#define function []
#define var auto

Zo kun je het volgende doen:

C++:

var a = function(int x, int y) { return x + y; }

[Gamebuster]

Houd je dit project voor jezelf of zou je het willen delen?

[Arjan]

Gamebuster schreef op zaterdag 02 april 2011 @ 18:47:
Houd je dit project voor jezelf of zou je het willen delen?

al mijn eigen projectjes zijn open source, ik zet vanavond een eerste versie online, maakt meedenken wat makkelijker

[.oisyn]

Verwijderd schreef op zaterdag 02 april 2011 @ 13:45:
Oh, en over 'var' gesproken: C++0x heeft daar 'auto' voor.

'var' zoals gepresenteerd door Arjan en 'auto' van C++0x zijn echt twee compleet verschillende dingen. 'var' is een loosely typed variabele, 'auto' is static type inference.

.edit: oh wacht dat was al duidelijk

Wat functies betreft, het wordt lastig denk ik. Overload var::operator() die 0 of meer vars accepteert, en reroute de call naar de virtual BaseObject::Call(). Die implementatie is voor een functor is dan een template die werkt op het type wat aan de var geassigned is, waarvoor je dus een generieke operator=(T) nodig hebt, wat wellicht voor een hoop kopzorgen gaat zorgen - en je moet zorgen dat de implementatie van Call() wel compilet als je op die T helemaal geen operator() hebt.

C++ Concepts had je hier enorm kunnen helpen, maar helaas . Wat ik écht een gemisten kans vind van lambda's is dat de signature niet deduceerbaar is.

[ Voor 51% gewijzigd door .oisyn op 03-04-2011 02:17 ]

[Verwijderd]

.oisyn schreef op zondag 03 april 2011 @ 01:05:
[...]

'var' zoals gepresenteerd door Arjan en 'auto' van C++0x zijn echt twee compleet verschillende dingen. 'var' is een loosely typed variabele, 'auto' is static type inference.

Klopt, dat was my bad. Excuses.

[Arjan]

Arjan schreef op zaterdag 02 april 2011 @ 19:59:
[...]

al mijn eigen projectjes zijn open source, ik zet vanavond een eerste versie online, maakt meedenken wat makkelijker

Dit duurt even iets langer, ik wil nog wat aanpassingen maken alvorens 'm publiek te gooien.

.oisyn schreef op zondag 03 april 2011 @ 01:05:
[...]
Wat functies betreft, het wordt lastig denk ik. Overload var::operator() die 0 of meer vars accepteert, en reroute de call naar de virtual BaseObject::Call(). Die implementatie is voor een functor is dan een template die werkt op het type wat aan de var geassigned is, waarvoor je dus een generieke operator=(T) nodig hebt, wat wellicht voor een hoop kopzorgen gaat zorgen - en je moet zorgen dat de implementatie van Call() wel compilet als je op die T helemaal geen operator() hebt.
[...]

Ik snap niet precies wat je bedoeld, wat mij persoonlijk het grootste probleem lijkt is het feit dat het aantal parameters niet vaststaat. var heeft al een = operator die built-ins accepteerd, of bedoel je dat niet?

[.oisyn]

Ik bedoel zoiets:

C++:

class BaseObject
{
    // ...

    virtual var Call(const std::vector<var> & vars) = 0;
};

template<class T, class SIG>
class FunctionObject;

/* voorbeeld voor 2 params, de overige moet je ook maken, en rekening houden
met het feit dat een functie ook void kan returnen */
template<class T, class R, class P1, class P2>
class FunctionObject<T, R(P1, P2)>
{
    FunctionObject(T func) : m_func(func) { }

    // ...

    virtual var Call(const std::vector<var> & vars)
    {
        if (vars.size() != 2)
            throw NotEnoughArgumentsException();

        return m_func(static_cast<P1>(vars[0]), static_cast<P2>(vars[1]));
    }

private:
    T m_func;
};

class var
{
    // ...

    var operator()(var v1, var v2) const
    {
        std::vector<var> vars(2);
        vars[0] = v1;
        vars[1] = v2;
        return m_pBaseObject->Call(vars);
    }

    template<class T> var & operator=(T func)
    {
        typedef typename een_constructie_die_de_sig_van_T_bepaalt<T>::type SIG;
        m_pBaseObject = new FunctionObject<T, SIG>(func);
        return *this;
    }
};

Nadeel is dus de operator= die ineens alles accepteert (al zou dat op te lossen zijn met enable_if), en de lastigheid van het bepalen van signatures gegeven generieke functors. Je zou ervoor kunnen kiezen om alleen function pointers en std::function<SIG> te accepteren en geen generieke functors, maar dat betekent dat je voor lambda's expliciet moet casten.

[ Voor 18% gewijzigd door .oisyn op 03-04-2011 23:47 ]

[Arjan]

Volgens mij kan het nog makkelijker door alleen var's te accepteren, ik heb mijn broncode online gegooid via git:
git://houbenweb.nl/JS++

Voor functies zit er momenteel nog niets in, behalve een () operator die 10 optionele var's ( Undefined ) accepteert.

Ik heb naar aanleiding van .oisyn's code een idee voor een mogelijke implementatie, morgen maar eens proberen

[Gamebuster]

Kan je bij C++ niet het ophalen van een length-property de getLength method laten gebruiken?

Ik zie een .getLength method, maar geen .length property.

[Arjan]

Gamebuster schreef op maandag 04 april 2011 @ 02:13:
Kan je bij C++ niet het ophalen van een length-property de getLength method laten gebruiken?

Ik zie een .getLength method, maar geen .length property.

De implementatie ontbrak, maar de property was er wel. Heb de implementatie nu toegevoegd.

[.oisyn]

C++ heeft geen properties.

[Arjan]

Tja, strikt genomen is de Length uit de Undefined classe natuurlijk geen property, maar in dagelijks gebruik is deze prima te gebruiken alsof het een readonly property is.
Het mooiste zou zijn om Length te laten overerven van een Number, maar dat gaat natuurlijk niet werken

[.oisyn]

Oh ja ik kan je code niet zien, heb geen git client

[Gamebuster]

offtopic:
Waarom heb je Undefined de Length-property gegeven?
Length (eigenlijk length, met kleine L) zit alleen in String en Array, zover ik weet.

[.oisyn]

Zodat je de length op een var kunt aanroepen.

[Arjan]

voor de git-lozen: http://houbenweb.nl/JS++/

[.oisyn]

Clever, die truc met de union

[Arjan]

Die had ik bedacht naar aanleiding van \[C++] Swizzling implementatie operators
Ik was er zelf ook wel blij mee

[user109731]

Ik kwam net deze blogpost tegen: http://blog.vjeux.com/201...-cpp-into-javascript.html

Precies hetzelfde idee, misschien interessant om jullie implementaties te vergelijken

[ Voor 9% gewijzigd door user109731 op 25-04-2011 17:36 ]

[Devilly]

Arjan schreef op maandag 04 april 2011 @ 15:08:
voor de git-lozen: http://houbenweb.nl/JS++/

Oops! This link appears to be broken.

[Arjan]

JanDM schreef op maandag 25 april 2011 @ 17:36:
Ik kwam net deze blogpost tegen: http://blog.vjeux.com/201...-cpp-into-javascript.html

Precies hetzelfde idee, misschien interessant om jullie implementaties te vergelijken

Ziet er mooi uit, ga het eens bekijken

Devilly schreef op maandag 25 april 2011 @ 19:07:
[...]

gefixt