← Back to branch summary

~ubuntu-branches/ubuntu/vivid/nqp/vivid-proposed

« back to all changes in this revision

Viewing changes to src/pmc/ownedresizablepmcarray.pmc

  • Committer: Package Import Robot
  • Author(s): Alessandro Ghedini
  • Date: 2013-11-01 12:09:18 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20131101120918-kx51sl0sxl3exsxi
Tags: 2013.10-1
* New upstream release
* Bump versioned (Build-)Depends on parrot
* Update patches
* Install new README.pod
* Fix vcs-field-not-canonical
* Do not install rubyish examples
* Do not Depends on parrot-devel anymore
* Add 07_disable-serialization-tests.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pmc/ownedresizablepmcarray.pmc
1
 
/* Represents a ResizablePMCArray that is owned by a serialization context.
2
 
 * If it gets modified, we need to trigger the SC write barrier. */
3
 
 
4
 
#include "../6model/sixmodelobject.h"
5
 
 
6
 
pmclass OwnedResizablePMCArray extends ResizablePMCArray provides array auto_attrs dynpmc group nqp {
7
 
    /* The object that owns this RPA. */
8
 
    ATTR PMC *owner;
9
 
    
10
 
    VTABLE void set_integer_keyed(PMC* key, INTVAL value) {
11
 
        PMC *owner;
12
 
        GET_ATTR_owner(interp, SELF, owner);
13
 
        if (!PMC_IS_NULL(owner))
14
 
            OBJ_SC_WRITE_BARRIER(owner);
15
 
        SUPER(key, value);
16
 
    }
17
 
    VTABLE void set_integer_keyed_int(INTVAL key, INTVAL value) {
18
 
        PMC *owner;
19
 
        GET_ATTR_owner(interp, SELF, owner);
20
 
        if (!PMC_IS_NULL(owner))
21
 
            OBJ_SC_WRITE_BARRIER(owner);
22
 
        SUPER(key, value);
23
 
    }
24
 
    VTABLE void set_integer_keyed_str(STRING* key, INTVAL value) {
25
 
        PMC *owner;
26
 
        GET_ATTR_owner(interp, SELF, owner);
27
 
        if (!PMC_IS_NULL(owner))
28
 
            OBJ_SC_WRITE_BARRIER(owner);
29
 
        SUPER(key, value);
30
 
    }
31
 
 
32
 
    VTABLE void set_number_keyed(PMC* key, FLOATVAL value) {
33
 
        PMC *owner;
34
 
        GET_ATTR_owner(interp, SELF, owner);
35
 
        if (!PMC_IS_NULL(owner))
36
 
            OBJ_SC_WRITE_BARRIER(owner);
37
 
        SUPER(key, value);
38
 
    }
39
 
    VTABLE void set_number_keyed_int(INTVAL key, FLOATVAL value) {
40
 
        PMC *owner;
41
 
        GET_ATTR_owner(interp, SELF, owner);
42
 
        if (!PMC_IS_NULL(owner))
43
 
            OBJ_SC_WRITE_BARRIER(owner);
44
 
        SUPER(key, value);
45
 
    }
46
 
    VTABLE void set_number_keyed_str(STRING* key, FLOATVAL value) {
47
 
        PMC *owner;
48
 
        GET_ATTR_owner(interp, SELF, owner);
49
 
        if (!PMC_IS_NULL(owner))
50
 
            OBJ_SC_WRITE_BARRIER(owner);
51
 
        SUPER(key, value);
52
 
    }
53
 
 
54
 
    VTABLE void set_string_keyed(PMC* key, STRING* value) {
55
 
        PMC *owner;
56
 
        GET_ATTR_owner(interp, SELF, owner);
57
 
        if (!PMC_IS_NULL(owner))
58
 
            OBJ_SC_WRITE_BARRIER(owner);
59
 
        SUPER(key, value);
60
 
    }
61
 
    VTABLE void set_string_keyed_int(INTVAL key, STRING* value) {
62
 
        PMC *owner;
63
 
        GET_ATTR_owner(interp, SELF, owner);
64
 
        if (!PMC_IS_NULL(owner))
65
 
            OBJ_SC_WRITE_BARRIER(owner);
66
 
        SUPER(key, value);
67
 
    }
68
 
    VTABLE void set_string_keyed_str(STRING* key, STRING* value) {
69
 
        PMC *owner;
70
 
        GET_ATTR_owner(interp, SELF, owner);
71
 
        if (!PMC_IS_NULL(owner))
72
 
            OBJ_SC_WRITE_BARRIER(owner);
73
 
        SUPER(key, value);
74
 
    }
75
 
    
76
 
    VTABLE void set_pmc_keyed(PMC* key, PMC* value) {
77
 
        PMC *owner;
78
 
        GET_ATTR_owner(interp, SELF, owner);
79
 
        if (!PMC_IS_NULL(owner))
80
 
            OBJ_SC_WRITE_BARRIER(owner);
81
 
        SUPER(key, value);
82
 
    }
83
 
    VTABLE void set_pmc_keyed_int(INTVAL key, PMC* value) {
84
 
        PMC *owner;
85
 
        GET_ATTR_owner(interp, SELF, owner);
86
 
        if (!PMC_IS_NULL(owner))
87
 
            OBJ_SC_WRITE_BARRIER(owner);
88
 
        SUPER(key, value);
89
 
    }
90
 
    VTABLE void set_pmc_keyed_str(STRING* key, PMC* value) {
91
 
        PMC *owner;
92
 
        GET_ATTR_owner(interp, SELF, owner);
93
 
        if (!PMC_IS_NULL(owner))
94
 
            OBJ_SC_WRITE_BARRIER(owner);
95
 
        SUPER(key, value);
96
 
    }
97
 
    
98
 
    VTABLE INTVAL pop_integer() {
99
 
        PMC *owner;
100
 
        GET_ATTR_owner(interp, SELF, owner);
101
 
        if (!PMC_IS_NULL(owner))
102
 
            OBJ_SC_WRITE_BARRIER(owner);
103
 
        return SUPER();
104
 
    }
105
 
    VTABLE FLOATVAL pop_float() {
106
 
        PMC *owner;
107
 
        GET_ATTR_owner(interp, SELF, owner);
108
 
        if (!PMC_IS_NULL(owner))
109
 
            OBJ_SC_WRITE_BARRIER(owner);
110
 
        return SUPER();
111
 
    }
112
 
    VTABLE STRING* pop_string() {
113
 
        PMC *owner;
114
 
        GET_ATTR_owner(interp, SELF, owner);
115
 
        if (!PMC_IS_NULL(owner))
116
 
            OBJ_SC_WRITE_BARRIER(owner);
117
 
        return SUPER();
118
 
    }
119
 
    VTABLE PMC* pop_pmc() {
120
 
        PMC *owner;
121
 
        GET_ATTR_owner(interp, SELF, owner);
122
 
        if (!PMC_IS_NULL(owner))
123
 
            OBJ_SC_WRITE_BARRIER(owner);
124
 
        return SUPER();
125
 
    }
126
 
 
127
 
    VTABLE void push_integer(INTVAL value) {
128
 
        PMC *owner;
129
 
        GET_ATTR_owner(interp, SELF, owner);
130
 
        if (!PMC_IS_NULL(owner))
131
 
            OBJ_SC_WRITE_BARRIER(owner);
132
 
        SUPER(value);
133
 
    }
134
 
    VTABLE void push_float(FLOATVAL value) {
135
 
        PMC *owner;
136
 
        GET_ATTR_owner(interp, SELF, owner);
137
 
        if (!PMC_IS_NULL(owner))
138
 
            OBJ_SC_WRITE_BARRIER(owner);
139
 
        SUPER(value);
140
 
    }
141
 
    VTABLE void push_string(STRING* value) {
142
 
        PMC *owner;
143
 
        GET_ATTR_owner(interp, SELF, owner);
144
 
        if (!PMC_IS_NULL(owner))
145
 
            OBJ_SC_WRITE_BARRIER(owner);
146
 
        SUPER(value);
147
 
    }
148
 
    VTABLE void push_pmc(PMC* value) {
149
 
        PMC *owner;
150
 
        GET_ATTR_owner(interp, SELF, owner);
151
 
        if (!PMC_IS_NULL(owner))
152
 
            OBJ_SC_WRITE_BARRIER(owner);
153
 
        SUPER(value);
154
 
    }
155
 
 
156
 
    VTABLE INTVAL shift_integer() {
157
 
        PMC *owner;
158
 
        GET_ATTR_owner(interp, SELF, owner);
159
 
        if (!PMC_IS_NULL(owner))
160
 
            OBJ_SC_WRITE_BARRIER(owner);
161
 
        return SUPER();
162
 
    }
163
 
    VTABLE FLOATVAL shift_float() {
164
 
        PMC *owner;
165
 
        GET_ATTR_owner(interp, SELF, owner);
166
 
        if (!PMC_IS_NULL(owner))
167
 
            OBJ_SC_WRITE_BARRIER(owner);
168
 
        return SUPER();
169
 
    }
170
 
    VTABLE STRING* shift_string() {
171
 
        PMC *owner;
172
 
        GET_ATTR_owner(interp, SELF, owner);
173
 
        if (!PMC_IS_NULL(owner))
174
 
            OBJ_SC_WRITE_BARRIER(owner);
175
 
        return SUPER();
176
 
    }
177
 
    VTABLE PMC* shift_pmc() {
178
 
        PMC *owner;
179
 
        GET_ATTR_owner(interp, SELF, owner);
180
 
        if (!PMC_IS_NULL(owner))
181
 
            OBJ_SC_WRITE_BARRIER(owner);
182
 
        return SUPER();
183
 
    }
184
 
 
185
 
    VTABLE void unshift_integer(INTVAL value) {
186
 
        PMC *owner;
187
 
        GET_ATTR_owner(interp, SELF, owner);
188
 
        if (!PMC_IS_NULL(owner))
189
 
            OBJ_SC_WRITE_BARRIER(owner);
190
 
        SUPER(value);
191
 
    }
192
 
    VTABLE void unshift_float(FLOATVAL value) {
193
 
        PMC *owner;
194
 
        GET_ATTR_owner(interp, SELF, owner);
195
 
        if (!PMC_IS_NULL(owner))
196
 
            OBJ_SC_WRITE_BARRIER(owner);
197
 
        SUPER(value);
198
 
    }
199
 
    VTABLE void unshift_string(STRING* value) {
200
 
        PMC *owner;
201
 
        GET_ATTR_owner(interp, SELF, owner);
202
 
        if (!PMC_IS_NULL(owner))
203
 
            OBJ_SC_WRITE_BARRIER(owner);
204
 
        SUPER(value);
205
 
    }
206
 
    VTABLE void unshift_pmc(PMC* value) {
207
 
        PMC *owner;
208
 
        GET_ATTR_owner(interp, SELF, owner);
209
 
        if (!PMC_IS_NULL(owner))
210
 
            OBJ_SC_WRITE_BARRIER(owner);
211
 
        SUPER(value);
212
 
    }
213
 
 
214
 
    void splice(PMC* value, INTVAL offset, INTVAL count) {
215
 
        PMC *owner;
216
 
        GET_ATTR_owner(interp, SELF, owner);
217
 
        if (!PMC_IS_NULL(owner))
218
 
            OBJ_SC_WRITE_BARRIER(owner);
219
 
        SUPER(value, offset, count);
220
 
    }
221
 
    
222
 
    VTABLE void mark() {
223
 
        PMC *owner;
224
 
        GET_ATTR_owner(interp, SELF, owner);
225
 
        Parrot_gc_mark_PMC_alive(INTERP, owner);
226
 
        SUPER();
227
 
    }
228
 
}