Mercurial > projects > ldc

comparison dmd2/arrayop.c @ 1452:638d16625da2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LDC 2 compiles again.
author Robert Clipsham <robert@octarineparrot.com>
date Sat, 30 May 2009 17:23:32 +0100
parents f04dde6e882c
children 54b3c1394d62
comparison
equal deleted inserted replaced
1423:42bd767ec5a4 1452:638d16625da2
9 9
10 #include <stdio.h> 10 #include <stdio.h>
11 #include <string.h> 11 #include <string.h>
12 #include <assert.h> 12 #include <assert.h>
13 13
14 #if _WIN32 || IN_GCC || IN_LLVM 14 #include "rmem.h"
15 #include "mem.h"
16 #else
17 #include "../root/mem.h"
18 #endif
19 15
20 #include "stringtable.h" 16 #include "stringtable.h"
21 17
22 #include "expression.h" 18 #include "expression.h"
23 #include "statement.h" 19 #include "statement.h"
26 #include "scope.h" 22 #include "scope.h"
27 #include "id.h" 23 #include "id.h"
28 #include "module.h" 24 #include "module.h"
29 #include "init.h" 25 #include "init.h"
30 26
27 #if IN_DMD
28 extern int binary(const char *p , const char **tab, int high);
29
30 /**************************************
31 * Hash table of array op functions already generated or known about.
32 */
33
34 StringTable arrayfuncs;
35 #endif
31 36
32 /*********************************** 37 /***********************************
33 * Construct the array operation expression. 38 * Construct the array operation expression.
34 */ 39 */
35 40
58 buf.writeByte(0); 63 buf.writeByte(0);
59 char *name = (char *)buf.extractData(); 64 char *name = (char *)buf.extractData();
60 65
61 /* Look up name in hash table 66 /* Look up name in hash table
62 */ 67 */
68 #if IN_LLVM
63 StringValue *sv = sc->module->arrayfuncs.update(name, namelen); 69 StringValue *sv = sc->module->arrayfuncs.update(name, namelen);
70 #else
71 StringValue *sv = arrayfuncs.update(name, namelen);
72 #endif
64 FuncDeclaration *fd = (FuncDeclaration *)sv->ptrvalue; 73 FuncDeclaration *fd = (FuncDeclaration *)sv->ptrvalue;
65 if (!fd) 74 if (!fd)
66 { 75 {
67 // /* Some of the array op functions are written as library functions, 76 #if IN_DMD
68 // * presumably to optimize them with special CPU vector instructions. 77 /* Some of the array op functions are written as library functions,
69 // * List those library functions here, in alpha order. 78 * presumably to optimize them with special CPU vector instructions.
70 // */ 79 * List those library functions here, in alpha order.
71 // static const char *libArrayopFuncs[] = 80 */
72 // { 81 static const char *libArrayopFuncs[] =
73 // "_arrayExpSliceAddass_a", 82 {
74 // "_arrayExpSliceAddass_d", // T[]+=T 83 "_arrayExpSliceAddass_a",
75 // "_arrayExpSliceAddass_f", // T[]+=T 84 "_arrayExpSliceAddass_d", // T[]+=T
76 // "_arrayExpSliceAddass_g", 85 "_arrayExpSliceAddass_f", // T[]+=T
77 // "_arrayExpSliceAddass_h", 86 "_arrayExpSliceAddass_g",
78 // "_arrayExpSliceAddass_i", 87 "_arrayExpSliceAddass_h",
79 // "_arrayExpSliceAddass_k", 88 "_arrayExpSliceAddass_i",
80 // "_arrayExpSliceAddass_s", 89 "_arrayExpSliceAddass_k",
81 // "_arrayExpSliceAddass_t", 90 "_arrayExpSliceAddass_s",
82 // "_arrayExpSliceAddass_u", 91 "_arrayExpSliceAddass_t",
83 // "_arrayExpSliceAddass_w", 92 "_arrayExpSliceAddass_u",
84 // 93 "_arrayExpSliceAddass_w",
85 // "_arrayExpSliceDivass_d", // T[]/=T 94
86 // "_arrayExpSliceDivass_f", // T[]/=T 95 "_arrayExpSliceDivass_d", // T[]/=T
87 // 96 "_arrayExpSliceDivass_f", // T[]/=T
88 // "_arrayExpSliceMinSliceAssign_a", 97
89 // "_arrayExpSliceMinSliceAssign_d", // T[]=T-T[] 98 "_arrayExpSliceMinSliceAssign_a",
90 // "_arrayExpSliceMinSliceAssign_f", // T[]=T-T[] 99 "_arrayExpSliceMinSliceAssign_d", // T[]=T-T[]
91 // "_arrayExpSliceMinSliceAssign_g", 100 "_arrayExpSliceMinSliceAssign_f", // T[]=T-T[]
92 // "_arrayExpSliceMinSliceAssign_h", 101 "_arrayExpSliceMinSliceAssign_g",
93 // "_arrayExpSliceMinSliceAssign_i", 102 "_arrayExpSliceMinSliceAssign_h",
94 // "_arrayExpSliceMinSliceAssign_k", 103 "_arrayExpSliceMinSliceAssign_i",
95 // "_arrayExpSliceMinSliceAssign_s", 104 "_arrayExpSliceMinSliceAssign_k",
96 // "_arrayExpSliceMinSliceAssign_t", 105 "_arrayExpSliceMinSliceAssign_s",
97 // "_arrayExpSliceMinSliceAssign_u", 106 "_arrayExpSliceMinSliceAssign_t",
98 // "_arrayExpSliceMinSliceAssign_w", 107 "_arrayExpSliceMinSliceAssign_u",
99 // 108 "_arrayExpSliceMinSliceAssign_w",
100 // "_arrayExpSliceMinass_a", 109
101 // "_arrayExpSliceMinass_d", // T[]-=T 110 "_arrayExpSliceMinass_a",
102 // "_arrayExpSliceMinass_f", // T[]-=T 111 "_arrayExpSliceMinass_d", // T[]-=T
103 // "_arrayExpSliceMinass_g", 112 "_arrayExpSliceMinass_f", // T[]-=T
104 // "_arrayExpSliceMinass_h", 113 "_arrayExpSliceMinass_g",
105 // "_arrayExpSliceMinass_i", 114 "_arrayExpSliceMinass_h",
106 // "_arrayExpSliceMinass_k", 115 "_arrayExpSliceMinass_i",
107 // "_arrayExpSliceMinass_s", 116 "_arrayExpSliceMinass_k",
108 // "_arrayExpSliceMinass_t", 117 "_arrayExpSliceMinass_s",
109 // "_arrayExpSliceMinass_u", 118 "_arrayExpSliceMinass_t",
110 // "_arrayExpSliceMinass_w", 119 "_arrayExpSliceMinass_u",
111 // 120 "_arrayExpSliceMinass_w",
112 // "_arrayExpSliceMulass_d", // T[]*=T 121
113 // "_arrayExpSliceMulass_f", // T[]*=T 122 "_arrayExpSliceMulass_d", // T[]*=T
114 // "_arrayExpSliceMulass_i", 123 "_arrayExpSliceMulass_f", // T[]*=T
115 // "_arrayExpSliceMulass_k", 124 "_arrayExpSliceMulass_i",
116 // "_arrayExpSliceMulass_s", 125 "_arrayExpSliceMulass_k",
117 // "_arrayExpSliceMulass_t", 126 "_arrayExpSliceMulass_s",
118 // "_arrayExpSliceMulass_u", 127 "_arrayExpSliceMulass_t",
119 // "_arrayExpSliceMulass_w", 128 "_arrayExpSliceMulass_u",
120 // 129 "_arrayExpSliceMulass_w",
121 // "_arraySliceExpAddSliceAssign_a", 130
122 // "_arraySliceExpAddSliceAssign_d", // T[]=T[]+T 131 "_arraySliceExpAddSliceAssign_a",
123 // "_arraySliceExpAddSliceAssign_f", // T[]=T[]+T 132 "_arraySliceExpAddSliceAssign_d", // T[]=T[]+T
124 // "_arraySliceExpAddSliceAssign_g", 133 "_arraySliceExpAddSliceAssign_f", // T[]=T[]+T
125 // "_arraySliceExpAddSliceAssign_h", 134 "_arraySliceExpAddSliceAssign_g",
126 // "_arraySliceExpAddSliceAssign_i", 135 "_arraySliceExpAddSliceAssign_h",
127 // "_arraySliceExpAddSliceAssign_k", 136 "_arraySliceExpAddSliceAssign_i",
128 // "_arraySliceExpAddSliceAssign_s", 137 "_arraySliceExpAddSliceAssign_k",
129 // "_arraySliceExpAddSliceAssign_t", 138 "_arraySliceExpAddSliceAssign_s",
130 // "_arraySliceExpAddSliceAssign_u", 139 "_arraySliceExpAddSliceAssign_t",
131 // "_arraySliceExpAddSliceAssign_w", 140 "_arraySliceExpAddSliceAssign_u",
132 // 141 "_arraySliceExpAddSliceAssign_w",
133 // "_arraySliceExpDivSliceAssign_d", // T[]=T[]/T 142
134 // "_arraySliceExpDivSliceAssign_f", // T[]=T[]/T 143 "_arraySliceExpDivSliceAssign_d", // T[]=T[]/T
135 // 144 "_arraySliceExpDivSliceAssign_f", // T[]=T[]/T
136 // "_arraySliceExpMinSliceAssign_a", 145
137 // "_arraySliceExpMinSliceAssign_d", // T[]=T[]-T 146 "_arraySliceExpMinSliceAssign_a",
138 // "_arraySliceExpMinSliceAssign_f", // T[]=T[]-T 147 "_arraySliceExpMinSliceAssign_d", // T[]=T[]-T
139 // "_arraySliceExpMinSliceAssign_g", 148 "_arraySliceExpMinSliceAssign_f", // T[]=T[]-T
140 // "_arraySliceExpMinSliceAssign_h", 149 "_arraySliceExpMinSliceAssign_g",
141 // "_arraySliceExpMinSliceAssign_i", 150 "_arraySliceExpMinSliceAssign_h",
142 // "_arraySliceExpMinSliceAssign_k", 151 "_arraySliceExpMinSliceAssign_i",
143 // "_arraySliceExpMinSliceAssign_s", 152 "_arraySliceExpMinSliceAssign_k",
144 // "_arraySliceExpMinSliceAssign_t", 153 "_arraySliceExpMinSliceAssign_s",
145 // "_arraySliceExpMinSliceAssign_u", 154 "_arraySliceExpMinSliceAssign_t",
146 // "_arraySliceExpMinSliceAssign_w", 155 "_arraySliceExpMinSliceAssign_u",
147 // 156 "_arraySliceExpMinSliceAssign_w",
148 // "_arraySliceExpMulSliceAddass_d", // T[] += T[]*T 157
149 // "_arraySliceExpMulSliceAddass_f", 158 "_arraySliceExpMulSliceAddass_d", // T[] += T[]*T
150 // "_arraySliceExpMulSliceAddass_r", 159 "_arraySliceExpMulSliceAddass_f",
151 // 160 "_arraySliceExpMulSliceAddass_r",
152 // "_arraySliceExpMulSliceAssign_d", // T[]=T[]*T 161
153 // "_arraySliceExpMulSliceAssign_f", // T[]=T[]*T 162 "_arraySliceExpMulSliceAssign_d", // T[]=T[]*T
154 // "_arraySliceExpMulSliceAssign_i", 163 "_arraySliceExpMulSliceAssign_f", // T[]=T[]*T
155 // "_arraySliceExpMulSliceAssign_k", 164 "_arraySliceExpMulSliceAssign_i",
156 // "_arraySliceExpMulSliceAssign_s", 165 "_arraySliceExpMulSliceAssign_k",
157 // "_arraySliceExpMulSliceAssign_t", 166 "_arraySliceExpMulSliceAssign_s",
158 // "_arraySliceExpMulSliceAssign_u", 167 "_arraySliceExpMulSliceAssign_t",
159 // "_arraySliceExpMulSliceAssign_w", 168 "_arraySliceExpMulSliceAssign_u",
160 // 169 "_arraySliceExpMulSliceAssign_w",
161 // "_arraySliceExpMulSliceMinass_d", // T[] -= T[]*T 170
162 // "_arraySliceExpMulSliceMinass_f", 171 "_arraySliceExpMulSliceMinass_d", // T[] -= T[]*T
163 // "_arraySliceExpMulSliceMinass_r", 172 "_arraySliceExpMulSliceMinass_f",
164 // 173 "_arraySliceExpMulSliceMinass_r",
165 // "_arraySliceSliceAddSliceAssign_a", 174
166 // "_arraySliceSliceAddSliceAssign_d", // T[]=T[]+T[] 175 "_arraySliceSliceAddSliceAssign_a",
167 // "_arraySliceSliceAddSliceAssign_f", // T[]=T[]+T[] 176 "_arraySliceSliceAddSliceAssign_d", // T[]=T[]+T[]
168 // "_arraySliceSliceAddSliceAssign_g", 177 "_arraySliceSliceAddSliceAssign_f", // T[]=T[]+T[]
169 // "_arraySliceSliceAddSliceAssign_h", 178 "_arraySliceSliceAddSliceAssign_g",
170 // "_arraySliceSliceAddSliceAssign_i", 179 "_arraySliceSliceAddSliceAssign_h",
171 // "_arraySliceSliceAddSliceAssign_k", 180 "_arraySliceSliceAddSliceAssign_i",
172 // "_arraySliceSliceAddSliceAssign_r", // T[]=T[]+T[] 181 "_arraySliceSliceAddSliceAssign_k",
173 // "_arraySliceSliceAddSliceAssign_s", 182 "_arraySliceSliceAddSliceAssign_r", // T[]=T[]+T[]
174 // "_arraySliceSliceAddSliceAssign_t", 183 "_arraySliceSliceAddSliceAssign_s",
175 // "_arraySliceSliceAddSliceAssign_u", 184 "_arraySliceSliceAddSliceAssign_t",
176 // "_arraySliceSliceAddSliceAssign_w", 185 "_arraySliceSliceAddSliceAssign_u",
177 // 186 "_arraySliceSliceAddSliceAssign_w",
178 // "_arraySliceSliceAddass_a", 187
179 // "_arraySliceSliceAddass_d", // T[]+=T[] 188 "_arraySliceSliceAddass_a",
180 // "_arraySliceSliceAddass_f", // T[]+=T[] 189 "_arraySliceSliceAddass_d", // T[]+=T[]
181 // "_arraySliceSliceAddass_g", 190 "_arraySliceSliceAddass_f", // T[]+=T[]
182 // "_arraySliceSliceAddass_h", 191 "_arraySliceSliceAddass_g",
183 // "_arraySliceSliceAddass_i", 192 "_arraySliceSliceAddass_h",
184 // "_arraySliceSliceAddass_k", 193 "_arraySliceSliceAddass_i",
185 // "_arraySliceSliceAddass_s", 194 "_arraySliceSliceAddass_k",
186 // "_arraySliceSliceAddass_t", 195 "_arraySliceSliceAddass_s",
187 // "_arraySliceSliceAddass_u", 196 "_arraySliceSliceAddass_t",
188 // "_arraySliceSliceAddass_w", 197 "_arraySliceSliceAddass_u",
189 // 198 "_arraySliceSliceAddass_w",
190 // "_arraySliceSliceMinSliceAssign_a", 199
191 // "_arraySliceSliceMinSliceAssign_d", // T[]=T[]-T[] 200 "_arraySliceSliceMinSliceAssign_a",
192 // "_arraySliceSliceMinSliceAssign_f", // T[]=T[]-T[] 201 "_arraySliceSliceMinSliceAssign_d", // T[]=T[]-T[]
193 // "_arraySliceSliceMinSliceAssign_g", 202 "_arraySliceSliceMinSliceAssign_f", // T[]=T[]-T[]
194 // "_arraySliceSliceMinSliceAssign_h", 203 "_arraySliceSliceMinSliceAssign_g",
195 // "_arraySliceSliceMinSliceAssign_i", 204 "_arraySliceSliceMinSliceAssign_h",
196 // "_arraySliceSliceMinSliceAssign_k", 205 "_arraySliceSliceMinSliceAssign_i",
197 // "_arraySliceSliceMinSliceAssign_r", // T[]=T[]-T[] 206 "_arraySliceSliceMinSliceAssign_k",
198 // "_arraySliceSliceMinSliceAssign_s", 207 "_arraySliceSliceMinSliceAssign_r", // T[]=T[]-T[]
199 // "_arraySliceSliceMinSliceAssign_t", 208 "_arraySliceSliceMinSliceAssign_s",
200 // "_arraySliceSliceMinSliceAssign_u", 209 "_arraySliceSliceMinSliceAssign_t",
201 // "_arraySliceSliceMinSliceAssign_w", 210 "_arraySliceSliceMinSliceAssign_u",
202 // 211 "_arraySliceSliceMinSliceAssign_w",
203 // "_arraySliceSliceMinass_a", 212
204 // "_arraySliceSliceMinass_d", // T[]-=T[] 213 "_arraySliceSliceMinass_a",
205 // "_arraySliceSliceMinass_f", // T[]-=T[] 214 "_arraySliceSliceMinass_d", // T[]-=T[]
206 // "_arraySliceSliceMinass_g", 215 "_arraySliceSliceMinass_f", // T[]-=T[]
207 // "_arraySliceSliceMinass_h", 216 "_arraySliceSliceMinass_g",
208 // "_arraySliceSliceMinass_i", 217 "_arraySliceSliceMinass_h",
209 // "_arraySliceSliceMinass_k", 218 "_arraySliceSliceMinass_i",
210 // "_arraySliceSliceMinass_s", 219 "_arraySliceSliceMinass_k",
211 // "_arraySliceSliceMinass_t", 220 "_arraySliceSliceMinass_s",
212 // "_arraySliceSliceMinass_u", 221 "_arraySliceSliceMinass_t",
213 // "_arraySliceSliceMinass_w", 222 "_arraySliceSliceMinass_u",
214 // 223 "_arraySliceSliceMinass_w",
215 // "_arraySliceSliceMulSliceAssign_d", // T[]=T[]*T[] 224
216 // "_arraySliceSliceMulSliceAssign_f", // T[]=T[]*T[] 225 "_arraySliceSliceMulSliceAssign_d", // T[]=T[]*T[]
217 // "_arraySliceSliceMulSliceAssign_i", 226 "_arraySliceSliceMulSliceAssign_f", // T[]=T[]*T[]
218 // "_arraySliceSliceMulSliceAssign_k", 227 "_arraySliceSliceMulSliceAssign_i",
219 // "_arraySliceSliceMulSliceAssign_s", 228 "_arraySliceSliceMulSliceAssign_k",
220 // "_arraySliceSliceMulSliceAssign_t", 229 "_arraySliceSliceMulSliceAssign_s",
221 // "_arraySliceSliceMulSliceAssign_u", 230 "_arraySliceSliceMulSliceAssign_t",
222 // "_arraySliceSliceMulSliceAssign_w", 231 "_arraySliceSliceMulSliceAssign_u",
223 // 232 "_arraySliceSliceMulSliceAssign_w",
224 // "_arraySliceSliceMulass_d", // T[]*=T[] 233
225 // "_arraySliceSliceMulass_f", // T[]*=T[] 234 "_arraySliceSliceMulass_d", // T[]*=T[]
226 // "_arraySliceSliceMulass_i", 235 "_arraySliceSliceMulass_f", // T[]*=T[]
227 // "_arraySliceSliceMulass_k", 236 "_arraySliceSliceMulass_i",
228 // "_arraySliceSliceMulass_s", 237 "_arraySliceSliceMulass_k",
229 // "_arraySliceSliceMulass_t", 238 "_arraySliceSliceMulass_s",
230 // "_arraySliceSliceMulass_u", 239 "_arraySliceSliceMulass_t",
231 // "_arraySliceSliceMulass_w", 240 "_arraySliceSliceMulass_u",
232 // }; 241 "_arraySliceSliceMulass_w",
233 // 242 };
234 // int i = binary(name, libArrayopFuncs, sizeof(libArrayopFuncs) / sizeof(char *)); 243
235 // if (i == -1) 244 int i = binary(name, libArrayopFuncs, sizeof(libArrayopFuncs) / sizeof(char *));
236 // { 245 if (i == -1)
237 // #ifdef DEBUG // Make sure our array is alphabetized 246 {
238 // for (i = 0; i < sizeof(libArrayopFuncs) / sizeof(char *); i++) 247 #ifdef DEBUG // Make sure our array is alphabetized
239 // { 248 for (i = 0; i < sizeof(libArrayopFuncs) / sizeof(char *); i++)
240 // if (strcmp(name, libArrayopFuncs[i]) == 0) 249 {
241 // assert(0); 250 if (strcmp(name, libArrayopFuncs[i]) == 0)
242 // } 251 assert(0);
243 // #endif 252 }
244 253 #endif
245 /* Not in library, so generate it. 254 #endif
246 * Construct the function body: 255 /* Not in library, so generate it.
247 * foreach (i; 0 .. p.length) for (size_t i = 0; i < p.length; i++) 256 * Construct the function body:
248 * loopbody; 257 * foreach (i; 0 .. p.length) for (size_t i = 0; i < p.length; i++)
249 * return p; 258 * loopbody;
250 */ 259 * return p;
251 260 */
252 Arguments *fparams = new Arguments(); 261
253 Expression *loopbody = buildArrayLoop(fparams); 262 Arguments *fparams = new Arguments();
254 Argument *p = (Argument *)fparams->data[0 /*fparams->dim - 1*/]; 263 Expression *loopbody = buildArrayLoop(fparams);
264 Argument *p = (Argument *)fparams->data[0 /*fparams->dim - 1*/];
255 #if DMDV1 265 #if DMDV1
256 // for (size_t i = 0; i < p.length; i++) 266 // for (size_t i = 0; i < p.length; i++)
257 Initializer *init = new ExpInitializer(0, new IntegerExp(0, 0, Type::tsize_t)); 267 Initializer *init = new ExpInitializer(0, new IntegerExp(0, 0, Type::tsize_t));
258 Dsymbol *d = new VarDeclaration(0, Type::tsize_t, Id::p, init); 268 Dsymbol *d = new VarDeclaration(0, Type::tsize_t, Id::p, init);
259 Statement *s1 = new ForStatement(0, 269 Statement *s1 = new ForStatement(0,
260 new DeclarationStatement(0, d), 270 new DeclarationStatement(0, d),
261 new CmpExp(TOKlt, 0, new IdentifierExp(0, Id::p), new ArrayLengthExp(0, new IdentifierExp(0, p->ident))), 271 new CmpExp(TOKlt, 0, new IdentifierExp(0, Id::p), new ArrayLengthExp(0, new IdentifierExp(0, p->ident))),
262 new PostExp(TOKplusplus, 0, new IdentifierExp(0, Id::p)), 272 new PostExp(TOKplusplus, 0, new IdentifierExp(0, Id::p)),
263 new ExpStatement(0, loopbody)); 273 new ExpStatement(0, loopbody));
264 #else 274 #else
265 // foreach (i; 0 .. p.length) 275 // foreach (i; 0 .. p.length)
266 Statement *s1 = new ForeachRangeStatement(0, TOKforeach, 276 Statement *s1 = new ForeachRangeStatement(0, TOKforeach,
267 new Argument(0, NULL, Id::p, NULL), 277 new Argument(0, NULL, Id::p, NULL),
268 new IntegerExp(0, 0, Type::tint32), 278 new IntegerExp(0, 0, Type::tint32),
269 new ArrayLengthExp(0, new IdentifierExp(0, p->ident)), 279 new ArrayLengthExp(0, new IdentifierExp(0, p->ident)),
270 new ExpStatement(0, loopbody)); 280 new ExpStatement(0, loopbody));
271 #endif 281 #endif
272 Statement *s2 = new ReturnStatement(0, new IdentifierExp(0, p->ident)); 282 Statement *s2 = new ReturnStatement(0, new IdentifierExp(0, p->ident));
273 //printf("s2: %s\n", s2->toChars()); 283 //printf("s2: %s\n", s2->toChars());
274 Statement *fbody = new CompoundStatement(0, s1, s2); 284 Statement *fbody = new CompoundStatement(0, s1, s2);
275 285
276 /* Construct the function 286 /* Construct the function
277 */ 287 */
278 TypeFunction *ftype = new TypeFunction(fparams, type, 0, LINKc); 288 TypeFunction *ftype = new TypeFunction(fparams, type, 0, LINKc);
279 //printf("ftype: %s\n", ftype->toChars()); 289 //printf("ftype: %s\n", ftype->toChars());
280 fd = new FuncDeclaration(0, 0, Lexer::idPool(name), STCundefined, ftype); 290 fd = new FuncDeclaration(0, 0, Lexer::idPool(name), STCundefined, ftype);
281 fd->fbody = fbody; 291 fd->fbody = fbody;
282 fd->protection = PROTprotected; 292 fd->protection = PROTpublic;
283 fd->linkage = LINKd; 293 fd->linkage = LINKd;
284 294
285 // special attention for array ops 295 // special attention for array ops
286 fd->isArrayOp = true; 296 fd->isArrayOp = true;
287 297
288 sc->module->members->push(fd); 298 sc->module->importedFrom->members->push(fd);
289 299
290 sc = sc->push(); 300 sc = sc->push();
291 sc->parent = sc->module; 301 sc->parent = sc->module->importedFrom;
292 sc->stc = 0; 302 sc->stc = 0;
293 sc->linkage = LINKd; 303 sc->linkage = LINKc;
294 fd->semantic(sc); 304 fd->semantic(sc);
295 sc->pop(); 305 sc->pop();
296 // } 306 #if IN_DMD
297 // else 307 }
298 // { /* In library, refer to it. 308 else
299 // */ 309 { /* In library, refer to it.
300 // // FIXME 310 */
301 // fd = FuncDeclaration::genCfunc(NULL, type, name); 311 fd = FuncDeclaration::genCfunc(type, name);
302 // } 312 }
303 sv->ptrvalue = fd; // cache symbol in hash table 313 #endif
314 sv->ptrvalue = fd; // cache symbol in hash table
304 } 315 }
305 316
306 /* Call the function fd(arguments) 317 /* Call the function fd(arguments)
307 */ 318 */
308 Expression *ec = new VarExp(0, fd); 319 Expression *ec = new VarExp(0, fd);