Skip to content

Commit 28ed391

Browse files
kripkenkripken
committed
webidl binder
1 parent 55c1dfd commit 28ed391

File tree

10 files changed

+5792
-1
lines changed

10 files changed

+5792
-1
lines changed

‎src/settings.js

+1-1
Original file line numberDiff line numberDiff line change
@@ -338,7 +338,7 @@ var EXPORTED_FUNCTIONS = ['_main', '_malloc'];
338338
var EXPORT_ALL = 0; // If true, we export all the symbols. Note that this does *not* affect LLVM, so it can
339339
// still eliminate functions as dead. This just exports them on the Module object.
340340
var EXPORT_BINDINGS = 0; // Export all bindings generator functions (prefixed with emscripten_bind_). This
341-
// is necessary to use the bindings generator with asm.js
341+
// is necessary to use the WebIDL binder or bindings generator with asm.js
342342
var RETAIN_COMPILER_SETTINGS = 0; // Remembers the values of these settings, and makes them accessible
343343
// through Runtime.getCompilerSetting and emscripten_get_compiler_setting.
344344
// To see what is retained, look for compilerSettings in the generated code.

‎tests/test_core.py

+16
Original file line numberDiff line numberDiff line change
@@ -5971,6 +5971,22 @@ def process(filename):
59715971
'''
59725972
self.do_run(src, '|hello|43|world|41|', post_build=post)
59735973

5974+
def test_webidl(self):
5975+
if self.emcc_args is None: return self.skip('requires emcc')
5976+
5977+
output = Popen([PYTHON, path_from_root('tools', 'webidl_binder.py'),
5978+
path_from_root('tests', 'webidl', 'test.idl'),
5979+
'glue']).communicate()[0]
5980+
assert os.path.exists('glue.cpp')
5981+
assert os.path.exists('glue.js')
5982+
5983+
self.emcc_args += ['--post-js', 'glue.js',
5984+
'--post-js', path_from_root('tests', 'webidl', 'post.js')]
5985+
shutil.copyfile(path_from_root('tests', 'webidl', 'test.h'), self.in_dir('test.h'))
5986+
shutil.copyfile(path_from_root('tests', 'webidl', 'test.cpp'), self.in_dir('test.cpp'))
5987+
src = open('test.cpp').read()
5988+
self.do_run(src, open(path_from_root('tests', 'webidl', 'output.txt')).read())
5989+
59745990
def test_typeinfo(self):
59755991
if os.environ.get('EMCC_FAST_COMPILER') != '0': return self.skip('fastcomp does not support RUNTIME_TYPE_INFO')
59765992

‎tests/webidl/output.txt

+56
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
Parent:42
2+
*
3+
84
4+
c1
5+
Parent:7
6+
Child1:7
7+
7
8+
14
9+
196
10+
588
11+
14
12+
28
13+
c1 v2
14+
Parent:16
15+
Child1:15
16+
15
17+
30
18+
900
19+
2700
20+
c2
21+
Parent:9
22+
Child2:9
23+
9
24+
18
25+
5832
26+
0
27+
0
28+
1
29+
*static*
30+
*virtualf*
31+
*virtualf*
32+
*virtualf2*
33+
Parent:9
34+
Child2:9
35+
*js virtualf replacement*
36+
*js virtualf replacement*
37+
*js virtualf2 replacement*
38+
*js virtualf3 replacement 123*
39+
caught: a JSImplementation must implement all functions, you forgot Child2JS::virtualFunc4.
40+
*virtualf*
41+
*virtualf*
42+
*virtualf2*
43+
*ok*
44+
|hello|43|world|41|
45+
12.35
46+
10
47+
object
48+
10
49+
11
50+
object
51+
10
52+
11
53+
21.12
54+
198
55+
56+
done.

‎tests/webidl/post.js

+117
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,117 @@
1+
2+
// Part 1
3+
4+
var sme = new Module.Parent(42);
5+
sme.mulVal(2);
6+
Module.print('*')
7+
Module.print(sme.getVal());
8+
9+
Module.print('c1');
10+
11+
var c1 = new Module.Child1();
12+
Module.print(c1.getVal());
13+
c1.mulVal(2);
14+
Module.print(c1.getVal());
15+
Module.print(c1.getValSqr());
16+
Module.print(c1.getValSqr(3));
17+
Module.print(c1.getValTimes()); // default argument should be 1
18+
Module.print(c1.getValTimes(2));
19+
20+
Module.print('c1 v2');
21+
22+
c1 = new Module.Child1(8); // now with a parameter, we should handle the overloading automatically and properly and use constructor #2
23+
Module.print(c1.getVal());
24+
c1.mulVal(2);
25+
Module.print(c1.getVal());
26+
Module.print(c1.getValSqr());
27+
Module.print(c1.getValSqr(3));
28+
29+
Module.print('c2')
30+
31+
var c2 = new Module.Child2();
32+
Module.print(c2.getVal());
33+
c2.mulVal(2);
34+
Module.print(c2.getVal());
35+
Module.print(c2.getValCube());
36+
var succeeded;
37+
try {
38+
succeeded = 0;
39+
Module.print(c2.doSomethingSecret()); // should fail since private
40+
succeeded = 1;
41+
} catch(e) {}
42+
Module.print(succeeded);
43+
try {
44+
succeeded = 0;
45+
Module.print(c2.getValSqr()); // function from the other class
46+
succeeded = 1;
47+
} catch(e) {}
48+
Module.print(succeeded);
49+
try {
50+
succeeded = 0;
51+
c2.getValCube(); // sanity
52+
succeeded = 1;
53+
} catch(e) {}
54+
Module.print(succeeded);
55+
56+
Module.Child2.prototype.printStatic(); // static calls go through the prototype
57+
58+
// virtual function
59+
c2.virtualFunc();
60+
Module.Child2.prototype.runVirtualFunc(c2);
61+
c2.virtualFunc2();
62+
63+
// extend a class from JS
64+
var c3 = new Module.Child2JS;
65+
66+
c3.virtualFunc = function() {
67+
Module.print('*js virtualf replacement*');
68+
};
69+
c3.virtualFunc2 = function() {
70+
Module.print('*js virtualf2 replacement*');
71+
};
72+
c3.virtualFunc3 = function(x) {
73+
Module.print('*js virtualf3 replacement ' + x + '*');
74+
};
75+
76+
c3.virtualFunc();
77+
Module.Child2.prototype.runVirtualFunc(c3);
78+
c3.virtualFunc2();
79+
c3.virtualFunc3(123); // this one is not replaced!
80+
try {
81+
c3.virtualFunc4(123);
82+
} catch(e) {
83+
Module.print('caught: ' + e);
84+
}
85+
86+
c2.virtualFunc(); // original should remain the same
87+
Module.Child2.prototype.runVirtualFunc(c2);
88+
c2.virtualFunc2();
89+
Module.print('*ok*');
90+
91+
// Part 2
92+
93+
var suser = new Module.StringUser("hello", 43);
94+
suser.Print(41, "world");
95+
suser.PrintFloat(12.3456);
96+
97+
var bv = new Module.RefUser(10);
98+
var bv2 = new Module.RefUser(11);
99+
Module.print(bv2.getValue(bv));
100+
101+
Module.print(typeof bv2.getMe());
102+
Module.print(bv2.getMe().getValue(bv));
103+
Module.print(bv2.getMe().getValue(bv2));
104+
105+
Module.print(typeof bv2.getCopy());
106+
Module.print(bv2.getCopy().getValue(bv));
107+
Module.print(bv2.getCopy().getValue(bv2));
108+
109+
bv2.getAnother().PrintFloat(21.12);
110+
111+
Module.print(new Module.Inner().get());
112+
new Module.Inner().mul(2);
113+
114+
//
115+
116+
Module.print('\ndone.')
117+

‎tests/webidl/test.cpp

+8
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
#include "test.h"
2+
3+
Parent::Parent(int val) : value(val) { printf("Parent:%d\n", val); }
4+
Parent::Parent(Parent *p, Parent *q) : value(p->value + q->value) { printf("Parent:%d\n", value); }
5+
void Parent::mulVal(int mul) { value *= mul; }
6+
7+
#include "glue.cpp"
8+

‎tests/webidl/test.h

+72
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,72 @@
1+
#include <stdio.h>
2+
3+
// Part 1
4+
5+
class Parent {
6+
protected:
7+
int value;
8+
public:
9+
Parent(int val);
10+
Parent(Parent *p, Parent *q); // overload constructor
11+
int getVal() { return value; }; // inline should work just fine here, unlike Way 1 before
12+
void mulVal(int mul);
13+
};
14+
15+
class Child1 : public Parent {
16+
public:
17+
Child1() : Parent(7) { printf("Child1:%d\n", value); };
18+
Child1(int val) : Parent(val*2) { value -= 1; printf("Child1:%d\n", value); };
19+
int getValSqr() { return value*value; }
20+
int getValSqr(int more) { return value*value*more; }
21+
int getValTimes(int times=1) { return value*times; }
22+
};
23+
24+
// Child2 has vtable, parent does not. Checks we cast child->parent properly - (Parent*)child is not a no-op, must offset
25+
class Child2 : public Parent {
26+
public:
27+
Child2() : Parent(9) { printf("Child2:%d\n", value); };
28+
int getValCube() { return value*value*value; }
29+
static void printStatic() { printf("*static*\n"); }
30+
31+
virtual void virtualFunc() { printf("*virtualf*\n"); }
32+
virtual void virtualFunc2() { printf("*virtualf2*\n"); }
33+
static void runVirtualFunc(Child2 *self) { self->virtualFunc(); };
34+
virtual void virtualFunc3(int x) { printf("*virtualf3: %d*\n", x); }
35+
virtual void virtualFunc4(int x) { printf("*virtualf4: %d*\n", x); }
36+
37+
private:
38+
void doSomethingSecret() { printf("security breached!\n"); }; // we should not be able to do this
39+
};
40+
41+
// Part 2
42+
43+
#include <string.h>
44+
45+
class StringUser {
46+
char *s;
47+
int i;
48+
public:
49+
StringUser(char *string="NO", int integer=99) : s(strdup(string)), i(integer) {}
50+
void Print(int anotherInteger, char *anotherString) {
51+
printf("|%s|%d|%s|%d|\n", s, i, anotherString, anotherInteger);
52+
}
53+
void PrintFloat(float f) { printf("%.2f\n", f); }
54+
};
55+
56+
struct RefUser {
57+
int value;
58+
RefUser(int x = 77) : value(x) {}
59+
int getValue(RefUser b) { return b.value; }
60+
RefUser &getMe() { return *this; }
61+
RefUser getCopy() { return RefUser(value*2); }
62+
StringUser getAnother() { return StringUser("another", 5); }
63+
};
64+
65+
namespace Space {
66+
struct Inner {
67+
Inner() {}
68+
int get() { return 198; }
69+
Inner& operator*=(float x) { return *this; }
70+
};
71+
}
72+

‎tests/webidl/test.idl

+64
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,64 @@
1+
2+
// Part 1
3+
4+
interface Parent {
5+
void Parent(long val);
6+
long getVal();
7+
void mulVal(long mul);
8+
};
9+
10+
interface Child1 {
11+
void Child1(optional long val);
12+
long getValSqr(optional long more);
13+
long getValTimes(optional long times=1);
14+
};
15+
16+
Child1 implements Parent;
17+
18+
interface Child2 {
19+
void Child2();
20+
long getValCube();
21+
static void printStatic();
22+
void virtualFunc();
23+
void virtualFunc2();
24+
void virtualFunc3(long x);
25+
void virtualFunc4(long x);
26+
static void runVirtualFunc(Child2 self);
27+
};
28+
29+
Child2 implements Parent;
30+
31+
[JSImplementation="Child2"]
32+
interface Child2JS {
33+
void Child2JS();
34+
void virtualFunc();
35+
void virtualFunc2();
36+
void virtualFunc3(long x);
37+
void virtualFunc4(long x);
38+
};
39+
40+
// Part 2
41+
42+
interface StringUser {
43+
void StringUser();
44+
void StringUser(DOMString str, long i);
45+
void Print(long anotherInteger, DOMString anotherString);
46+
void PrintFloat(float f);
47+
};
48+
49+
interface RefUser {
50+
void RefUser();
51+
void RefUser(long value);
52+
long getValue([Ref] RefUser b);
53+
[Ref] RefUser getMe();
54+
[Value] RefUser getCopy(); // must have zero-arg constructor
55+
[Value] StringUser getAnother();
56+
};
57+
58+
[Prefix="Space::"]
59+
interface Inner {
60+
void Inner();
61+
long get();
62+
[Operator="*=", Ref] Inner mul(float x);
63+
};
64+

0 commit comments

Comments
 (0)