vitalif
/
openscad
mirror of https://github.com/vitalif/openscad
1
0
Fork 0
Code Issues Releases Wiki Activity

Reimplemented serialization of expression to string after last refactoring

master
Marius Kintel 2014-11-25 15:05:36 -05:00
parent 259d1b6435
commit 2644b19ce7
3 changed files with 197 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

275
src/expr.cc
View File

@ -131,118 +131,11 @@ namespace /* anonymous*/ {
}
bool Expression::isListComprehension()
bool Expression::isListComprehension() const
{
return false;
}
std::string Expression::toString() const
{
std::stringstream stream;
/*
switch (this->type) {
case EXPRESSION_TYPE_MULTIPLY:
case EXPRESSION_TYPE_DIVISION:
case EXPRESSION_TYPE_MODULO:
case EXPRESSION_TYPE_PLUS:
case EXPRESSION_TYPE_MINUS:
case EXPRESSION_TYPE_LESS:
case EXPRESSION_TYPE_GREATER:
stream << "(" << *this->children[0] << " " << this->type << " " << *this->children[1] << ")";
break;
case EXPRESSION_TYPE_NOT:
stream << "!" << *this->children[0];
break;
case EXPRESSION_TYPE_LOGICAL_AND:
stream << "(" << *this->children[0] << " && " << *this->children[1] << ")";
break;
case EXPRESSION_TYPE_LOGICAL_OR:
stream << "(" << *this->children[0] << " || " << *this->children[1] << ")";
break;
case EXPRESSION_TYPE_LESS_OR_EQUAL:
stream << "(" << *this->children[0] << " <= " << *this->children[1] << ")";
break;
case EXPRESSION_TYPE_EQUAL:
stream << "(" << *this->children[0] << " == " << *this->children[1] << ")";
break;
case EXPRESSION_TYPE_NOT_EQUAL:
stream << "(" << *this->children[0] << " != " << *this->children[1] << ")";
break;
case EXPRESSION_TYPE_GREATER_OR_EQUAL:
stream << "(" << *this->children[0] << " >= " << *this->children[1] << ")";
break;
case EXPRESSION_TYPE_TERNARY:
stream << "(" << *this->children[0] << " ? " << *this->children[1] << " : " << *this->children[2] << ")";
break;
case EXPRESSION_TYPE_ARRAY_ACCESS:
stream << *this->children[0] << "[" << *this->children[1] << "]";
break;
case EXPRESSION_TYPE_INVERT:
stream << "-" << *this->children[0];
break;
case EXPRESSION_TYPE_CONST:
stream << *this->const_value;
break;
case EXPRESSION_TYPE_RANGE:
stream << "[" << *this->children[0] << " : " << *this->children[1];
if (this->children.size() > 2) {
stream << " : " << *this->children[2];
}
stream << "]";
break;
case EXPRESSION_TYPE_VECTOR:
stream << "[";
for (size_t i=0; i < this->children.size(); i++) {
if (i > 0) stream << ", ";
stream << *this->children[i];
}
stream << "]";
break;
case EXPRESSION_TYPE_LOOKUP:
stream << this->var_name;
break;
case EXPRESSION_TYPE_MEMBER:
stream << *this->children[0] << "." << this->var_name;
break;
case EXPRESSION_TYPE_FUNCTION:
stream << this->call_funcname << "(" << this->call_arguments << ")";
break;
case EXPRESSION_TYPE_LET:
stream << "let(" << this->call_arguments << ") " << *this->children[0];
break;
case EXPRESSION_TYPE_LC_EXPRESSION: // list comprehension expression
//case EXPRESSION_TYPE_LC:
{
Expression const* c = this->children[0];
stream << "[";
do {
if (c->call_funcname == "for") {
stream << "for(" << c->call_arguments << ") ";
c = c->children[0];
} else if (c->call_funcname == "if") {
stream << "if(" << c->children[0] << ") ";
c = c->children[1];
} else if (c->call_funcname == "let") {
stream << "let(" << c->call_arguments << ") ";
c = c->children[0];
} else {
assert(false && "Illegal list comprehension element");
}
} while (c->type == EXPRESSION_TYPE_LC);
stream << *c << "]";
break;
}
default:
assert(false && "Illegal expression type");
break;
}
*/
return stream.str();
}
ExpressionNot::ExpressionNot(Expression *expr) : Expression(expr)
{
}
@ -252,6 +145,11 @@ ValuePtr ExpressionNot::evaluate(const Context *context) const
return !first->evaluate(context);
}
void ExpressionNot::print(std::ostream &stream) const
{
stream << "!" << *first;
}
ExpressionLogicalAnd::ExpressionLogicalAnd(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -261,6 +159,11 @@ ValuePtr ExpressionLogicalAnd::evaluate(const Context *context) const
return this->first->evaluate(context) && this->second->evaluate(context);
}
void ExpressionLogicalAnd::print(std::ostream &stream) const
{
stream << "(" << *first << " && " << *second << ")";
}
ExpressionLogicalOr::ExpressionLogicalOr(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -270,6 +173,11 @@ ValuePtr ExpressionLogicalOr::evaluate(const Context *context) const
return this->first->evaluate(context) || this->second->evaluate(context);
}
void ExpressionLogicalOr::print(std::ostream &stream) const
{
stream << "(" << *first << " || " << *second << ")";
}
ExpressionMultiply::ExpressionMultiply(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -279,6 +187,11 @@ ValuePtr ExpressionMultiply::evaluate(const Context *context) const
return this->first->evaluate(context) * this->second->evaluate(context);
}
void ExpressionMultiply::print(std::ostream &stream) const
{
stream << "(" << *first << " * " << *second << ")";
}
ExpressionDivision::ExpressionDivision(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -288,6 +201,11 @@ ValuePtr ExpressionDivision::evaluate(const Context *context) const
return this->first->evaluate(context) / this->second->evaluate(context);
}
void ExpressionDivision::print(std::ostream &stream) const
{
stream << "(" << *first << " / " << *second << ")";
}
ExpressionModulo::ExpressionModulo(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -297,6 +215,11 @@ ValuePtr ExpressionModulo::evaluate(const Context *context) const
return this->first->evaluate(context) % this->second->evaluate(context);
}
void ExpressionModulo::print(std::ostream &stream) const
{
stream << "(" << *first << " % " << *second << ")";
}
ExpressionPlus::ExpressionPlus(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -306,6 +229,11 @@ ValuePtr ExpressionPlus::evaluate(const Context *context) const
return this->first->evaluate(context) + this->second->evaluate(context);
}
void ExpressionPlus::print(std::ostream &stream) const
{
stream << "(" << *first << " + " << *second << ")";
}
ExpressionMinus::ExpressionMinus(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -315,6 +243,11 @@ ValuePtr ExpressionMinus::evaluate(const Context *context) const
return this->first->evaluate(context) - this->second->evaluate(context);
}
void ExpressionMinus::print(std::ostream &stream) const
{
stream << "(" << *first << " - " << *second << ")";
}
ExpressionLess::ExpressionLess(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -324,6 +257,11 @@ ValuePtr ExpressionLess::evaluate(const Context *context) const
return this->first->evaluate(context) < this->second->evaluate(context);
}
void ExpressionLess::print(std::ostream &stream) const
{
stream << "(" << *first << " < " << *second << ")";
}
ExpressionLessOrEqual::ExpressionLessOrEqual(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -333,6 +271,11 @@ ValuePtr ExpressionLessOrEqual::evaluate(const Context *context) const
return this->first->evaluate(context) <= this->second->evaluate(context);
}
void ExpressionLessOrEqual::print(std::ostream &stream) const
{
stream << "(" << *first << " <= " << *second << ")";
}
ExpressionEqual::ExpressionEqual(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -342,6 +285,11 @@ ValuePtr ExpressionEqual::evaluate(const Context *context) const
return this->first->evaluate(context) == this->second->evaluate(context);
}
void ExpressionEqual::print(std::ostream &stream) const
{
stream << "(" << *first << " == " << *second << ")";
}
ExpressionNotEqual::ExpressionNotEqual(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -351,6 +299,11 @@ ValuePtr ExpressionNotEqual::evaluate(const Context *context) const
return this->first->evaluate(context) != this->second->evaluate(context);
}
void ExpressionNotEqual::print(std::ostream &stream) const
{
stream << "(" << *first << " != " << *second << ")";
}
ExpressionGreaterOrEqual::ExpressionGreaterOrEqual(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -360,6 +313,11 @@ ValuePtr ExpressionGreaterOrEqual::evaluate(const Context *context) const
return this->first->evaluate(context) >= this->second->evaluate(context);
}
void ExpressionGreaterOrEqual::print(std::ostream &stream) const
{
stream << "(" << *first << " >= " << *second << ")";
}
ExpressionGreater::ExpressionGreater(Expression *left, Expression *right) : Expression(left, right)
{
}
@ -369,6 +327,11 @@ ValuePtr ExpressionGreater::evaluate(const Context *context) const
return this->first->evaluate(context) > this->second->evaluate(context);
}
void ExpressionGreater::print(std::ostream &stream) const
{
stream << "(" << *first << " > " << *second << ")";
}
ExpressionTernary::ExpressionTernary(Expression *expr1, Expression *expr2, Expression *expr3) : Expression(expr1, expr2, expr3)
{
}
@ -378,14 +341,24 @@ ValuePtr ExpressionTernary::evaluate(const Context *context) const
return (this->first->evaluate(context) ? this->second : this->third)->evaluate(context);
}
ExpressionArray::ExpressionArray(Expression *left, Expression *right) : Expression(left, right)
void ExpressionTernary::print(std::ostream &stream) const
{
stream << "(" << *first << " ? " << *second << " : " << *third << ")";
}
ExpressionArrayLookup::ExpressionArrayLookup(Expression *left, Expression *right) : Expression(left, right)
{
}
ValuePtr ExpressionArray::evaluate(const Context *context) const {
ValuePtr ExpressionArrayLookup::evaluate(const Context *context) const {
return this->first->evaluate(context)[this->second->evaluate(context)];
}
void ExpressionArrayLookup::print(std::ostream &stream) const
{
stream << *first << "[" << *second << "]";
}
ExpressionInvert::ExpressionInvert(Expression *expr) : Expression(expr)
{
}
@ -395,6 +368,11 @@ ValuePtr ExpressionInvert::evaluate(const Context *context) const
return -this->first->evaluate(context);
}
void ExpressionInvert::print(std::ostream &stream) const
{
stream << "-" << *first;
}
ExpressionConst::ExpressionConst(const ValuePtr &val) : Expression(val)
{
}
@ -404,6 +382,11 @@ ValuePtr ExpressionConst::evaluate(const class Context *) const
return ValuePtr(this->const_value);
}
void ExpressionConst::print(std::ostream &stream) const
{
stream << *this->const_value;
}
ExpressionRange::ExpressionRange(Expression *expr1, Expression *expr2) : Expression(expr1, expr2)
{
}
@ -433,6 +416,13 @@ ValuePtr ExpressionRange::evaluate(const Context *context) const
return ValuePtr::undefined;
}
void ExpressionRange::print(std::ostream &stream) const
{
stream << "[" << *first << " : " << *second;
if (this->children.size() > 2) stream << " : " << *third;
stream << "]";
}
ExpressionVector::ExpressionVector(Expression *expr) : Expression(expr)
{
}
@ -446,6 +436,16 @@ ValuePtr ExpressionVector::evaluate(const Context *context) const
return ValuePtr(vec);
}
void ExpressionVector::print(std::ostream &stream) const
{
stream << "[";
for (size_t i=0; i < this->children.size(); i++) {
if (i > 0) stream << ", ";
stream << *this->children[i];
}
stream << "]";
}
ExpressionLookup::ExpressionLookup(const std::string &val) : Expression(val)
{
}
@ -455,6 +455,11 @@ ValuePtr ExpressionLookup::evaluate(const Context *context) const
return context->lookup_variable(this->var_name);
}
void ExpressionLookup::print(std::ostream &stream) const
{
stream << this->var_name;
}
ExpressionMember::ExpressionMember(const std::string &val, Expression *expr) : Expression(val, expr)
{
}
@ -475,6 +480,11 @@ ValuePtr ExpressionMember::evaluate(const Context *context) const
return ValuePtr::undefined;
}
void ExpressionMember::print(std::ostream &stream) const
{
stream << *first << "." << this->var_name;
}
ExpressionFunction::ExpressionFunction()
{
}
@ -492,7 +502,12 @@ ValuePtr ExpressionFunction::evaluate(const Context *context) const
return result;
}
ExpressionLet::ExpressionLet()
void ExpressionFunction::print(std::ostream &stream) const
{
stream << this->call_funcname << "(" << this->call_arguments << ")";
}
ExpressionLet::ExpressionLet(Expression *expr) : Expression(expr)
{
}
@ -504,6 +519,11 @@ ValuePtr ExpressionLet::evaluate(const Context *context) const
return this->children[0]->evaluate(&c);
}
void ExpressionLet::print(std::ostream &stream) const
{
stream << "let(" << this->call_arguments << ") " << *first;
}
ExpressionLcExpression::ExpressionLcExpression(Expression *expr) : Expression(expr)
{
}
@ -513,6 +533,30 @@ ValuePtr ExpressionLcExpression::evaluate(const Context *context) const
return this->children[0]->evaluate(context);
}
void ExpressionLcExpression::print(std::ostream &stream) const
{
Expression const* c = this->first;
stream << "[";
do {
if (c->call_funcname == "for") {
stream << "for(" << c->call_arguments << ") ";
c = c->children[0];
} else if (c->call_funcname == "if") {
stream << "if(" << c->children[0] << ") ";
c = c->children[1];
} else if (c->call_funcname == "let") {
stream << "let(" << c->call_arguments << ") ";
c = c->children[0];
} else {
assert(false && "Illegal list comprehension element");
}
} while (c->isListComprehension());
stream << *c << "]";
}
ExpressionLc::ExpressionLc(Expression *expr) : Expression(expr)
{
}
@ -521,7 +565,7 @@ ExpressionLc::ExpressionLc(Expression *expr1, Expression *expr2) : Expression(ex
{
}
bool ExpressionLc::isListComprehension()
bool ExpressionLc::isListComprehension() const
{
return true;
}
@ -587,8 +631,13 @@ ValuePtr ExpressionLc::evaluate(const Context *context) const
}
}
void ExpressionLc::print(std::ostream &stream) const
{
// FIXME: Implement?
}
std::ostream &operator<<(std::ostream &stream, const Expression &expr)
{
stream << expr.toString();
expr.print(stream);
return stream;
}

40
src/expression.h
View File

@ -28,9 +28,9 @@ public:
Expression(Expression *expr1, Expression *expr2, Expression *expr3);
virtual ~Expression();
virtual bool isListComprehension();
virtual bool isListComprehension() const;
virtual ValuePtr evaluate(const class Context *context) const = 0;
std::string toString() const;
virtual void print(std::ostream &stream) const = 0;
};
std::ostream &operator<<(std::ostream &stream, const Expression &expr);
@ -39,7 +39,8 @@ class ExpressionNot : public Expression
{
public:
ExpressionNot(Expression *expr);
ValuePtr evaluate(const class Context *context) const;
virtual ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionLogicalAnd : public Expression
@ -47,6 +48,7 @@ class ExpressionLogicalAnd : public Expression
public:
ExpressionLogicalAnd(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionLogicalOr : public Expression
@ -54,6 +56,7 @@ class ExpressionLogicalOr : public Expression
public:
ExpressionLogicalOr(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionMultiply : public Expression
@ -61,6 +64,7 @@ class ExpressionMultiply : public Expression
public:
ExpressionMultiply(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionDivision : public Expression
@ -68,6 +72,7 @@ class ExpressionDivision : public Expression
public:
ExpressionDivision(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionModulo : public Expression
@ -75,6 +80,7 @@ class ExpressionModulo : public Expression
public:
ExpressionModulo(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionPlus : public Expression
@ -82,6 +88,7 @@ class ExpressionPlus : public Expression
public:
ExpressionPlus(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionMinus : public Expression
@ -89,6 +96,7 @@ class ExpressionMinus : public Expression
public:
ExpressionMinus(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionLess : public Expression
@ -96,6 +104,7 @@ class ExpressionLess : public Expression
public:
ExpressionLess(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionLessOrEqual : public Expression
@ -103,6 +112,7 @@ class ExpressionLessOrEqual : public Expression
public:
ExpressionLessOrEqual(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionEqual : public Expression
@ -110,6 +120,7 @@ class ExpressionEqual : public Expression
public:
ExpressionEqual(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionNotEqual : public Expression
@ -117,6 +128,7 @@ class ExpressionNotEqual : public Expression
public:
ExpressionNotEqual(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionGreaterOrEqual : public Expression
@ -124,6 +136,7 @@ class ExpressionGreaterOrEqual : public Expression
public:
ExpressionGreaterOrEqual(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionGreater : public Expression
@ -131,6 +144,7 @@ class ExpressionGreater : public Expression
public:
ExpressionGreater(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionTernary : public Expression
@ -138,13 +152,15 @@ class ExpressionTernary : public Expression
public:
ExpressionTernary(Expression *expr1, Expression *expr2, Expression *expr3);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionArray : public Expression
class ExpressionArrayLookup : public Expression
{
public:
ExpressionArray(Expression *left, Expression *right);
ExpressionArrayLookup(Expression *left, Expression *right);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionInvert : public Expression
@ -152,6 +168,7 @@ class ExpressionInvert : public Expression
public:
ExpressionInvert(Expression *expr);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionConst : public Expression
@ -159,6 +176,7 @@ class ExpressionConst : public Expression
public:
ExpressionConst(const ValuePtr &val);
ValuePtr evaluate(const class Context *) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionRange : public Expression
@ -167,6 +185,7 @@ public:
ExpressionRange(Expression *expr1, Expression *expr2);
ExpressionRange(Expression *expr1, Expression *expr2, Expression *expr3);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionVector : public Expression
@ -174,6 +193,7 @@ class ExpressionVector : public Expression
public:
ExpressionVector(Expression *expr);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionLookup : public Expression
@ -181,6 +201,7 @@ class ExpressionLookup : public Expression
public:
ExpressionLookup(const std::string &val);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionMember : public Expression
@ -188,6 +209,7 @@ class ExpressionMember : public Expression
public:
ExpressionMember(const std::string &val, Expression *expr);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionFunction : public Expression
@ -195,13 +217,15 @@ class ExpressionFunction : public Expression
public:
ExpressionFunction();
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionLet : public Expression
{
public:
ExpressionLet();
ExpressionLet(Expression *expr);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionLcExpression : public Expression
@ -209,13 +233,15 @@ class ExpressionLcExpression : public Expression
public:
ExpressionLcExpression(Expression *expr);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};
class ExpressionLc : public Expression
{
bool isListComprehension();
virtual bool isListComprehension() const;
public:
ExpressionLc(Expression *expr);
ExpressionLc(Expression *expr1, Expression *expr2);
ValuePtr evaluate(const class Context *context) const;
virtual void print(std::ostream &stream) const;
};

5
src/parser.y
View File

@ -333,10 +333,9 @@ expr:
}
| TOK_LET '(' arguments_call ')' expr %prec LET
{
$$ = new ExpressionLet();
$$ = new ExpressionLet($5);
$$->call_arguments = *$3;
delete $3;
$$->children.push_back($5);
}
| '[' expr ':' expr ']'
{
@ -432,7 +431,7 @@ expr:
}
| expr '[' expr ']'
{
$$ = new ExpressionArray($1, $3);
$$ = new ExpressionArrayLookup($1, $3);
}
| TOK_ID '(' arguments_call ')'
{