1 //**************************************************************************
2 //**
3 //** ## ## ## ## ## #### #### ### ###
4 //** ## ## ## ## ## ## ## ## ## ## #### ####
5 //** ## ## ## ## ## ## ## ## ## ## ## ## ## ##
6 //** ## ## ######## ## ## ## ## ## ## ## ### ##
7 //** ### ## ## ### ## ## ## ## ## ##
8 //** # ## ## # #### #### ## ##
9 //**
10 //** $Id: vc_expr_misc.cpp 4327 2010-07-24 19:30:53Z firebrand_kh $
11 //**
12 //** Copyright (C) 1999-2006 Jānis Legzdiņš
13 //**
14 //** This program is free software; you can redistribute it and/or
15 //** modify it under the terms of the GNU General Public License
16 //** as published by the Free Software Foundation; either version 2
17 //** of the License, or (at your option) any later version.
18 //**
19 //** This program is distributed in the hope that it will be useful,
20 //** but WITHOUT ANY WARRANTY; without even the implied warranty of
21 //** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 //** GNU General Public License for more details.
23 //**
24 //**************************************************************************
25
26 // HEADER FILES ------------------------------------------------------------
27
28 #include "vc_local.h"
29
30 // MACROS ------------------------------------------------------------------
31
32 // TYPES -------------------------------------------------------------------
33
34 // EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
35
36 // PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
37
38 // PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
39
40 // EXTERNAL DATA DECLARATIONS ----------------------------------------------
41
42 // PUBLIC DATA DEFINITIONS -------------------------------------------------
43
44 // PRIVATE DATA DEFINITIONS ------------------------------------------------
45
46 // CODE --------------------------------------------------------------------
47
48 //BEGIN VVector
49
50 //==========================================================================
51 //
52 // VVector::VVector
53 //
54 //==========================================================================
55
VVector(VExpression * AOp1,VExpression * AOp2,VExpression * AOp3,const TLocation & ALoc)56 VVector::VVector(VExpression* AOp1, VExpression* AOp2, VExpression* AOp3, const TLocation& ALoc)
57 : VExpression(ALoc)
58 , op1(AOp1)
59 , op2(AOp2)
60 , op3(AOp3)
61 {
62 if (!op1)
63 {
64 ParseError(Loc, "Expression expected");
65 }
66 if (!op2)
67 {
68 ParseError(Loc, "Expression expected");
69 }
70 if (!op3)
71 {
72 ParseError(Loc, "Expression expected");
73 }
74 }
75
76 //==========================================================================
77 //
78 // VVector::~VVector
79 //
80 //==========================================================================
81
~VVector()82 VVector::~VVector()
83 {
84 if (op1)
85 {
86 delete op1;
87 op1 = NULL;
88 }
89 if (op2)
90 {
91 delete op2;
92 op2 = NULL;
93 }
94 if (op3)
95 {
96 delete op3;
97 op3 = NULL;
98 }
99 }
100
101 //==========================================================================
102 //
103 // VVector::DoResolve
104 //
105 //==========================================================================
106
DoResolve(VEmitContext & ec)107 VExpression* VVector::DoResolve(VEmitContext& ec)
108 {
109 if (op1)
110 op1 = op1->Resolve(ec);
111 if (op2)
112 op2 = op2->Resolve(ec);
113 if (op3)
114 op3 = op3->Resolve(ec);
115 if (!op1 || !op2 || !op3)
116 {
117 delete this;
118 return NULL;
119 }
120
121 if (op1->Type.Type != TYPE_Float)
122 {
123 ParseError(Loc, "Expression type mistmatch, vector param 1 is not a float");
124 delete this;
125 return NULL;
126 }
127 if (op2->Type.Type != TYPE_Float)
128 {
129 ParseError(Loc, "Expression type mistmatch, vector param 2 is not a float");
130 delete this;
131 return NULL;
132 }
133 if (op3->Type.Type != TYPE_Float)
134 {
135 ParseError(Loc, "Expression type mistmatch, vector param 3 is not a float");
136 delete this;
137 return NULL;
138 }
139
140 Type = TYPE_Vector;
141 return this;
142 }
143
144 //==========================================================================
145 //
146 // VVector::Emit
147 //
148 //==========================================================================
149
Emit(VEmitContext & ec)150 void VVector::Emit(VEmitContext& ec)
151 {
152 op1->Emit(ec);
153 op2->Emit(ec);
154 op3->Emit(ec);
155 }
156
157 //END
158
159 //BEGIN VSingleName
160
161 //==========================================================================
162 //
163 // VSingleName::VSingleName
164 //
165 //==========================================================================
166
VSingleName(VName AName,const TLocation & ALoc)167 VSingleName::VSingleName(VName AName, const TLocation& ALoc)
168 : VExpression(ALoc)
169 , Name(AName)
170 {
171 }
172
173 //==========================================================================
174 //
175 // VSingleName::IntResolve
176 //
177 //==========================================================================
178
IntResolve(VEmitContext & ec,bool AssignTarget)179 VExpression* VSingleName::IntResolve(VEmitContext& ec, bool AssignTarget)
180 {
181 int num = ec.CheckForLocalVar(Name);
182 if (num != -1)
183 {
184 VExpression* e = new VLocalVar(num, Loc);
185 delete this;
186 return e->Resolve(ec);
187 }
188
189 if (ec.SelfClass)
190 {
191 VConstant* Const = ec.SelfClass->FindConstant(Name);
192 if (Const)
193 {
194 VExpression* e = new VConstantValue(Const, Loc);
195 delete this;
196 return e->Resolve(ec);
197 }
198
199 VMethod* M = ec.SelfClass->FindMethod(Name);
200 if (M)
201 {
202 VExpression* e = new VDelegateVal((new VSelf(Loc))->Resolve(ec), M, Loc);
203 delete this;
204 return e->Resolve(ec);
205 }
206
207 VField* field = ec.SelfClass->FindField(Name, Loc, ec.SelfClass);
208 if (field)
209 {
210 VExpression* e = new VFieldAccess((new VSelf(Loc))->Resolve(ec), field, Loc, 0);
211 delete this;
212 return e->Resolve(ec);
213 }
214
215 VProperty* Prop = ec.SelfClass->FindProperty(Name);
216 if (Prop)
217 {
218 if (AssignTarget)
219 {
220 if (ec.InDefaultProperties)
221 {
222 if (!Prop->DefaultField)
223 {
224 ParseError(Loc, "Property %s has no default field set", *Name);
225 delete this;
226 return NULL;
227 }
228 VExpression* e = new VFieldAccess((new VSelf(Loc))->Resolve(ec),
229 Prop->DefaultField, Loc, 0);
230 delete this;
231 return e->Resolve(ec);
232 }
233 else
234 {
235 if (!Prop->SetFunc)
236 {
237 ParseError(Loc, "Property %s cannot be set", *Name);
238 delete this;
239 return NULL;
240 }
241 VExpression* e = new VPropertyAssign(NULL, Prop->SetFunc, false, Loc);
242 delete this;
243 // Assignment will call resolve.
244 return e;
245 }
246 }
247 else
248 {
249 if (!Prop->GetFunc)
250 {
251 ParseError(Loc, "Property %s cannot be read", *Name);
252 delete this;
253 return NULL;
254 }
255 VExpression* e = new VInvocation(NULL, Prop->GetFunc, NULL,
256 false, false, Loc, 0, NULL);
257 delete this;
258 return e->Resolve(ec);
259 }
260 }
261 }
262
263 VConstant* Const = ec.Package->FindConstant(Name);
264 if (Const)
265 {
266 VExpression* e = new VConstantValue(Const, Loc);
267 delete this;
268 return e->Resolve(ec);
269 }
270
271 VClass* Class = VMemberBase::StaticFindClass(Name);
272 if (Class)
273 {
274 VExpression* e = new VClassConstant(Class, Loc);
275 delete this;
276 return e->Resolve(ec);
277 }
278
279 Class = ec.Package->FindDecorateImportClass(Name);
280 if (Class)
281 {
282 VExpression* e = new VClassConstant(Class, Loc);
283 delete this;
284 return e->Resolve(ec);
285 }
286
287 Const = (VConstant*)VMemberBase::StaticFindMember(Name, ANY_PACKAGE,
288 MEMBER_Const);
289 if (Const)
290 {
291 VExpression* e = new VConstantValue(Const, Loc);
292 delete this;
293 return e->Resolve(ec);
294 }
295
296 ParseError(Loc, "Illegal expression identifier %s", *Name);
297 delete this;
298 return NULL;
299 }
300
301 //==========================================================================
302 //
303 // VSingleName::DoResolve
304 //
305 //==========================================================================
306
DoResolve(VEmitContext & ec)307 VExpression* VSingleName::DoResolve(VEmitContext& ec)
308 {
309 return IntResolve(ec, false);
310 }
311
312 //==========================================================================
313 //
314 // VSingleName::ResolveAssignmentTarget
315 //
316 //==========================================================================
317
ResolveAssignmentTarget(VEmitContext & ec)318 VExpression* VSingleName::ResolveAssignmentTarget(VEmitContext& ec)
319 {
320 return IntResolve(ec, true);
321 }
322
323 //==========================================================================
324 //
325 // VSingleName::ResolveAsType
326 //
327 //==========================================================================
328
ResolveAsType(VEmitContext & ec)329 VTypeExpr* VSingleName::ResolveAsType(VEmitContext& ec)
330 {
331 Type = VMemberBase::StaticFindType(ec.SelfClass, Name);
332 if (Type.Type == TYPE_Unknown)
333 {
334 ParseError(Loc, "Invalid identifier, bad type name %s", *Name);
335 delete this;
336 return NULL;
337 }
338
339 VTypeExpr* e = new VTypeExpr(Type, Loc);
340 delete this;
341 return e;
342 }
343
344 //==========================================================================
345 //
346 // VSingleName::Emit
347 //
348 //==========================================================================
349
Emit(VEmitContext &)350 void VSingleName::Emit(VEmitContext&)
351 {
352 ParseError(Loc, "Should not happen");
353 }
354
355 //==========================================================================
356 //
357 // VSingleName::IsValidTypeExpression
358 //
359 //==========================================================================
360
IsValidTypeExpression()361 bool VSingleName::IsValidTypeExpression()
362 {
363 return true;
364 }
365
366 //==========================================================================
367 //
368 // VSingleName::CreateTypeExprCopy
369 //
370 //==========================================================================
371
CreateTypeExprCopy()372 VExpression* VSingleName::CreateTypeExprCopy()
373 {
374 return new VSingleName(Name, Loc);
375 }
376
377 //END
378
379 //BEGIN VDoubleName
380
381 //==========================================================================
382 //
383 // VDoubleName::VDoubleName
384 //
385 //==========================================================================
386
VDoubleName(VName AName1,VName AName2,const TLocation & ALoc)387 VDoubleName::VDoubleName(VName AName1, VName AName2, const TLocation& ALoc)
388 : VExpression(ALoc)
389 , Name1(AName1)
390 , Name2(AName2)
391 {
392 }
393
394 //==========================================================================
395 //
396 // VDoubleName::DoResolve
397 //
398 //==========================================================================
399
DoResolve(VEmitContext & ec)400 VExpression* VDoubleName::DoResolve(VEmitContext& ec)
401 {
402 VClass* Class = VMemberBase::StaticFindClass(Name1);
403 if (!Class)
404 {
405 ParseError(Loc, "No such class %s", *Name1);
406 delete this;
407 return NULL;
408 }
409
410 VConstant* Const = Class->FindConstant(Name2);
411 if (Const)
412 {
413 VExpression* e = new VConstantValue(Const, Loc);
414 delete this;
415 return e->Resolve(ec);
416 }
417
418 ParseError(Loc, "No such constant or state %s", *Name2);
419 delete this;
420 return NULL;
421 }
422
423 //==========================================================================
424 //
425 // VDoubleName::ResolveAsType
426 //
427 //==========================================================================
428
ResolveAsType(VEmitContext &)429 VTypeExpr* VDoubleName::ResolveAsType(VEmitContext&)
430 {
431 VClass* Class = VMemberBase::StaticFindClass(Name1);
432 if (!Class)
433 {
434 ParseError(Loc, "No such class %s", *Name1);
435 delete this;
436 return NULL;
437 }
438
439 Type = VMemberBase::StaticFindType(Class, Name2);
440 if (Type.Type == TYPE_Unknown)
441 {
442 ParseError(Loc, "Invalid identifier, bad type name %s::%s", *Name1, *Name2);
443 delete this;
444 return NULL;
445 }
446
447 VTypeExpr* e = new VTypeExpr(Type, Loc);
448 delete this;
449 return e;
450 }
451
452 //==========================================================================
453 //
454 // VDoubleName::Emit
455 //
456 //==========================================================================
457
Emit(VEmitContext &)458 void VDoubleName::Emit(VEmitContext&)
459 {
460 ParseError(Loc, "Should not happen");
461 }
462
463 //==========================================================================
464 //
465 // VDoubleName::IsValidTypeExpression
466 //
467 //==========================================================================
468
IsValidTypeExpression()469 bool VDoubleName::IsValidTypeExpression()
470 {
471 return true;
472 }
473
474 //==========================================================================
475 //
476 // VDoubleName::CreateTypeExprCopy
477 //
478 //==========================================================================
479
CreateTypeExprCopy()480 VExpression* VDoubleName::CreateTypeExprCopy()
481 {
482 return new VDoubleName(Name1, Name2, Loc);
483 }
484
485 //END
486
487 //BEGIN VDefaultObject
488
489 //==========================================================================
490 //
491 // VDefaultObject::VDefaultObject
492 //
493 //==========================================================================
494
VDefaultObject(VExpression * AOp,const TLocation & ALoc)495 VDefaultObject::VDefaultObject(VExpression* AOp, const TLocation& ALoc)
496 : VExpression(ALoc)
497 , op(AOp)
498 {
499 }
500
501 //==========================================================================
502 //
503 // VDefaultObject::~VDefaultObject
504 //
505 //==========================================================================
506
~VDefaultObject()507 VDefaultObject::~VDefaultObject()
508 {
509 if (op)
510 {
511 delete op;
512 op = NULL;
513 }
514 }
515
516 //==========================================================================
517 //
518 // VDefaultObject::DoResolve
519 //
520 //==========================================================================
521
DoResolve(VEmitContext & ec)522 VExpression* VDefaultObject::DoResolve(VEmitContext& ec)
523 {
524 if (op)
525 op = op->Resolve(ec);
526 if (!op)
527 {
528 delete this;
529 return NULL;
530 }
531
532 if (op->Type.Type == TYPE_Reference)
533 {
534 Type = op->Type;
535 return this;
536 }
537 else if (op->Type.Type == TYPE_Class)
538 {
539 if (!op->Type.Class)
540 {
541 ParseError(Loc, "A typed class value required");
542 delete this;
543 return NULL;
544 }
545 Type = VFieldType(op->Type.Class);
546 return this;
547 }
548
549 ParseError(Loc, "Reference or class expected on left side of default");
550 delete this;
551 return NULL;
552 }
553
554 //==========================================================================
555 //
556 // VDefaultObject::Emit
557 //
558 //==========================================================================
559
Emit(VEmitContext & ec)560 void VDefaultObject::Emit(VEmitContext& ec)
561 {
562 op->Emit(ec);
563 if (op->Type.Type == TYPE_Reference)
564 {
565 ec.AddStatement(OPC_GetDefaultObj);
566 }
567 else if (op->Type.Type == TYPE_Class)
568 {
569 ec.AddStatement(OPC_GetClassDefaultObj);
570 }
571 }
572
573 //==========================================================================
574 //
575 // VDefaultObject::IsDefaultObject
576 //
577 //==========================================================================
578
IsDefaultObject() const579 bool VDefaultObject::IsDefaultObject() const
580 {
581 return true;
582 }
583
584 //END
585
586 //BEGIN VPushPointed
587
588 //==========================================================================
589 //
590 // VPushPointed::VPushPointed
591 //
592 //==========================================================================
593
VPushPointed(VExpression * AOp)594 VPushPointed::VPushPointed(VExpression* AOp)
595 : VExpression(AOp->Loc)
596 , op(AOp)
597 , AddressRequested(false)
598 {
599 if (!op)
600 {
601 ParseError(Loc, "Expression expected");
602 return;
603 }
604 }
605
606 //==========================================================================
607 //
608 // VPushPointed::~VPushPointed
609 //
610 //==========================================================================
611
~VPushPointed()612 VPushPointed::~VPushPointed()
613 {
614 if (op)
615 {
616 delete op;
617 op = NULL;
618 }
619 }
620
621 //==========================================================================
622 //
623 // VPushPointed::DoResolve
624 //
625 //==========================================================================
626
DoResolve(VEmitContext & ec)627 VExpression* VPushPointed::DoResolve(VEmitContext& ec)
628 {
629 if (op)
630 op = op->Resolve(ec);
631 if (!op)
632 {
633 delete this;
634 return NULL;
635 }
636
637 if (op->Type.Type != TYPE_Pointer)
638 {
639 ParseError(Loc, "Expression syntax error");
640 delete this;
641 return NULL;
642 }
643 Type = op->Type.GetPointerInnerType();
644 RealType = Type;
645 if (Type.Type == TYPE_Byte || Type.Type == TYPE_Bool)
646 {
647 Type = VFieldType(TYPE_Int);
648 }
649 return this;
650 }
651
652 //==========================================================================
653 //
654 // VPushPointed::RequestAddressOf
655 //
656 //==========================================================================
657
RequestAddressOf()658 void VPushPointed::RequestAddressOf()
659 {
660 if (RealType.Type == TYPE_Void)
661 {
662 ParseError(Loc, "Bad address operation");
663 return;
664 }
665 if (AddressRequested)
666 ParseError(Loc, "Multiple address of");
667 AddressRequested = true;
668 }
669
670 //==========================================================================
671 //
672 // VPushPointed::Emit
673 //
674 //==========================================================================
675
Emit(VEmitContext & ec)676 void VPushPointed::Emit(VEmitContext& ec)
677 {
678 op->Emit(ec);
679 if (!AddressRequested)
680 {
681 EmitPushPointedCode(RealType, ec);
682 }
683 }
684
685 //END
686
687 //BEGIN VConditional
688
689 //==========================================================================
690 //
691 // VConditional::VConditional
692 //
693 //==========================================================================
694
VConditional(VExpression * AOp,VExpression * AOp1,VExpression * AOp2,const TLocation & ALoc)695 VConditional::VConditional(VExpression* AOp, VExpression* AOp1, VExpression* AOp2, const TLocation& ALoc)
696 : VExpression(ALoc)
697 , op(AOp)
698 , op1(AOp1)
699 , op2(AOp2)
700 {
701 if (!op1)
702 {
703 ParseError(Loc, "Expression expected");
704 return;
705 }
706 if (!op2)
707 {
708 ParseError(Loc, "Expression expected");
709 return;
710 }
711 }
712
713 //==========================================================================
714 //
715 // VConditional::~VConditional
716 //
717 //==========================================================================
718
~VConditional()719 VConditional::~VConditional()
720 {
721 if (op)
722 {
723 delete op;
724 op = NULL;
725 }
726 if (op1)
727 {
728 delete op1;
729 op1 = NULL;
730 }
731 if (op2)
732 {
733 delete op2;
734 op2 = NULL;
735 }
736 }
737
738 //==========================================================================
739 //
740 // VConditional::DoResolve
741 //
742 //==========================================================================
743
DoResolve(VEmitContext & ec)744 VExpression* VConditional::DoResolve(VEmitContext& ec)
745 {
746 if (op)
747 op = op->ResolveBoolean(ec);
748 if (op1)
749 op1 = op1->Resolve(ec);
750 if (op2)
751 op2 = op2->Resolve(ec);
752 if (!op || !op1 || !op2)
753 {
754 delete this;
755 return NULL;
756 }
757
758 op1->Type.CheckMatch(Loc, op2->Type);
759 if (op1->Type.Type == TYPE_Pointer && op1->Type.InnerType == TYPE_Void)
760 Type = op2->Type;
761 else
762 Type = op1->Type;
763 return this;
764 }
765
766 //==========================================================================
767 //
768 // VConditional::Emit
769 //
770 //==========================================================================
771
Emit(VEmitContext & ec)772 void VConditional::Emit(VEmitContext& ec)
773 {
774 VLabel FalseTarget = ec.DefineLabel();
775 VLabel End = ec.DefineLabel();
776
777 op->EmitBranchable(ec, FalseTarget, false);
778 op1->Emit(ec);
779 ec.AddStatement(OPC_Goto, End);
780 ec.MarkLabel(FalseTarget);
781 op2->Emit(ec);
782 ec.MarkLabel(End);
783 }
784
785 //END
786
787 //BEGIN VClassConstant
788
789 //==========================================================================
790 //
791 // VClassConstant::VClassConstant
792 //
793 //==========================================================================
794
VClassConstant(VClass * AClass,const TLocation & ALoc)795 VClassConstant::VClassConstant(VClass* AClass, const TLocation& ALoc)
796 : VExpression(ALoc)
797 , Class(AClass)
798 {
799 Type = TYPE_Class;
800 Type.Class = Class;
801 }
802
803 //==========================================================================
804 //
805 // VClassConstant::DoResolve
806 //
807 //==========================================================================
808
DoResolve(VEmitContext &)809 VExpression* VClassConstant::DoResolve(VEmitContext&)
810 {
811 return this;
812 }
813
814 //==========================================================================
815 //
816 // VClassConstant::Emit
817 //
818 //==========================================================================
819
Emit(VEmitContext & ec)820 void VClassConstant::Emit(VEmitContext& ec)
821 {
822 ec.AddStatement(OPC_PushClassId, Class);
823 }
824
825 //END
826
827 //BEGIN VStateConstant
828
829 //==========================================================================
830 //
831 // VStateConstant::VStateConstant
832 //
833 //==========================================================================
834
VStateConstant(VState * AState,const TLocation & ALoc)835 VStateConstant::VStateConstant(VState* AState, const TLocation& ALoc)
836 : VExpression(ALoc)
837 , State(AState)
838 {
839 Type = TYPE_State;
840 }
841
842 //==========================================================================
843 //
844 // VStateConstant::DoResolve
845 //
846 //==========================================================================
847
DoResolve(VEmitContext &)848 VExpression* VStateConstant::DoResolve(VEmitContext&)
849 {
850 return this;
851 }
852
853 //==========================================================================
854 //
855 // VStateConstant::Emit
856 //
857 //==========================================================================
858
Emit(VEmitContext & ec)859 void VStateConstant::Emit(VEmitContext& ec)
860 {
861 ec.AddStatement(OPC_PushState, State);
862 }
863
864 //END
865
866 //BEGIN VConstantValue
867
868 //==========================================================================
869 //
870 // VConstantValue::VConstantValue
871 //
872 //==========================================================================
873
VConstantValue(VConstant * AConst,const TLocation & ALoc)874 VConstantValue::VConstantValue(VConstant* AConst, const TLocation& ALoc)
875 : VExpression(ALoc)
876 , Const(AConst)
877 {
878 }
879
880 //==========================================================================
881 //
882 // VConstantValue::DoResolve
883 //
884 //==========================================================================
885
DoResolve(VEmitContext &)886 VExpression* VConstantValue::DoResolve(VEmitContext&)
887 {
888 Type = (EType)Const->Type;
889 return this;
890 }
891
892 //==========================================================================
893 //
894 // VConstantValue::Emit
895 //
896 //==========================================================================
897
Emit(VEmitContext & ec)898 void VConstantValue::Emit(VEmitContext& ec)
899 {
900 ec.EmitPushNumber(Const->Value);
901 }
902
903 //==========================================================================
904 //
905 // VConstantValue::GetIntConst
906 //
907 //==========================================================================
908
GetIntConst() const909 vint32 VConstantValue::GetIntConst() const
910 {
911 if (Const->Type == TYPE_Int)
912 {
913 return Const->Value;
914 }
915 return VExpression::GetIntConst();
916 }
917
918 //==========================================================================
919 //
920 // VConstantValue::GetFloatConst
921 //
922 //==========================================================================
923
GetFloatConst() const924 float VConstantValue::GetFloatConst() const
925 {
926 if (Const->Type == TYPE_Float)
927 {
928 return Const->FloatValue;
929 }
930 return VExpression::GetFloatConst();
931 }
932
933 //==========================================================================
934 //
935 // VConstantValue::IsIntConst
936 //
937 //==========================================================================
938
IsIntConst() const939 bool VConstantValue::IsIntConst() const
940 {
941 return Const->Type == TYPE_Int;
942 }
943
944 //==========================================================================
945 //
946 // VConstantValue::IsFloatConst
947 //
948 //==========================================================================
949
IsFloatConst() const950 bool VConstantValue::IsFloatConst() const
951 {
952 return Const->Type == TYPE_Float;
953 }
954
955 //END
956
957 //BEGIN VDropResult
958
959 //==========================================================================
960 //
961 // VDropResult::VDropResult
962 //
963 //==========================================================================
964
VDropResult(VExpression * AOp)965 VDropResult::VDropResult(VExpression* AOp)
966 : VExpression(AOp->Loc)
967 , op(AOp)
968 {
969 }
970
971 //==========================================================================
972 //
973 // VDropResult::~VDropResult
974 //
975 //==========================================================================
976
~VDropResult()977 VDropResult::~VDropResult()
978 {
979 if (op)
980 {
981 delete op;
982 op = NULL;
983 }
984 }
985
986 //==========================================================================
987 //
988 // VDropResult::DoResolve
989 //
990 //==========================================================================
991
DoResolve(VEmitContext & ec)992 VExpression* VDropResult::DoResolve(VEmitContext& ec)
993 {
994 if (op)
995 op = op->Resolve(ec);
996 if (!op)
997 {
998 delete this;
999 return NULL;
1000 }
1001
1002 if (op->Type.Type == TYPE_Delegate)
1003 {
1004 ParseError(Loc, "Delegate call parameters are missing");
1005 delete this;
1006 return NULL;
1007 }
1008
1009 if (op->Type.Type != TYPE_String && op->Type.GetStackSize() != 4 &&
1010 op->Type.Type != TYPE_Vector && op->Type.Type != TYPE_Void)
1011 {
1012 ParseError(Loc, "Expression's result type cannot be dropped");
1013 delete this;
1014 return NULL;
1015 }
1016
1017 if (op->AddDropResult())
1018 {
1019 VExpression* e = op;
1020 op = NULL;
1021 delete this;
1022 return e;
1023 }
1024
1025 Type = TYPE_Void;
1026 return this;
1027 }
1028
1029 //==========================================================================
1030 //
1031 // VDropResult::Emit
1032 //
1033 //==========================================================================
1034
Emit(VEmitContext & ec)1035 void VDropResult::Emit(VEmitContext& ec)
1036 {
1037 op->Emit(ec);
1038 if (op->Type.Type == TYPE_String)
1039 {
1040 ec.AddStatement(OPC_DropStr);
1041 }
1042 else if (op->Type.Type == TYPE_Vector)
1043 {
1044 ec.AddStatement(OPC_VDrop);
1045 }
1046 else if (op->Type.GetStackSize() == 4)
1047 {
1048 ec.AddStatement(OPC_Drop);
1049 }
1050 }
1051
1052 //END
1053