projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0026937: Eliminate NO_CXX_EXCEPTION macro support
[occt.git] / src / ExprIntrp / ExprIntrp_yaccintrf.cxx
CommitLineData
b311480e 1// Copyright (c) 1997-1999 Matra Datavision
973c2be1 2// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 3//
973c2be1 4// This file is part of Open CASCADE Technology software library.
b311480e 5//
d5f74e42 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
973c2be1 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.
b311480e 11//
973c2be1 12// Alternatively, this file may be used under the terms of Open CASCADE
13// commercial license or contractual agreement.
b311480e 14
7fd59977 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>
2a54ebbf 49#include <Expr.hxx>
7fd59977 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>
2a54ebbf 55
56static TCollection_AsciiString ExprIntrp_assname;
57static TCollection_AsciiString ExprIntrp_funcdefname;
7fd59977 58static Standard_Integer ExprIntrp_nbargs;
59static Standard_Integer ExprIntrp_nbdiff;
60
7fd59977 61extern "C" void ExprIntrp_StartFunction()
62{
2a54ebbf 63 const TCollection_AsciiString& name = ExprIntrp_GetResult();
7fd59977 64 ExprIntrp_Recept.PushName(name);
65 ExprIntrp_nbargs = 0;
66}
67
68extern "C" void ExprIntrp_StartDerivate()
69{
2a54ebbf 70 const TCollection_AsciiString& name = ExprIntrp_GetResult();
7fd59977 71 ExprIntrp_Recept.PushName(name);
72}
73
74extern "C" void ExprIntrp_EndDerivate()
75{
76 int degree;
77 degree = ExprIntrp_GetDegree();
78 ExprIntrp_Recept.PushValue(degree);
79}
80
81extern "C" void ExprIntrp_Derivation()
82{
83 ExprIntrp_Recept.PushValue(1);
2a54ebbf 84 const TCollection_AsciiString& thename = ExprIntrp_GetResult();
7fd59977 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))) {
9775fa61 90 throw ExprIntrp_SyntaxError();
7fd59977 91 }
92 ExprIntrp_Recept.Push(namexp);
93}
94
95extern "C" void ExprIntrp_DerivationValue()
96{
2a54ebbf 97 const TCollection_AsciiString& aStr = ExprIntrp_GetResult();
98 ExprIntrp_Recept.PopValue();
99 ExprIntrp_Recept.PushValue(aStr.IntegerValue());
7fd59977 100}
101
102extern "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
111extern "C" void ExprIntrp_StartDifferential()
112{
113 ExprIntrp_StartDerivate();
114 ExprIntrp_nbdiff = 0;
115}
116
117extern "C" void ExprIntrp_DiffDegreeVar()
118{
2a54ebbf 119 const TCollection_AsciiString& aStr = ExprIntrp_GetResult();
120 const char* s = aStr.ToCString();
121 if ( *s != 'X' && *s != 'x' ) {
9775fa61 122 throw ExprIntrp_SyntaxError();
7fd59977 123 }
7fd59977 124 s++;
125 Standard_Integer rank = atoi(s);
126 ExprIntrp_Recept.PushValue(rank);
127 ExprIntrp_nbdiff++;
128}
129
130extern "C" void ExprIntrp_DiffVar()
131{
132 ExprIntrp_Recept.PushValue(1);
133 ExprIntrp_DiffDegreeVar();
134}
135
136extern "C" void ExprIntrp_DiffDegree()
137{
2a54ebbf 138 const TCollection_AsciiString& aStr = ExprIntrp_GetResult();
139 Standard_Integer deg = aStr.IntegerValue();
7fd59977 140 ExprIntrp_Recept.PushValue(deg);
141}
142
143extern "C" void ExprIntrp_VerDiffDegree()
144{
2a54ebbf 145 const TCollection_AsciiString& aStr = ExprIntrp_GetResult();
146 Standard_Integer deg = aStr.IntegerValue();
7fd59977 147 Standard_Integer thedeg = ExprIntrp_Recept.PopValue();
148 if (deg != thedeg) {
9775fa61 149 throw ExprIntrp_SyntaxError();
7fd59977 150 }
151 ExprIntrp_Recept.PushValue(deg);
152}
153
154extern "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()) {
9775fa61 159 throw ExprIntrp_SyntaxError();
7fd59977 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)) {
9775fa61 169 throw ExprIntrp_SyntaxError();
7fd59977 170 }
171 thediff = thefunc->Variable(rank);
172 thefunc = new Expr_FunctionDerivative(thefunc,thediff,degree);
173 }
174 ExprIntrp_Recept.PushFunction(thefunc);
175}
176
177extern "C" void ExprIntrp_EndDiffFunction()
178{
179 Handle(Expr_GeneralFunction) thefunc = ExprIntrp_Recept.PopFunction();
180 if (thefunc.IsNull()) {
9775fa61 181 throw ExprIntrp_SyntaxError();
7fd59977 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()) {
9775fa61 194 throw ExprIntrp_SyntaxError();
7fd59977 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()) {
9775fa61 206 throw ExprIntrp_SyntaxError();
7fd59977 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
216static 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
281extern "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()) {
9775fa61 292 throw ExprIntrp_SyntaxError();
7fd59977 293 }
294 else {
295 var = rit.Value();
296 if (var->IsAssigned()) {
297 var.Nullify();
298 }
299 }
300 rit.Next();
301 }
302 if (var.IsNull()) {
9775fa61 303 throw ExprIntrp_SyntaxError();
7fd59977 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()) {
9775fa61 313 throw ExprIntrp_SyntaxError();
7fd59977 314 }
315 Standard_Integer nbargs = thefunc->NbOfVariables();
316 if (nbargs != 1) {
9775fa61 317 throw ExprIntrp_SyntaxError();
7fd59977 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
328extern "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()) {
9775fa61 340 throw ExprIntrp_SyntaxError();
7fd59977 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()) {
9775fa61 351 throw ExprIntrp_SyntaxError();
7fd59977 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()) {
9775fa61 364 throw ExprIntrp_SyntaxError();
7fd59977 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
375extern "C" void ExprIntrp_NextFuncArg()
376{
377 ExprIntrp_nbargs++;
378}
379
380extern "C" void ExprIntrp_EndFuncArg()
381{
382 ExprIntrp_nbargs++;
383}
384
385extern "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
394extern "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
402extern "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
410extern "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
418extern "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
426extern "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
ab146989 433extern "C" void ExprIntrp_UnaryPlusOperator()
434{
435 Handle(Expr_GeneralExpression) op = ExprIntrp_Recept.Pop();
436 ExprIntrp_Recept.Push(op);
437}
438
7fd59977 439extern "C" void ExprIntrp_VariableIdentifier()
440{
2a54ebbf 441 const TCollection_AsciiString& thename = ExprIntrp_GetResult();
7fd59977 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
450extern "C" void ExprIntrp_NumValue()
451{
2a54ebbf 452 const TCollection_AsciiString& aStr = ExprIntrp_GetResult();
453 Standard_Real value = aStr.RealValue();
7fd59977 454 Handle(Expr_NumericValue) nval = new Expr_NumericValue(value);
455 ExprIntrp_Recept.Push(nval);
456}
457
458extern "C" void ExprIntrp_AssignVariable()
459{
2a54ebbf 460 ExprIntrp_assname = ExprIntrp_GetResult();
7fd59977 461}
462
463extern "C" void ExprIntrp_Deassign()
464{
2a54ebbf 465 const TCollection_AsciiString& thename = ExprIntrp_GetResult();
7fd59977 466 Handle(Expr_NamedExpression) nameexp = ExprIntrp_Recept.GetNamed(thename);
467 if (nameexp.IsNull()) {
9775fa61 468 throw ExprIntrp_SyntaxError();
7fd59977 469 }
470 if (!nameexp->IsKind(STANDARD_TYPE(Expr_NamedUnknown))) {
9775fa61 471 throw ExprIntrp_SyntaxError();
7fd59977 472 }
473 Handle(Expr_NamedUnknown) var = Handle(Expr_NamedUnknown)::DownCast(nameexp);
474 var->Deassign();
475}
476
477extern "C" void ExprIntrp_DefineFunction()
478{
479 ExprIntrp_funcdefname = ExprIntrp_Recept.PopName();
480 ExprIntrp_Recept.PushValue(ExprIntrp_nbargs);
481}
482
483extern "C" void ExprIntrp_close()
484{
485 ExprIntrp_stop_string();
486}
487
488extern "C" void ExprIntrperror(char* msg)
489{
490 ExprIntrp_close();
9775fa61 491 throw ExprIntrp_SyntaxError(msg);
7fd59977 492}
493
494
495extern "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
503extern "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
529extern "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);
543a9964 535 const Handle(Expr_NamedExpression)& aNamedExpr = namu; // to resolve ambiguity
536 ExprIntrp_Recept.Use(aNamedExpr);
7fd59977 537 }
538 else {
539 if (!namexp->IsKind(STANDARD_TYPE(Expr_NamedUnknown))) {
9775fa61 540 throw ExprIntrp_SyntaxError();
7fd59977 541 }
542 namu = Handle(Expr_NamedUnknown)::DownCast(namexp);
543 }
544 namu->Assign(ExprIntrp_Recept.Pop());
545}
546
547extern "C" void ExprIntrp_EndOfFuncDef()
548{
549 Handle(Expr_GeneralExpression) theexp = ExprIntrp_Recept.Pop();
550 Standard_Integer nbargs = ExprIntrp_Recept.PopValue();
551 Expr_Array1OfNamedUnknown vars(1,nbargs);
552 Expr_Array1OfNamedUnknown internvars(1,nbargs);
553 Standard_Integer i;
554 for (i=nbargs; i > 0; i--) {
555 vars(i) = Handle(Expr_NamedUnknown)::DownCast(ExprIntrp_Recept.Pop());
556 internvars(i) = Handle(Expr_NamedUnknown)::DownCast(vars(i)->Copy());
557 }
558 theexp = Expr::CopyShare(theexp); // ATTENTION, PROTECTION BUG STACK
559 for (i=1; i<= nbargs; i++) {
560 if (theexp->Contains(vars(i))) {
561 theexp->Replace(vars(i),internvars(i));
562 }
563 else {
564 if (theexp == vars(i)) {
565 theexp = internvars(i);
566 }
567 }
568 }
569 Handle(Expr_NamedFunction) thefunc =
570 new Expr_NamedFunction(ExprIntrp_funcdefname,
571 theexp,
572 internvars);
573 ExprIntrp_Recept.Use(thefunc);
574}
575
576extern "C" void ExprIntrp_ConstantIdentifier()
577{
2a54ebbf 578 const TCollection_AsciiString& thename = ExprIntrp_GetResult();
7fd59977 579 ExprIntrp_Recept.PushName(thename);
580}
581
582extern "C" void ExprIntrp_ConstantDefinition()
583{
584 TCollection_AsciiString name = ExprIntrp_Recept.PopName();
2a54ebbf 585 const TCollection_AsciiString& aStr = ExprIntrp_GetResult();
586 Standard_Real val = aStr.RealValue();
7fd59977 587 Handle(Expr_NamedConstant) theconst = new Expr_NamedConstant(name,val);
543a9964 588 const Handle(Expr_NamedExpression) theexpr = theconst; // to resolve ambiguity
589 ExprIntrp_Recept.Use(theexpr);
7fd59977 590 ExprIntrp_Recept.Push(theconst);
591}
592
593
594extern "C" void ExprIntrp_Sumator()
595{
596 Handle(Expr_NumericValue) number = Handle(Expr_NumericValue)::DownCast(ExprIntrp_Recept.Pop());
597 Standard_Integer nb = (Standard_Integer) number->GetValue();
598 Handle(Expr_GeneralExpression) inc = ExprIntrp_Recept.Pop();
599 Handle(Expr_GeneralExpression) first = ExprIntrp_Recept.Pop();
600 Handle(Expr_NamedUnknown) var = Handle(Expr_NamedUnknown)::DownCast(ExprIntrp_Recept.Pop());
601 Handle(Expr_GeneralExpression) theexp = ExprIntrp_Recept.Pop();
602 Standard_Boolean thesame = (theexp == var);
603 Handle(Expr_GeneralExpression) cur = Expr::CopyShare(first);
604 Handle(Expr_GeneralExpression) res;
605 Handle(Expr_GeneralExpression) member;
606 Expr_SequenceOfGeneralExpression seq;
607 for (Standard_Integer i=1; i<= nb; i++) {
608 if (thesame) {
609 member = cur;
610 }
611 else {
612 member = Expr::CopyShare(theexp);
613 member->Replace(var,cur);
614 }
615 seq.Append(member);
616 cur = (cur + inc)->ShallowSimplified();
617 }
618 res = new Expr_Sum(seq);
619 ExprIntrp_Recept.Push(res->ShallowSimplified());
620}
621
622extern "C" void ExprIntrp_Productor()
623{
624 Handle(Expr_NumericValue) number = Handle(Expr_NumericValue)::DownCast(ExprIntrp_Recept.Pop());
625 Standard_Integer nb = (Standard_Integer) number->GetValue();
626 Handle(Expr_GeneralExpression) inc = ExprIntrp_Recept.Pop();
627 Handle(Expr_GeneralExpression) first = ExprIntrp_Recept.Pop();
628 Handle(Expr_NamedUnknown) var = Handle(Expr_NamedUnknown)::DownCast(ExprIntrp_Recept.Pop());
629 Handle(Expr_GeneralExpression) theexp = ExprIntrp_Recept.Pop();
630 Standard_Boolean thesame = (theexp == var);
631 Handle(Expr_GeneralExpression) cur = Expr::CopyShare(first);
632 Handle(Expr_GeneralExpression) res;
633 Handle(Expr_GeneralExpression) member;
634 Expr_SequenceOfGeneralExpression seq;
635 for (Standard_Integer i=1; i<= nb; i++) {
636 if (thesame) {
637 member = cur;
638 }
639 else {
640 member = Expr::CopyShare(theexp);
641 member->Replace(var,cur);
642 }
643 seq.Append(member);
644 cur = (cur + inc)->ShallowSimplified();
645 }
646 res = new Expr_Product(seq);
647 ExprIntrp_Recept.Push(res->ShallowSimplified());
648}
Open CASCADE Technology repository