Mercurial > hg-old > index.cgi
comparison lwasm/pseudo.c @ 391:c1d83336e1d1
Fixed problem with structure member registration and fixed detection of operator{} type symbols in expression evaluation
author | lost@l-w.ca |
---|---|
date | Wed, 21 Jul 2010 21:26:43 -0600 |
parents | fbb7bfed8076 |
children | 62cb50c50976 |
comparison
equal
deleted
inserted
replaced
390:027d7fbcdcfc | 391:c1d83336e1d1 |
---|---|
303 if (!expr) | 303 if (!expr) |
304 { | 304 { |
305 lwasm_register_error(as, l, "Bad expression"); | 305 lwasm_register_error(as, l, "Bad expression"); |
306 } | 306 } |
307 | 307 |
308 l -> lint = 0; | |
308 if (as -> instruct) | 309 if (as -> instruct) |
309 { | 310 { |
310 lwasm_reduce_expr(as, expr); | 311 lwasm_reduce_expr(as, expr); |
311 if (!lw_expr_istype(expr, lw_expr_type_int)) | 312 if (!lw_expr_istype(expr, lw_expr_type_int)) |
312 { | 313 { |
316 { | 317 { |
317 int e; | 318 int e; |
318 e = lw_expr_intval(expr); | 319 e = lw_expr_intval(expr); |
319 register_struct_entry(as, l, e, NULL); | 320 register_struct_entry(as, l, e, NULL); |
320 l -> len = 0; | 321 l -> len = 0; |
322 l -> lint = 1; | |
323 l -> symset = 1; | |
321 } | 324 } |
322 } | 325 } |
323 | 326 |
324 lwasm_save_expr(l, 0, expr); | 327 lwasm_save_expr(l, 0, expr); |
325 } | 328 } |
326 | 329 |
327 RESOLVEFUNC(pseudo_resolve_rmb) | 330 RESOLVEFUNC(pseudo_resolve_rmb) |
328 { | 331 { |
329 lw_expr_t expr; | 332 lw_expr_t expr; |
330 | 333 |
334 if (l -> lint) | |
335 return; | |
336 | |
331 if (l -> len >= 0) | 337 if (l -> len >= 0) |
332 return; | 338 return; |
333 | 339 |
334 expr = lwasm_fetch_expr(l, 0); | 340 expr = lwasm_fetch_expr(l, 0); |
335 | 341 |
339 } | 345 } |
340 } | 346 } |
341 | 347 |
342 EMITFUNC(pseudo_emit_rmb) | 348 EMITFUNC(pseudo_emit_rmb) |
343 { | 349 { |
350 if (l -> lint) | |
351 return; | |
352 | |
344 if (l -> len < 0) | 353 if (l -> len < 0) |
345 lwasm_register_error(as, l, "Expression not constant"); | 354 lwasm_register_error(as, l, "Expression not constant"); |
346 } | 355 } |
347 | 356 |
348 PARSEFUNC(pseudo_parse_rmd) | 357 PARSEFUNC(pseudo_parse_rmd) |
349 { | 358 { |
350 lw_expr_t expr; | 359 lw_expr_t expr; |
351 | 360 |
361 l -> lint = 0; | |
352 expr = lwasm_parse_expr(as, p); | 362 expr = lwasm_parse_expr(as, p); |
353 if (!expr) | 363 if (!expr) |
354 { | 364 { |
355 lwasm_register_error(as, l, "Bad expression"); | 365 lwasm_register_error(as, l, "Bad expression"); |
356 } | 366 } |
366 { | 376 { |
367 int e; | 377 int e; |
368 e = lw_expr_intval(expr) * 2; | 378 e = lw_expr_intval(expr) * 2; |
369 register_struct_entry(as, l, e, NULL); | 379 register_struct_entry(as, l, e, NULL); |
370 l -> len = 0; | 380 l -> len = 0; |
381 l -> symset = 1; | |
382 l -> lint = 1; | |
371 } | 383 } |
372 } | 384 } |
373 lwasm_save_expr(l, 0, expr); | 385 lwasm_save_expr(l, 0, expr); |
374 } | 386 } |
375 | 387 |
376 RESOLVEFUNC(pseudo_resolve_rmd) | 388 RESOLVEFUNC(pseudo_resolve_rmd) |
377 { | 389 { |
378 lw_expr_t expr; | 390 lw_expr_t expr; |
379 | 391 |
392 if (l -> lint) | |
393 return; | |
394 | |
380 if (l -> len >= 0) | 395 if (l -> len >= 0) |
381 return; | 396 return; |
382 | 397 |
383 expr = lwasm_fetch_expr(l, 0); | 398 expr = lwasm_fetch_expr(l, 0); |
384 | 399 |
388 } | 403 } |
389 } | 404 } |
390 | 405 |
391 EMITFUNC(pseudo_emit_rmd) | 406 EMITFUNC(pseudo_emit_rmd) |
392 { | 407 { |
408 if (l -> lint) | |
409 return; | |
410 | |
393 if (l -> len < 0) | 411 if (l -> len < 0) |
394 lwasm_register_error(as, l, "Expression not constant"); | 412 lwasm_register_error(as, l, "Expression not constant"); |
395 } | 413 } |
396 | 414 |
397 | 415 |
398 PARSEFUNC(pseudo_parse_rmq) | 416 PARSEFUNC(pseudo_parse_rmq) |
399 { | 417 { |
400 lw_expr_t expr; | 418 lw_expr_t expr; |
401 | 419 |
420 l -> lint = 0; | |
402 expr = lwasm_parse_expr(as, p); | 421 expr = lwasm_parse_expr(as, p); |
403 if (!expr) | 422 if (!expr) |
404 { | 423 { |
405 lwasm_register_error(as, l, "Bad expression"); | 424 lwasm_register_error(as, l, "Bad expression"); |
406 } | 425 } |
415 { | 434 { |
416 int e; | 435 int e; |
417 e = lw_expr_intval(expr) * 4; | 436 e = lw_expr_intval(expr) * 4; |
418 register_struct_entry(as, l, e, NULL); | 437 register_struct_entry(as, l, e, NULL); |
419 l -> len = 0; | 438 l -> len = 0; |
439 l -> symset = 1; | |
440 l -> lint = 1; | |
420 } | 441 } |
421 } | 442 } |
422 | 443 |
423 lwasm_save_expr(l, 0, expr); | 444 lwasm_save_expr(l, 0, expr); |
424 } | 445 } |
425 | 446 |
426 RESOLVEFUNC(pseudo_resolve_rmq) | 447 RESOLVEFUNC(pseudo_resolve_rmq) |
427 { | 448 { |
428 lw_expr_t expr; | 449 lw_expr_t expr; |
450 | |
451 if (l -> lint) | |
452 return; | |
429 | 453 |
430 if (l -> len >= 0) | 454 if (l -> len >= 0) |
431 return; | 455 return; |
432 | 456 |
433 expr = lwasm_fetch_expr(l, 0); | 457 expr = lwasm_fetch_expr(l, 0); |
438 } | 462 } |
439 } | 463 } |
440 | 464 |
441 EMITFUNC(pseudo_emit_rmq) | 465 EMITFUNC(pseudo_emit_rmq) |
442 { | 466 { |
467 if (l -> lint) | |
468 return; | |
469 | |
443 if (l -> len < 0) | 470 if (l -> len < 0) |
444 lwasm_register_error(as, l, "Expression not constant"); | 471 lwasm_register_error(as, l, "Expression not constant"); |
445 } | 472 } |
446 | 473 |
447 | 474 |