Valid HTML 4.01!

Valid CSS!
www.oisyn.nl news whois projects forum new user

questa at 1-03-07 15:23
AAADDDS! * click

Woudloper at 24-01-07 11:58
Zag de ads! Heb er nog op één geklikt omdat er iets interessants tussenstond :)

.oisyn at 23-01-07 15:46
Aangezien ik zowaar visitors heb, even wat ads toegevoegd :+

Woudloper at 8-01-07 8:02
Met de UBB Parser aan het stoeien

Woudloper at 5-01-07 10:22
Nieuwe reactie toegevoegd bij het artikel over UBB Parser

Spockz at 31-12-06 12:42
Ja, dit werkt nog hoor. :)

.oisyn at 28-12-06 16:37
Werkt dit nog?

questa at 21-11-05 15:15
*gaap

Grubolsch at 9-06-05 17:12
Bedankt om dit alles open source te maken, ik vermeld je zeker op mijn website! Echt knap werk!

Grubolsch at 9-06-05 17:12
.oisyn, ik moet zeggen dat ik je parser enorm knap vind, en ook je syntacs highlighter!

questa at 8-02-05 13:52
Jammer dat het nooit af komt, maar vertel is meer over je nieuwe baan!!!

.oisyn at 17-05-04 15:28
Dat laatste, weinig tijd enzo. Eerlijk gezegd denk ik niet dat het ooit nog geimplementeerd wordt :/

koli-man at 11-05-04 22:38
Is er eigenlijk nog Orbb nieuws of staat project een beetje stil?

.oisyn at 2-04-04 18:38
/me doet maar weer eens een update :P

eamelink at 1-02-04 11:27
*kick* ;)

questa at 8-12-03 22:16
Kom op, pronken met die zooi!!!

curry684 at 4-12-03 14:04
En waar is de sourcecode van Orbb? Doe eens treehugging opensource hippie uithangen!

questa at 1-12-03 12:49
Damz.. dan maar even hopen dat de compiler snel aan ze 1.0 versie komt :) dan is Questa weer blij!

coubertin119 at 12-11-03 18:32
Pff, ik ben gewoon ongeduldig ;)

.oisyn at 12-11-03 18:29
Wat boeit dat? Je hebt er toch niets aan zolang er geen compiler is ;)

Active articles#

Kol Q l8or 2 beta 4
Code syntax highlighter (php module) 21
UBB Parser (PHP code) 9
Compile-time sqrt in C++ 3
Experiment #1 2
More dynamics :) 3
Interfacing Orbb with C++ 1
Site migrated 0
Integer division using binary long division method 0
Nieuwe forum online 0
Not logged in

Projects / Orbb / Interfacing Orbb with C++


Interfacing Orbb with C++
Tue 28 Oct 2003 17:20 by .oisyn

Ik gooi gewoon maar even wat C++ code neer
Antwoorden op verzoek


Orbb biedt (ongeveer) deze functionaliteit voor C++ developers:

c++:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
enum OrbbType
{
    T_NULL,
    T_INT,
    T_FLOAT,
    T_STRING,
    T_OBJECT,
    T_ARRAY,
    T_VAR,      // not used for Variable

    // special types for in namespaces
    T_NAMESPACE,
    T_CLASS,
    T_FUNCTION,
    T_CONSTRUCTOR,
    T_DESTRUCTOR,

    T_ENDPARAMS = 0xff  // only for FunctionDefinition
};


enum OrbbAccess
{
    A_PRIVATE,
    A_PROTECTED,
    A_PUBLIC,

    A_INSTANCE  = 0x40,
    A_ABSTRACT  = 0x80      // only valid in combination with A_INSTANCE
};


class Variable
{
public:
    OrbbType        getType ();
    int             asInt ();
    float           asFloat ();
    OrbbString *    asString ();
    OrbbObject *    asObject ();
    OrbbArray *     asArray ();

    bool            setNull ();
    bool            set (int);
    bool            set (float);
    bool            set (OrbbString *);
    bool            set (OrbbObject *);
    bool            set (OrbbArray *);
};


class ParamStream
{
public:
    int             numParams () const;
    OrbbType        nextType () const;
    int             nextInt () const;
    float           nextFloat () const;
    OrbbString *    nextString () const;
    OrbbObject *    nextObject () const;
    OrbbArray *     nextArray () const;
    Variable        nextVar () const;       // only a wrapper function

    void            putNull ();
    void            put (int);
    void            put (float);
    void            put (OrbbString *);
    void            put (OrbbObject *);
    void            put (OrbbArray *);
    void            put (Variable);         // only a wrapper function
};


class FunctionDefinition
{
public:
    FunctionDefinition (Variable (*pFunc) (const ParamStream &), OrbbType * params);        // create native function
    FunctionDefinition (Variable (*pFunc) (OrbbObject *, const ParamStream &), OrbbType * params);  // create native class method
    FunctionDefinition (void * orbbCodebool methodOrbbType * params);                   // create function from compiled orbb code

    bool            isNative () const;
    bool            isMethod () const;
    const OrbbType *getParameters () const;
    void *          getDataPtr () const;

    Variable        call (const ParamStream &);
};


struct Identifier
{
    OrbbType        type;
    OrbbAccess      access;
    int             index;
};


class Namespace
{
public:
    Namespace (const std::string & name);

    const std::string & getName () const;

    bool findIdentifier (const std::string & nameIdentifier &) const;
    void * getIdentData (int index);

    virtual bool addIdentifier (const std::string & nameOrbbType typeOrbbAccess accessvoid * data);
};


class ClassDefinition : public Namespace
{
public:
    ClassDefinition (const std::string & nameClassDefinition ** superClasses);

    bool instantiatable () const;
    OrbbObject * instantiate (const ParamStream &) const;

    bool addIdentifier (const std::string & nameOrbbType typeOrbbAccess accessvoid * data);
};





De calling convention van een C++ functie ziet er zo uit:

c++:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/* * * * * * * * Calling convention * * * * * * * * */

// public function myFunc (int, float)
Variable myFunc (const ParamStream & stream)
{
    std::cout << "param 1: " << stream.nextInt () << std::endl;
    std::cout << "param 2: " << stream.nextFloat () << std::endl;

    return T_NULL;
}


/*
this C++ class corresponds with the following Orbb code:

    class MyClass
    {
        public int i;
        public static var x;

        public function instanceFunc ();
    }
*/

Variable MyClass_instanceFunc (OrbbObject * objectconst ParamStream & stream)
{
    ClassDefinition * def = object->getClassDefinition ();

    Identifier id_iid_x;
    def->findIdentifier ("i"id_i);    // should return { T_INT, A_PUBLIC | A_INSTANCE, -1 }
    def->findIdentifier ("x"id_x);    // should return { T_VAR, A_PUBLIC | A_INSTANCE, 0 }

    int * i = object->getVarData (id_i.index);
    Variable * x = def->getIdentData (id_x.index);

    std::cout << "i: " << *i << std::endl;
    std::cout << "x: " << *x << std::endl;
}


// registering definitions
void reg ()
{
    Namespace * global = Orbb::getGlobalNamespace ();

    OrbbType myFuncParams[] = { T_INTT_FLOATT_ENDPARAMS };
    global->addIdentifier ("myFunc"T_FUNCTIONA_PUBLICnew FunctionDefinition (&myFuncmyFuncParams));

    ClassDefinition * myClassDef = new ClassDefinition ("MyClass"0);
    myClassDef->addIdentifier ("i"T_INTA_PUBLIC | A_INSTANCE0);
    myClassDef->addIdentifier ("x"T_VARA_PUBLICnew Variable ());
    OrbbType instanceFuncParams[] = { T_ENDPARAMS };
    myClassDef->addIdentifier ("instanceFunc"T_FUNCTIONA_PUBLIC | A_INSTANCEnew FunctionDefinition (&MyClass_instanceFuncinstanceFuncParams));

    global->addIdentifier (myClassDef->getName (), T_CLASSA_PUBLICmyClassDef);
}



Schiet maar

1 comment - 1 page
Post comment


Comments


Wed 12 Nov 2003 12:46 by questa

Benchmark... ik zou er is even mee gaan prutsen *als ik tijd heb*, ik zal wel is even kijken of deze geweldige uitkomst ook echt zo geweldig is!


Post comment


You must be logged in to post a comment