0025329: ExprIntrp_GenExp can not parse unary plus
[occt.git] / src / ExprIntrp / ExprIntrp_yaccintrf.cxx
1 // Copyright (c) 1997-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #include <ExprIntrp_yaccintrf.hxx>
16 #include <ExprIntrp_yaccanal.hxx>
17 #include <Expr_GeneralExpression.hxx>
18 #include <Expr_NamedExpression.hxx>
19 #include <Expr_NamedUnknown.hxx>
20 #include <Expr_NamedConstant.hxx>
21 #include <Expr_NamedFunction.hxx>
22 #include <Expr_NumericValue.hxx>
23 #include <Expr_UnaryFunction.hxx>
24 #include <Expr_BinaryFunction.hxx>
25 #include <Expr_PolyFunction.hxx>
26 #include <Expr_Exponentiate.hxx>
27 #include <Expr_Absolute.hxx>
28 #include <Expr_ArcCosine.hxx>
29 #include <Expr_ArcSine.hxx>
30 #include <Expr_ArcTangent.hxx>
31 #include <Expr_ArgCosh.hxx>
32 #include <Expr_ArgSinh.hxx>
33 #include <Expr_ArgTanh.hxx>
34 #include <Expr_Cosh.hxx>
35 #include <Expr_Cosine.hxx>
36 #include <Expr_Exponential.hxx>
37 #include <Expr_LogOf10.hxx>
38 #include <Expr_LogOfe.hxx>
39 #include <Expr_Sign.hxx>
40 #include <Expr_Sine.hxx>
41 #include <Expr_Sinh.hxx>
42 #include <Expr_SquareRoot.hxx>
43 #include <Expr_Tangent.hxx>
44 #include <Expr_Tanh.hxx>
45 #include <Expr_Equal.hxx>
46 #include <Expr_SystemRelation.hxx>
47 #include <Expr_UnknownIterator.hxx>
48 #include <Expr_FunctionDerivative.hxx>
49 #include <Expr.hxx>
50 #include <Expr_SequenceOfGeneralExpression.hxx>
51 #include <Expr_Operators.hxx>
52 #include <ExprIntrp_SyntaxError.hxx>
53 #include <Expr_Array1OfNamedUnknown.hxx>
54 #include <Expr_Array1OfGeneralExpression.hxx>
55
56 static TCollection_AsciiString ExprIntrp_assname;
57 static TCollection_AsciiString ExprIntrp_funcdefname;
58 static Standard_Integer ExprIntrp_nbargs;
59 static Standard_Integer ExprIntrp_nbdiff;
60
61 extern "C" void ExprIntrp_StartFunction()
62 {
63   const TCollection_AsciiString& name = ExprIntrp_GetResult();
64   ExprIntrp_Recept.PushName(name);
65   ExprIntrp_nbargs = 0;
66 }
67
68 extern "C" void ExprIntrp_StartDerivate()
69 {
70   const TCollection_AsciiString& name = ExprIntrp_GetResult();
71   ExprIntrp_Recept.PushName(name);
72 }
73
74 extern "C" void ExprIntrp_EndDerivate()
75 {
76   int degree;
77   degree = ExprIntrp_GetDegree();
78   ExprIntrp_Recept.PushValue(degree);
79 }
80
81 extern "C" void ExprIntrp_Derivation()
82 {
83   ExprIntrp_Recept.PushValue(1);
84   const TCollection_AsciiString& thename = ExprIntrp_GetResult();
85   Handle(Expr_NamedExpression) namexp = ExprIntrp_Recept.GetNamed(thename);
86   if (namexp.IsNull()) {
87     namexp = new Expr_NamedUnknown(thename);
88   }
89   if (!namexp->IsKind(STANDARD_TYPE(Expr_NamedUnknown))) {
90     ExprIntrp_SyntaxError::Raise();
91   }
92   ExprIntrp_Recept.Push(namexp);
93 }
94
95 extern "C" void ExprIntrp_DerivationValue()
96 {
97   const TCollection_AsciiString& aStr = ExprIntrp_GetResult();
98   ExprIntrp_Recept.PopValue();
99   ExprIntrp_Recept.PushValue(aStr.IntegerValue());
100 }
101
102 extern "C" void ExprIntrp_EndDerivation()
103 {
104   Standard_Integer degree = ExprIntrp_Recept.PopValue();
105   Handle(Expr_NamedUnknown) var = Handle(Expr_NamedUnknown)::DownCast(ExprIntrp_Recept.Pop());
106   Handle(Expr_GeneralExpression) exp = ExprIntrp_Recept.Pop();
107   exp = exp->NDerivative(var,degree);
108   ExprIntrp_Recept.Push(exp);
109 }
110
111 extern "C" void ExprIntrp_StartDifferential()
112 {
113   ExprIntrp_StartDerivate();
114   ExprIntrp_nbdiff = 0;
115 }
116
117 extern "C" void ExprIntrp_DiffDegreeVar()
118 {
119   const TCollection_AsciiString& aStr = ExprIntrp_GetResult();
120   const char* s = aStr.ToCString();
121   if ( *s != 'X' && *s != 'x' ) {
122     ExprIntrp_SyntaxError::Raise();
123   }
124   s++;
125   Standard_Integer rank = atoi(s);
126   ExprIntrp_Recept.PushValue(rank);
127   ExprIntrp_nbdiff++;
128 }
129
130 extern "C" void ExprIntrp_DiffVar()
131 {
132   ExprIntrp_Recept.PushValue(1);
133   ExprIntrp_DiffDegreeVar();
134 }
135
136 extern "C" void ExprIntrp_DiffDegree()
137 {
138   const TCollection_AsciiString& aStr = ExprIntrp_GetResult();
139   Standard_Integer deg = aStr.IntegerValue();
140   ExprIntrp_Recept.PushValue(deg);
141 }
142
143 extern "C" void ExprIntrp_VerDiffDegree()
144 {
145   const TCollection_AsciiString& aStr = ExprIntrp_GetResult();
146   Standard_Integer deg = aStr.IntegerValue();
147   Standard_Integer thedeg = ExprIntrp_Recept.PopValue();
148   if (deg != thedeg) {
149     ExprIntrp_SyntaxError::Raise();
150   }
151   ExprIntrp_Recept.PushValue(deg);
152 }
153
154 extern "C" void ExprIntrp_EndDifferential()
155 {
156   TCollection_AsciiString name = ExprIntrp_Recept.PopName();
157   Handle(Expr_GeneralFunction) thefunc = ExprIntrp_Recept.GetFunction(name);
158   if (thefunc.IsNull()) {
159     ExprIntrp_SyntaxError::Raise();
160   }
161   Standard_Integer rank,degree;
162   Handle(Expr_NamedUnknown) thediff;
163   Standard_Integer nbvars = thefunc->NbOfVariables();
164
165   for (Standard_Integer i=1; i<= ExprIntrp_nbdiff; i++) {
166     rank = ExprIntrp_Recept.PopValue();
167     degree = ExprIntrp_Recept.PopValue();
168     if ((rank > nbvars) || (rank < 1)) {
169       ExprIntrp_SyntaxError::Raise();
170     }
171     thediff = thefunc->Variable(rank);
172     thefunc = new Expr_FunctionDerivative(thefunc,thediff,degree);
173   }
174   ExprIntrp_Recept.PushFunction(thefunc);
175 }
176
177 extern "C" void ExprIntrp_EndDiffFunction()
178 {
179   Handle(Expr_GeneralFunction) thefunc = ExprIntrp_Recept.PopFunction();
180   if (thefunc.IsNull()) {
181     ExprIntrp_SyntaxError::Raise();
182   }
183   Standard_Integer nbargs = thefunc->NbOfVariables();
184   if (nbargs == 1) {
185     Handle(Expr_GeneralExpression) op = ExprIntrp_Recept.Pop();
186     Handle(Expr_UnaryFunction) res = 
187       new Expr_UnaryFunction(thefunc,op);
188     ExprIntrp_Recept.Push(res);
189   }
190   else if (nbargs == 2) {
191     Handle(Expr_GeneralExpression) arg2 = ExprIntrp_Recept.Pop();
192     Handle(Expr_GeneralExpression) arg1 = ExprIntrp_Recept.Pop();
193     if (arg1.IsNull()) {
194       ExprIntrp_SyntaxError::Raise();
195     }
196     Handle(Expr_BinaryFunction) res =
197       new Expr_BinaryFunction(thefunc,arg1,arg2);
198     ExprIntrp_Recept.Push(res);
199   }
200   else {
201     Expr_Array1OfGeneralExpression tabarg(1,nbargs);
202     Handle(Expr_GeneralExpression) arg;
203     for (Standard_Integer i = 1; i<= nbargs; i++) {
204       arg = ExprIntrp_Recept.Pop();
205       if (arg.IsNull()) {
206         ExprIntrp_SyntaxError::Raise();
207       }
208       tabarg(nbargs-i+1) = arg;
209     }
210     Handle(Expr_PolyFunction) res = 
211       new Expr_PolyFunction(thefunc,tabarg);
212     ExprIntrp_Recept.Push(res);
213   }
214 }
215   
216 static Handle(Expr_GeneralExpression) ExprIntrp_StandardFunction(const TCollection_AsciiString& name, const Handle(Expr_GeneralExpression)& op)
217 {
218 // return standard functions equivalent corresponding to <name> 
219 // with given operand <op> if exists. Returns null value if not.
220 // <name> is not case sensitive
221
222   Handle(Expr_GeneralExpression) res;
223   if ((name == "abs") || (name == "Abs")) {
224     res = new Expr_Absolute(op);
225   }
226   else if ((name == "acos") || (name == "ACos")) {
227     res = new Expr_ArcCosine(op);
228   }
229   else if ((name == "asin") || (name == "ASin")) {
230     res = new Expr_ArcSine(op);
231   }
232   else if ((name == "atan") || (name == "ATan")) {
233     res = new Expr_ArcTangent(op);
234   }
235   else if ((name == "acosh") || (name == "ACosh")) {
236     res = new Expr_ArgCosh(op);
237   }
238   else if ((name == "asinh") || (name == "ASinh")) {
239     res = new Expr_ArgSinh(op);
240   }
241   else if ((name == "atanh") || (name == "ATanh")) {
242     res = new Expr_ArgTanh(op);
243   }
244   else if ((name == "cosh") || (name == "Cosh")) {
245     res = new Expr_Cosh(op);
246   }
247   else if ((name == "cos") || (name == "Cos")) {
248     res = new Expr_Cosine(op);
249   }
250   else if ((name == "exp") || (name == "Exp")) {
251     res = new Expr_Exponential(op);
252   }
253   else if (name == "log") {
254     res = new Expr_LogOf10(op);
255   }
256   else if ((name == "Log") || (name == "Ln")) {
257     res = new Expr_LogOfe(op);
258   }
259   else if ((name == "sign") || (name == "Sign")) {
260     res = new Expr_Sign(op);
261   }
262   else if ((name == "sin") || (name == "Sin")) {
263     res = new Expr_Sine(op);
264   }
265   else if ((name == "sinh") || (name == "Sinh")) {
266     res = new Expr_Sinh(op);
267   }
268   else if ((name == "sqrt") || (name == "Sqrt")) {
269     res = new Expr_SquareRoot(op);
270   }
271   else if ((name == "tan") || (name == "Tan")) {
272     res = new Expr_Tangent(op);
273   }
274   else if ((name == "tanh") || (name == "Tanh")) {
275     res = new Expr_Tanh(op);
276   }
277   return res;
278 }
279
280
281 extern "C" void ExprIntrp_EndDerFunction()
282 {
283   TCollection_AsciiString name = ExprIntrp_Recept.PopName();
284   Handle(Expr_GeneralExpression) op = ExprIntrp_Recept.Pop();
285   Handle(Expr_GeneralExpression) resstand = ExprIntrp_StandardFunction(name,op);
286
287   if (!resstand.IsNull()) {
288     Handle(Expr_NamedUnknown) var;
289     Expr_UnknownIterator rit(resstand);
290     while (rit.More()) {
291       if (!var.IsNull()) {
292         ExprIntrp_SyntaxError::Raise();
293       }
294       else {
295         var = rit.Value();
296         if (var->IsAssigned()) {
297           var.Nullify();
298         }
299       }
300       rit.Next();
301     }
302     if (var.IsNull()) {
303       ExprIntrp_SyntaxError::Raise();
304     }
305     else {
306       Handle(Expr_GeneralExpression) res = resstand->NDerivative(var,ExprIntrp_Recept.PopValue());
307       ExprIntrp_Recept.Push(res);
308     }
309   }
310   else {
311     Handle(Expr_NamedFunction) thefunc = ExprIntrp_Recept.GetFunction(name);
312     if (thefunc.IsNull()) {
313       ExprIntrp_SyntaxError::Raise();
314     }
315     Standard_Integer nbargs = thefunc->NbOfVariables();
316     if (nbargs != 1) {
317       ExprIntrp_SyntaxError::Raise();
318     }
319     Handle(Expr_NamedUnknown) var = thefunc->Variable(1);
320     Handle(Expr_FunctionDerivative) thefuncder = 
321       new Expr_FunctionDerivative(thefunc,var,ExprIntrp_Recept.PopValue());
322     Handle(Expr_UnaryFunction) res = 
323       new Expr_UnaryFunction(thefuncder,op);
324     ExprIntrp_Recept.Push(res);
325   }
326 }
327     
328 extern "C" void ExprIntrp_EndFunction()
329 {
330   TCollection_AsciiString name = ExprIntrp_Recept.PopName();
331   Handle(Expr_GeneralExpression) op = ExprIntrp_Recept.Pop();
332
333   Handle(Expr_GeneralExpression) resstand = ExprIntrp_StandardFunction(name,op);
334   if (!resstand.IsNull()) {
335     ExprIntrp_Recept.Push(resstand->ShallowSimplified());
336   }
337   else {
338     Handle(Expr_NamedFunction) thefunc = ExprIntrp_Recept.GetFunction(name);
339     if (thefunc.IsNull()) {
340       ExprIntrp_SyntaxError::Raise();
341       }
342     Standard_Integer nbargs = thefunc->NbOfVariables();
343     if (nbargs == 1) {
344       Handle(Expr_UnaryFunction) res = 
345         new Expr_UnaryFunction(thefunc,op);
346       ExprIntrp_Recept.Push(res);
347     }
348     else if (nbargs == 2) {
349       Handle(Expr_GeneralExpression) arg1 = ExprIntrp_Recept.Pop();
350       if (arg1.IsNull()) {
351         ExprIntrp_SyntaxError::Raise();
352       }
353       Handle(Expr_BinaryFunction) res =
354         new Expr_BinaryFunction(thefunc,arg1,op);
355       ExprIntrp_Recept.Push(res);
356     }
357     else {
358       Expr_Array1OfGeneralExpression tabarg(1,nbargs);
359       Handle(Expr_GeneralExpression) arg;
360       tabarg(nbargs) = op;
361       for (Standard_Integer i = 1; i< nbargs; i++) {
362         arg = ExprIntrp_Recept.Pop();
363         if (arg.IsNull()) {
364           ExprIntrp_SyntaxError::Raise();
365         }
366         tabarg(nbargs-i) = arg;
367       }
368       Handle(Expr_PolyFunction) res = 
369         new Expr_PolyFunction(thefunc,tabarg);
370       ExprIntrp_Recept.Push(res);
371     }
372   }
373 }
374
375 extern "C" void ExprIntrp_NextFuncArg()
376 {
377   ExprIntrp_nbargs++;
378 }
379
380 extern "C" void ExprIntrp_EndFuncArg()
381 {
382   ExprIntrp_nbargs++;
383 }
384
385 extern "C" void ExprIntrp_SumOperator()
386 {
387   Handle(Expr_GeneralExpression) op2 = ExprIntrp_Recept.Pop();
388   Handle(Expr_GeneralExpression) op1 = ExprIntrp_Recept.Pop();
389   Handle(Expr_Sum) sres = op1 + op2;
390   Handle(Expr_GeneralExpression) res = sres->ShallowSimplified();
391   ExprIntrp_Recept.Push(res);
392 }
393
394 extern "C" void ExprIntrp_MinusOperator()
395 {
396   Handle(Expr_GeneralExpression) op2 = ExprIntrp_Recept.Pop();
397   Handle(Expr_GeneralExpression) op1 = ExprIntrp_Recept.Pop();
398   Handle(Expr_Difference) res = op1 - op2;
399   ExprIntrp_Recept.Push(res->ShallowSimplified());
400 }
401
402 extern "C" void ExprIntrp_DivideOperator()
403 {
404   Handle(Expr_GeneralExpression) op2 = ExprIntrp_Recept.Pop();
405   Handle(Expr_GeneralExpression) op1 = ExprIntrp_Recept.Pop();
406   Handle(Expr_Division) res = op1 / op2;
407   ExprIntrp_Recept.Push(res->ShallowSimplified());
408 }
409
410 extern "C" void ExprIntrp_ExpOperator()
411 {
412   Handle(Expr_GeneralExpression) op2 = ExprIntrp_Recept.Pop();
413   Handle(Expr_GeneralExpression) op1 = ExprIntrp_Recept.Pop();
414   Handle(Expr_Exponentiate) res = new Expr_Exponentiate(op1,op2);
415   ExprIntrp_Recept.Push(res->ShallowSimplified());
416 }
417
418 extern "C" void ExprIntrp_ProductOperator()
419 {
420   Handle(Expr_GeneralExpression) op2 = ExprIntrp_Recept.Pop();
421   Handle(Expr_GeneralExpression) op1 = ExprIntrp_Recept.Pop();
422   Handle(Expr_Product) res = op1 * op2;
423   ExprIntrp_Recept.Push(res->ShallowSimplified());
424 }
425
426 extern "C" void ExprIntrp_UnaryMinusOperator()
427 {
428   Handle(Expr_GeneralExpression) op = ExprIntrp_Recept.Pop();
429   Handle(Expr_UnaryMinus) res = new Expr_UnaryMinus(op);
430   ExprIntrp_Recept.Push(res->ShallowSimplified());
431 }
432
433 extern "C" void ExprIntrp_UnaryPlusOperator()
434 {
435   Handle(Expr_GeneralExpression) op = ExprIntrp_Recept.Pop();
436   ExprIntrp_Recept.Push(op);
437 }
438
439 extern "C" void ExprIntrp_VariableIdentifier()
440 {
441   const TCollection_AsciiString& thename = ExprIntrp_GetResult();
442   Handle(Expr_NamedExpression) nameexp = ExprIntrp_Recept.GetNamed(thename);
443   if (nameexp.IsNull()) {
444     nameexp = new Expr_NamedUnknown(thename);
445     ExprIntrp_Recept.Use(nameexp);
446   }
447   ExprIntrp_Recept.Push(nameexp);
448 }
449
450 extern "C" void ExprIntrp_NumValue()
451 {
452   const TCollection_AsciiString& aStr = ExprIntrp_GetResult();
453   Standard_Real value = aStr.RealValue();
454   Handle(Expr_NumericValue) nval = new Expr_NumericValue(value);
455   ExprIntrp_Recept.Push(nval);
456 }
457
458 extern "C" void ExprIntrp_AssignVariable()
459 {
460   ExprIntrp_assname = ExprIntrp_GetResult();
461 }
462
463 extern "C" void ExprIntrp_Deassign()
464 {
465   const TCollection_AsciiString& thename = ExprIntrp_GetResult();
466   Handle(Expr_NamedExpression) nameexp = ExprIntrp_Recept.GetNamed(thename);
467   if (nameexp.IsNull()) {
468     ExprIntrp_SyntaxError::Raise();
469   }
470   if (!nameexp->IsKind(STANDARD_TYPE(Expr_NamedUnknown))) {
471     ExprIntrp_SyntaxError::Raise();
472   }
473   Handle(Expr_NamedUnknown) var = Handle(Expr_NamedUnknown)::DownCast(nameexp);
474   var->Deassign();
475 }
476
477 extern "C" void ExprIntrp_DefineFunction()
478 {
479   ExprIntrp_funcdefname = ExprIntrp_Recept.PopName();
480   ExprIntrp_Recept.PushValue(ExprIntrp_nbargs);
481 }
482
483 extern "C" void ExprIntrp_close()
484 {
485   ExprIntrp_stop_string();
486 }
487
488 extern "C" void ExprIntrperror(char* msg)
489 {
490   ExprIntrp_close();
491   ExprIntrp_SyntaxError::Raise(msg);
492 }
493
494
495 extern "C" void ExprIntrp_EndOfEqual()
496 {
497   Handle(Expr_GeneralExpression) memb2 = ExprIntrp_Recept.Pop();
498   Handle(Expr_GeneralExpression) memb1 = ExprIntrp_Recept.Pop();
499   Handle(Expr_Equal) res = new Expr_Equal(memb1,memb2);
500   ExprIntrp_Recept.PushRelation(res);
501 }
502
503 extern "C" void ExprIntrp_EndOfRelation()
504 {
505   Handle(Expr_SystemRelation) sys;
506   Handle(Expr_GeneralRelation) currel;
507   Handle(Expr_GeneralRelation) oldrel;
508   while (!ExprIntrp_Recept.IsRelStackEmpty()) {
509     currel = ExprIntrp_Recept.PopRelation();
510     if (!sys.IsNull()) {
511       sys->Add(currel);
512     }
513     else if (!oldrel.IsNull()) {
514       sys = new Expr_SystemRelation(oldrel);
515       sys->Add(currel);
516     }
517     else {
518       oldrel = currel;
519     }
520   }
521   if (sys.IsNull()) {
522     ExprIntrp_Recept.PushRelation(currel);
523   }
524   else {
525     ExprIntrp_Recept.PushRelation(sys);
526   }
527 }
528
529 extern "C" void ExprIntrp_EndOfAssign()
530 {
531   Handle(Expr_NamedExpression) namexp = ExprIntrp_Recept.GetNamed(ExprIntrp_assname);
532   Handle(Expr_NamedUnknown) namu;
533   if (namexp.IsNull()) {
534     namu = new Expr_NamedUnknown(ExprIntrp_assname);
535     ExprIntrp_Recept.Use(namu);
536   }
537   else {
538     if (!namexp->IsKind(STANDARD_TYPE(Expr_NamedUnknown))) {
539       ExprIntrp_SyntaxError::Raise();
540     }
541     namu = Handle(Expr_NamedUnknown)::DownCast(namexp);
542   }
543   namu->Assign(ExprIntrp_Recept.Pop());
544 }
545
546 extern "C" void ExprIntrp_EndOfFuncDef()
547 {
548   Handle(Expr_GeneralExpression) theexp = ExprIntrp_Recept.Pop();
549   Standard_Integer nbargs = ExprIntrp_Recept.PopValue();
550   Expr_Array1OfNamedUnknown vars(1,nbargs);
551   Expr_Array1OfNamedUnknown internvars(1,nbargs);
552   Standard_Integer i;
553   for (i=nbargs; i > 0; i--) {
554     vars(i) = Handle(Expr_NamedUnknown)::DownCast(ExprIntrp_Recept.Pop());
555     internvars(i) = Handle(Expr_NamedUnknown)::DownCast(vars(i)->Copy());
556   }
557   theexp = Expr::CopyShare(theexp);  // ATTENTION, PROTECTION BUG STACK
558   for (i=1; i<= nbargs; i++) {
559     if (theexp->Contains(vars(i))) {
560       theexp->Replace(vars(i),internvars(i));
561     }
562     else {
563       if (theexp == vars(i)) {
564         theexp = internvars(i);
565       }
566     }
567   }
568   Handle(Expr_NamedFunction) thefunc = 
569     new Expr_NamedFunction(ExprIntrp_funcdefname,
570                            theexp,
571                            internvars);
572   ExprIntrp_Recept.Use(thefunc);
573 }
574
575 extern "C" void ExprIntrp_ConstantIdentifier()
576 {
577   const TCollection_AsciiString& thename = ExprIntrp_GetResult();
578   ExprIntrp_Recept.PushName(thename);
579 }
580
581 extern "C" void ExprIntrp_ConstantDefinition()
582 {
583   TCollection_AsciiString name = ExprIntrp_Recept.PopName();
584   const TCollection_AsciiString& aStr = ExprIntrp_GetResult();
585   Standard_Real val = aStr.RealValue();
586   Handle(Expr_NamedConstant) theconst = new Expr_NamedConstant(name,val);
587   ExprIntrp_Recept.Use(theconst);
588   ExprIntrp_Recept.Push(theconst);
589 }
590
591
592 extern "C" void ExprIntrp_Sumator()
593 {
594   Handle(Expr_NumericValue) number = Handle(Expr_NumericValue)::DownCast(ExprIntrp_Recept.Pop());
595   Standard_Integer nb = (Standard_Integer) number->GetValue();
596   Handle(Expr_GeneralExpression) inc = ExprIntrp_Recept.Pop();
597   Handle(Expr_GeneralExpression) first = ExprIntrp_Recept.Pop();
598   Handle(Expr_NamedUnknown) var = Handle(Expr_NamedUnknown)::DownCast(ExprIntrp_Recept.Pop());
599   Handle(Expr_GeneralExpression) theexp = ExprIntrp_Recept.Pop();
600   Standard_Boolean thesame = (theexp == var);
601   Handle(Expr_GeneralExpression) cur = Expr::CopyShare(first);
602   Handle(Expr_GeneralExpression) res;
603   Handle(Expr_GeneralExpression) member;
604   Expr_SequenceOfGeneralExpression seq;
605   for (Standard_Integer i=1; i<= nb; i++) {
606     if (thesame) {
607       member = cur;
608     }
609     else {
610       member = Expr::CopyShare(theexp);
611       member->Replace(var,cur);
612     }
613     seq.Append(member);
614     cur = (cur + inc)->ShallowSimplified();
615   }
616   res = new Expr_Sum(seq);
617   ExprIntrp_Recept.Push(res->ShallowSimplified());
618 }
619
620 extern "C" void ExprIntrp_Productor()
621 {
622   Handle(Expr_NumericValue) number = Handle(Expr_NumericValue)::DownCast(ExprIntrp_Recept.Pop());
623   Standard_Integer nb = (Standard_Integer) number->GetValue();
624   Handle(Expr_GeneralExpression) inc = ExprIntrp_Recept.Pop();
625   Handle(Expr_GeneralExpression) first = ExprIntrp_Recept.Pop();
626   Handle(Expr_NamedUnknown) var = Handle(Expr_NamedUnknown)::DownCast(ExprIntrp_Recept.Pop());
627   Handle(Expr_GeneralExpression) theexp = ExprIntrp_Recept.Pop();
628   Standard_Boolean thesame = (theexp == var);
629   Handle(Expr_GeneralExpression) cur = Expr::CopyShare(first);
630   Handle(Expr_GeneralExpression) res;
631   Handle(Expr_GeneralExpression) member;
632   Expr_SequenceOfGeneralExpression seq;
633   for (Standard_Integer i=1; i<= nb; i++) {
634     if (thesame) {
635       member = cur;
636     }
637     else {
638       member = Expr::CopyShare(theexp);
639       member->Replace(var,cur);
640     }
641     seq.Append(member);
642     cur = (cur + inc)->ShallowSimplified();
643   }
644   res = new Expr_Product(seq);
645   ExprIntrp_Recept.Push(res->ShallowSimplified());
646 }