Mercurial > projects > ldc

comparison dmd/arrayop.c @ 703:06576ece1a1b

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