Skip to content
This repository was archived by the owner on Oct 24, 2025. It is now read-only.

Commit a0238e2

Browse files
mgretermgreter
committed
Remove Sass_OP Type from C++ and use enum from C-API
This enum is needed to expose operator API at C level!
1 parent 1c0cddf commit a0238e2

File tree

6 files changed

+92
-90
lines changed

6 files changed

+92
-90
lines changed

‎ast.hpp‎

Lines changed: 3 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,7 @@
4848

4949
#include "sass.h"
5050
#include "sass_values.h"
51+
#include "sass_context.h"
5152
#include "sass_functions.h"
5253

5354
namespace Sass {
@@ -851,21 +852,14 @@ namespace Sass {
851852
// subclassing.
852853
//////////////////////////////////////////////////////////////////////////
853854
class Binary_Expression : public Expression {
854-
public:
855-
enum Type {
856-
AND, OR, // logical connectives
857-
EQ, NEQ, GT, GTE, LT, LTE, // arithmetic relations
858-
ADD, SUB, MUL, DIV, MOD, // arithmetic functions
859-
NUM_OPS // so we know how big to make the op table
860-
};
861855
private:
862-
ADD_PROPERTY(Type, type)
856+
ADD_PROPERTY(enum Sass_OP, type)
863857
ADD_PROPERTY(Expression*, left)
864858
ADD_PROPERTY(Expression*, right)
865859
size_t hash_;
866860
public:
867861
Binary_Expression(ParserState pstate,
868-
Type t, Expression* lhs, Expression* rhs)
862+
enum Sass_OP t, Expression* lhs, Expression* rhs)
869863
: Expression(pstate), type_(t), left_(lhs), right_(rhs), hash_(0)
870864
{ }
871865
const string type_name() {

‎eval.cpp‎

Lines changed: 45 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ namespace Sass {
3232
inline double div(double x, double y) { return x / y; } // x/0 checked by caller
3333
inline double mod(double x, double y) { return abs(fmod(x, y)); } // x/0 checked by caller
3434
typedef double (*bop)(double, double);
35-
bop ops[Binary_Expression::NUM_OPS] = {
35+
bop ops[Sass_OP::NUM_OPS] = {
3636
0, 0, // and, or
3737
0, 0, 0, 0, 0, 0, // eq, neq, gt, gte, lt, lte
3838
add, sub, mul, div, mod
@@ -445,28 +445,28 @@ namespace Sass {
445445
bool lt(Expression*, Expression*, Context&);
446446
// -- arithmetic on the combinations that matter
447447
Expression* op_numbers(Context&, Binary_Expression*, Expression*, Expression*);
448-
Expression* op_number_color(Context&, Binary_Expression::Type, Expression*, Expression*);
449-
Expression* op_color_number(Context&, Binary_Expression::Type, Expression*, Expression*);
450-
Expression* op_colors(Context&, Binary_Expression::Type, Expression*, Expression*);
451-
Expression* op_strings(Context&, Binary_Expression::Type, Expression*, Expression*);
448+
Expression* op_number_color(Context&, enum Sass_OP, Expression*, Expression*);
449+
Expression* op_color_number(Context&, enum Sass_OP, Expression*, Expression*);
450+
Expression* op_colors(Context&, enum Sass_OP, Expression*, Expression*);
451+
Expression* op_strings(Context&, enum Sass_OP, Expression*, Expression*);
452452

453453
Expression* Eval::operator()(Binary_Expression* b)
454454
{
455-
Binary_Expression::Type op_type = b->type();
455+
enum Sass_OP op_type = b->type();
456456
// don't eval delayed expressions (the '/' when used as a separator)
457-
if (op_type == Binary_Expression::DIV && b->is_delayed()) return b;
457+
if (op_type == Sass_OP::DIV && b->is_delayed()) return b;
458458
b->is_delayed(false);
459459
// if one of the operands is a '/' then make sure it's evaluated
460460
Expression* lhs = b->left()->perform(this);
461461
lhs->is_delayed(false);
462462
while (typeid(*lhs) == typeid(Binary_Expression)) lhs = lhs->perform(this);
463463

464464
switch (op_type) {
465-
case Binary_Expression::AND:
465+
case Sass_OP::AND:
466466
return *lhs ? b->right()->perform(this) : lhs;
467467
break;
468468

469-
case Binary_Expression::OR:
469+
case Sass_OP::OR:
470470
return *lhs ? lhs : b->right()->perform(this);
471471
break;
472472

@@ -476,12 +476,12 @@ namespace Sass {
476476
// not a logical connective, so go ahead and eval the rhs
477477
Expression* rhs = b->right()->perform(this);
478478
// maybe fully evaluate structure
479-
if (op_type == Binary_Expression::EQ ||
480-
op_type == Binary_Expression::NEQ ||
481-
op_type == Binary_Expression::GT ||
482-
op_type == Binary_Expression::GTE ||
483-
op_type == Binary_Expression::LT ||
484-
op_type == Binary_Expression::LTE)
479+
if (op_type == Sass_OP::EQ ||
480+
op_type == Sass_OP::NEQ ||
481+
op_type == Sass_OP::GT ||
482+
op_type == Sass_OP::GTE ||
483+
op_type == Sass_OP::LT ||
484+
op_type == Sass_OP::LTE)
485485
{
486486
rhs->is_expanded(false);
487487
rhs->set_delayed(false);
@@ -494,7 +494,7 @@ namespace Sass {
494494
}
495495

496496
// upgrade string to number if possible (issue #948)
497-
if (op_type == Binary_Expression::DIV || op_type == Binary_Expression::MUL) {
497+
if (op_type == Sass_OP::DIV || op_type == Sass_OP::MUL) {
498498
if (String_Constant* str = dynamic_cast<String_Constant*>(rhs)) {
499499
const char* start = str->value().c_str();
500500
if (Prelexer::sequence < Prelexer::number >(start) != 0) {
@@ -506,12 +506,12 @@ namespace Sass {
506506

507507
// see if it's a relational expression
508508
switch(op_type) {
509-
case Binary_Expression::EQ: return new (ctx.mem) Boolean(b->pstate(), eq(lhs, rhs, ctx));
510-
case Binary_Expression::NEQ: return new (ctx.mem) Boolean(b->pstate(), !eq(lhs, rhs, ctx));
511-
case Binary_Expression::GT: return new (ctx.mem) Boolean(b->pstate(), !lt(lhs, rhs, ctx) && !eq(lhs, rhs, ctx));
512-
case Binary_Expression::GTE: return new (ctx.mem) Boolean(b->pstate(), !lt(lhs, rhs, ctx));
513-
case Binary_Expression::LT: return new (ctx.mem) Boolean(b->pstate(), lt(lhs, rhs, ctx));
514-
case Binary_Expression::LTE: return new (ctx.mem) Boolean(b->pstate(), lt(lhs, rhs, ctx) || eq(lhs, rhs, ctx));
509+
case Sass_OP::EQ: return new (ctx.mem) Boolean(b->pstate(), eq(lhs, rhs, ctx));
510+
case Sass_OP::NEQ: return new (ctx.mem) Boolean(b->pstate(), !eq(lhs, rhs, ctx));
511+
case Sass_OP::GT: return new (ctx.mem) Boolean(b->pstate(), !lt(lhs, rhs, ctx) && !eq(lhs, rhs, ctx));
512+
case Sass_OP::GTE: return new (ctx.mem) Boolean(b->pstate(), !lt(lhs, rhs, ctx));
513+
case Sass_OP::LT: return new (ctx.mem) Boolean(b->pstate(), lt(lhs, rhs, ctx));
514+
case Sass_OP::LTE: return new (ctx.mem) Boolean(b->pstate(), lt(lhs, rhs, ctx) || eq(lhs, rhs, ctx));
515515

516516
default: break;
517517
}
@@ -1153,11 +1153,11 @@ namespace Sass {
11531153
Number* r = static_cast<Number*>(rhs);
11541154
double lv = l->value();
11551155
double rv = r->value();
1156-
Binary_Expression::Type op = b->type();
1157-
if (op == Binary_Expression::DIV && !rv) {
1156+
enum Sass_OP op = b->type();
1157+
if (op == Sass_OP::DIV && !rv) {
11581158
return new (ctx.mem) String_Quoted(l->pstate(), "Infinity");
11591159
}
1160-
if (op == Binary_Expression::MOD && !rv) {
1160+
if (op == Sass_OP::MOD && !rv) {
11611161
error("division by zero", r->pstate());
11621162
}
11631163

@@ -1166,17 +1166,17 @@ namespace Sass {
11661166
string l_unit(l->unit());
11671167
string r_unit(tmp.unit());
11681168
if (l_unit != r_unit && !l_unit.empty() && !r_unit.empty() &&
1169-
(op == Binary_Expression::ADD || op == Binary_Expression::SUB)) {
1169+
(op == Sass_OP::ADD || op == Sass_OP::SUB)) {
11701170
error("Incompatible units: '"+r_unit+"' and '"+l_unit+"'.", l->pstate());
11711171
}
11721172
Number* v = new (ctx.mem) Number(*l);
11731173
v->pstate(b->pstate());
1174-
if (l_unit.empty() && (op == Binary_Expression::ADD || op == Binary_Expression::SUB || op == Binary_Expression::MOD)) {
1174+
if (l_unit.empty() && (op == Sass_OP::ADD || op == Sass_OP::SUB || op == Sass_OP::MOD)) {
11751175
v->numerator_units() = r->numerator_units();
11761176
v->denominator_units() = r->denominator_units();
11771177
}
11781178

1179-
if (op == Binary_Expression::MUL) {
1179+
if (op == Sass_OP::MUL) {
11801180
v->value(ops[op](lv, rv));
11811181
for (size_t i = 0, S = r->numerator_units().size(); i < S; ++i) {
11821182
v->numerator_units().push_back(r->numerator_units()[i]);
@@ -1185,7 +1185,7 @@ namespace Sass {
11851185
v->denominator_units().push_back(r->denominator_units()[i]);
11861186
}
11871187
}
1188-
else if (op == Binary_Expression::DIV) {
1188+
else if (op == Sass_OP::DIV) {
11891189
v->value(ops[op](lv, rv));
11901190
for (size_t i = 0, S = r->numerator_units().size(); i < S; ++i) {
11911191
v->denominator_units().push_back(r->numerator_units()[i]);
@@ -1200,7 +1200,7 @@ namespace Sass {
12001200
return v;
12011201
}
12021202

1203-
Expression* op_number_color(Context& ctx, Binary_Expression::Type op, Expression* lhs, Expression* rhs)
1203+
Expression* op_number_color(Context& ctx, enum Sass_OP op, Expression* lhs, Expression* rhs)
12041204
{
12051205
Number* l = static_cast<Number*>(lhs);
12061206
Color* r = static_cast<Color*>(rhs);
@@ -1210,17 +1210,17 @@ namespace Sass {
12101210
r->disp("");
12111211
double lv = l->value();
12121212
switch (op) {
1213-
case Binary_Expression::ADD:
1214-
case Binary_Expression::MUL: {
1213+
case Sass_OP::ADD:
1214+
case Sass_OP::MUL: {
12151215
return new (ctx.mem) Color(l->pstate(),
12161216
ops[op](lv, r->r()),
12171217
ops[op](lv, r->g()),
12181218
ops[op](lv, r->b()),
12191219
r->a());
12201220
} break;
1221-
case Binary_Expression::SUB:
1222-
case Binary_Expression::DIV: {
1223-
string sep(op == Binary_Expression::SUB ? "-" : "/");
1221+
case Sass_OP::SUB:
1222+
case Sass_OP::DIV: {
1223+
string sep(op == Sass_OP::SUB ? "-" : "/");
12241224
To_String to_string(&ctx);
12251225
string color(r->sixtuplet() && (ctx.output_style != COMPRESSED) ?
12261226
r->perform(&to_string) :
@@ -1230,7 +1230,7 @@ namespace Sass {
12301230
+ sep
12311231
+ color);
12321232
} break;
1233-
case Binary_Expression::MOD: {
1233+
case Sass_OP::MOD: {
12341234
error("cannot divide a number by a color", r->pstate());
12351235
} break;
12361236
default: break; // caller should ensure that we don't get here
@@ -1239,27 +1239,27 @@ namespace Sass {
12391239
return l;
12401240
}
12411241

1242-
Expression* op_color_number(Context& ctx, Binary_Expression::Type op, Expression* lhs, Expression* rhs)
1242+
Expression* op_color_number(Context& ctx, enum Sass_OP op, Expression* lhs, Expression* rhs)
12431243
{
12441244
Color* l = static_cast<Color*>(lhs);
12451245
Number* r = static_cast<Number*>(rhs);
12461246
double rv = r->value();
1247-
if (op == Binary_Expression::DIV && !rv) error("division by zero", r->pstate());
1247+
if (op == Sass_OP::DIV && !rv) error("division by zero", r->pstate());
12481248
return new (ctx.mem) Color(l->pstate(),
12491249
ops[op](l->r(), rv),
12501250
ops[op](l->g(), rv),
12511251
ops[op](l->b(), rv),
12521252
l->a());
12531253
}
12541254

1255-
Expression* op_colors(Context& ctx, Binary_Expression::Type op, Expression* lhs, Expression* rhs)
1255+
Expression* op_colors(Context& ctx, enum Sass_OP op, Expression* lhs, Expression* rhs)
12561256
{
12571257
Color* l = static_cast<Color*>(lhs);
12581258
Color* r = static_cast<Color*>(rhs);
12591259
if (l->a() != r->a()) {
12601260
error("alpha channels must be equal when combining colors", r->pstate());
12611261
}
1262-
if ((op == Binary_Expression::DIV || op == Binary_Expression::MOD) &&
1262+
if ((op == Sass_OP::DIV || op == Sass_OP::MOD) &&
12631263
(!r->r() || !r->g() ||!r->b())) {
12641264
error("division by zero", r->pstate());
12651265
}
@@ -1270,7 +1270,7 @@ namespace Sass {
12701270
l->a());
12711271
}
12721272

1273-
Expression* op_strings(Context& ctx, Binary_Expression::Type op, Expression* lhs, Expression*rhs)
1273+
Expression* op_strings(Context& ctx, enum Sass_OP op, Expression* lhs, Expression*rhs)
12741274
{
12751275
To_String to_string(&ctx);
12761276
Expression::Concrete_Type ltype = lhs->concrete_type();
@@ -1299,12 +1299,12 @@ namespace Sass {
12991299
else if (ltype == Expression::NUMBER && r_str_color) {
13001300
return op_number_color(ctx, op, lhs, ctx.names_to_colors[rstr]);
13011301
}
1302-
if (op == Binary_Expression::MUL) error("invalid operands for multiplication", lhs->pstate());
1303-
if (op == Binary_Expression::MOD) error("invalid operands for modulo", lhs->pstate());
1302+
if (op == Sass_OP::MUL) error("invalid operands for multiplication", lhs->pstate());
1303+
if (op == Sass_OP::MOD) error("invalid operands for modulo", lhs->pstate());
13041304
string sep;
13051305
switch (op) {
1306-
case Binary_Expression::SUB: sep = "-"; break;
1307-
case Binary_Expression::DIV: sep = "/"; break;
1306+
case Sass_OP::SUB: sep = "-"; break;
1307+
case Sass_OP::DIV: sep = "/"; break;
13081308
default: break;
13091309
}
13101310
if (ltype == Expression::NULL_VAL) error("invalid null operation: \"null plus "+quote(unquote(rstr), '"')+"\".", lhs->pstate());

‎inspect.cpp‎

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -409,19 +409,19 @@ namespace Sass {
409409
{
410410
expr->left()->perform(this);
411411
switch (expr->type()) {
412-
case Binary_Expression::AND: append_string(" and "); break;
413-
case Binary_Expression::OR: append_string(" or "); break;
414-
case Binary_Expression::EQ: append_string(" == "); break;
415-
case Binary_Expression::NEQ: append_string(" != "); break;
416-
case Binary_Expression::GT: append_string(" > "); break;
417-
case Binary_Expression::GTE: append_string(" >= "); break;
418-
case Binary_Expression::LT: append_string(" < "); break;
419-
case Binary_Expression::LTE: append_string(" <= "); break;
420-
case Binary_Expression::ADD: append_string(" + "); break;
421-
case Binary_Expression::SUB: append_string(" - "); break;
422-
case Binary_Expression::MUL: append_string(" * "); break;
423-
case Binary_Expression::DIV: append_string("/"); break;
424-
case Binary_Expression::MOD: append_string(" % "); break;
412+
case Sass_OP::AND: append_string(" and "); break;
413+
case Sass_OP::OR: append_string(" or "); break;
414+
case Sass_OP::EQ: append_string(" == "); break;
415+
case Sass_OP::NEQ: append_string(" != "); break;
416+
case Sass_OP::GT: append_string(" > "); break;
417+
case Sass_OP::GTE: append_string(" >= "); break;
418+
case Sass_OP::LT: append_string(" < "); break;
419+
case Sass_OP::LTE: append_string(" <= "); break;
420+
case Sass_OP::ADD: append_string(" + "); break;
421+
case Sass_OP::SUB: append_string(" - "); break;
422+
case Sass_OP::MUL: append_string(" * "); break;
423+
case Sass_OP::DIV: append_string("/"); break;
424+
case Sass_OP::MOD: append_string(" % "); break;
425425
default: break; // shouldn't get here
426426
}
427427
expr->right()->perform(this);

0 commit comments

Comments
 (0)