Skip to content

Commit e2b6f9a

Browse files
mgretermgreter
committed
Implement more detailed backtraces
Cleaned up exceptions a bit and moved static operators from eval to its own compile unit.
1 parent be64aef commit e2b6f9a

33 files changed

+946
-860
lines changed

‎Makefile.conf

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -41,6 +41,8 @@ SOURCES = \
4141
sass_context.cpp \
4242
sass_functions.cpp \
4343
sass2scss.cpp \
44+
backtrace.cpp \
45+
operators.cpp \
4446
to_c.cpp \
4547
to_value.cpp \
4648
source_map.cpp \

‎src/ast.cpp

Lines changed: 21 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -837,7 +837,7 @@ namespace Sass {
837837
return lhs_list->is_superselector_of(rhs_list);
838838
}
839839
}
840-
error("is_superselector expected a Selector_List", sub->pstate());
840+
coreError("is_superselector expected a Selector_List", sub->pstate());
841841
return false;
842842
}
843843

@@ -1171,7 +1171,7 @@ namespace Sass {
11711171
// check if we need to append some headers
11721172
// then we need to check for the combinator
11731173
// only then we can safely set the new tail
1174-
void Complex_Selector::append(Complex_Selector_Obj ss)
1174+
void Complex_Selector::append(Complex_Selector_Obj ss, Backtraces& traces)
11751175
{
11761176

11771177
Complex_Selector_Obj t = ss->tail();
@@ -1185,7 +1185,8 @@ namespace Sass {
11851185
// append old headers
11861186
if (h && h->length()) {
11871187
if (last()->combinator() != ANCESTOR_OF && c != ANCESTOR_OF) {
1188-
error("Invalid parent selector", pstate_);
1188+
traces.push_back(Backtrace(pstate()));
1189+
throw Exception::InvalidParent(this, traces, ss);
11891190
} else if (last()->head_ && last()->head_->length()) {
11901191
Compound_Selector_Obj rh = last()->head();
11911192
size_t i;
@@ -1258,21 +1259,21 @@ namespace Sass {
12581259
return list;
12591260
}
12601261

1261-
Selector_List_Ptr Selector_List::resolve_parent_refs(std::vector<Selector_List_Obj>& pstack, bool implicit_parent)
1262+
Selector_List_Ptr Selector_List::resolve_parent_refs(std::vector<Selector_List_Obj>& pstack, Backtraces& traces, bool implicit_parent)
12621263
{
12631264
if (!this->has_parent_ref()) return this;
12641265
Selector_List_Ptr ss = SASS_MEMORY_NEW(Selector_List, pstate());
12651266
Selector_List_Ptr ps = pstack.back();
12661267
for (size_t pi = 0, pL = ps->length(); pi < pL; ++pi) {
12671268
for (size_t si = 0, sL = this->length(); si < sL; ++si) {
1268-
Selector_List_Obj rv = at(si)->resolve_parent_refs(pstack, implicit_parent);
1269+
Selector_List_Obj rv = at(si)->resolve_parent_refs(pstack, traces, implicit_parent);
12691270
ss->concat(rv);
12701271
}
12711272
}
12721273
return ss;
12731274
}
12741275

1275-
Selector_List_Ptr Complex_Selector::resolve_parent_refs(std::vector<Selector_List_Obj>& pstack, bool implicit_parent)
1276+
Selector_List_Ptr Complex_Selector::resolve_parent_refs(std::vector<Selector_List_Obj>& pstack, Backtraces& traces, bool implicit_parent)
12761277
{
12771278
Complex_Selector_Obj tail = this->tail();
12781279
Compound_Selector_Obj head = this->head();
@@ -1285,7 +1286,7 @@ namespace Sass {
12851286
}
12861287

12871288
// first resolve_parent_refs the tail (which may return an expanded list)
1288-
Selector_List_Obj tails = tail ? tail->resolve_parent_refs(pstack, implicit_parent) : 0;
1289+
Selector_List_Obj tails = tail ? tail->resolve_parent_refs(pstack, traces, implicit_parent) : 0;
12891290

12901291
if (head && head->length() > 0) {
12911292

@@ -1331,7 +1332,7 @@ namespace Sass {
13311332
// keep old parser state
13321333
s->pstate(pstate());
13331334
// append new tail
1334-
s->append(ss);
1335+
s->append(ss, traces);
13351336
retval->append(s);
13361337
}
13371338
}
@@ -1346,7 +1347,8 @@ namespace Sass {
13461347
// this is only if valid if the parent has no trailing op
13471348
// otherwise we cannot append more simple selectors to head
13481349
if (parent->last()->combinator() != ANCESTOR_OF) {
1349-
throw Exception::InvalidParent(parent, ss);
1350+
traces.push_back(Backtrace(pstate()));
1351+
throw Exception::InvalidParent(parent, traces, ss);
13501352
}
13511353
ss->tail(tail ? SASS_MEMORY_CLONE(tail) : NULL);
13521354
Compound_Selector_Obj h = SASS_MEMORY_COPY(head_);
@@ -1369,7 +1371,7 @@ namespace Sass {
13691371
// keep old parser state
13701372
s->pstate(pstate());
13711373
// append new tail
1372-
s->append(ss);
1374+
s->append(ss, traces);
13731375
retval->append(s);
13741376
}
13751377
}
@@ -1406,7 +1408,7 @@ namespace Sass {
14061408
for (Simple_Selector_Obj ss : head->elements()) {
14071409
if (Wrapped_Selector_Ptr ws = Cast<Wrapped_Selector>(ss)) {
14081410
if (Selector_List_Ptr sl = Cast<Selector_List>(ws->selector())) {
1409-
if (parents) ws->selector(sl->resolve_parent_refs(pstack, implicit_parent));
1411+
if (parents) ws->selector(sl->resolve_parent_refs(pstack, traces, implicit_parent));
14101412
}
14111413
}
14121414
}
@@ -1690,7 +1692,7 @@ namespace Sass {
16901692
}
16911693

16921694
if (!pIter->head() || pIter->tail()) {
1693-
error("nested selectors may not be extended", c->pstate());
1695+
coreError("nested selectors may not be extended", c->pstate());
16941696
}
16951697

16961698
compound_sel->is_optional(extendee->is_optional());
@@ -1766,31 +1768,31 @@ namespace Sass {
17661768
{
17671769
if (!a->name().empty()) {
17681770
if (has_keyword_argument()) {
1769-
error("named arguments must precede variable-length argument", a->pstate());
1771+
coreError("named arguments must precede variable-length argument", a->pstate());
17701772
}
17711773
has_named_arguments(true);
17721774
}
17731775
else if (a->is_rest_argument()) {
17741776
if (has_rest_argument()) {
1775-
error("functions and mixins may only be called with one variable-length argument", a->pstate());
1777+
coreError("functions and mixins may only be called with one variable-length argument", a->pstate());
17761778
}
17771779
if (has_keyword_argument_) {
1778-
error("only keyword arguments may follow variable arguments", a->pstate());
1780+
coreError("only keyword arguments may follow variable arguments", a->pstate());
17791781
}
17801782
has_rest_argument(true);
17811783
}
17821784
else if (a->is_keyword_argument()) {
17831785
if (has_keyword_argument()) {
1784-
error("functions and mixins may only be called with one keyword argument", a->pstate());
1786+
coreError("functions and mixins may only be called with one keyword argument", a->pstate());
17851787
}
17861788
has_keyword_argument(true);
17871789
}
17881790
else {
17891791
if (has_rest_argument()) {
1790-
error("ordinal arguments must precede variable-length arguments", a->pstate());
1792+
coreError("ordinal arguments must precede variable-length arguments", a->pstate());
17911793
}
17921794
if (has_named_arguments()) {
1793-
error("ordinal arguments must precede named arguments", a->pstate());
1795+
coreError("ordinal arguments must precede named arguments", a->pstate());
17941796
}
17951797
}
17961798
}
@@ -1907,6 +1909,7 @@ namespace Sass {
19071909
l.normalize(); r.normalize();
19081910
Units &lhs_unit = l, &rhs_unit = r;
19091911
if (!(lhs_unit == rhs_unit)) {
1912+
/* ToDo: do we always get usefull backtraces? */
19101913
throw Exception::IncompatibleUnits(rhs, *this);
19111914
}
19121915
return lhs_unit < rhs_unit ||

‎src/ast.hpp

Lines changed: 37 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -572,13 +572,15 @@ namespace Sass {
572572
// Trace.
573573
/////////////////
574574
class Trace : public Has_Block {
575+
ADD_CONSTREF(char, type)
575576
ADD_CONSTREF(std::string, name)
576577
public:
577-
Trace(ParserState pstate, std::string n, Block_Obj b = 0)
578-
: Has_Block(pstate, b), name_(n)
578+
Trace(ParserState pstate, std::string n, Block_Obj b = 0, char type = 'm')
579+
: Has_Block(pstate, b), type_(type), name_(n)
579580
{ }
580581
Trace(const Trace* ptr)
581582
: Has_Block(ptr),
583+
type_(ptr->type_),
582584
name_(ptr->name_)
583585
{ }
584586
ATTACH_AST_OPERATIONS(Trace)
@@ -943,7 +945,7 @@ namespace Sass {
943945
/////////////////////////////////////////////////////////////////////////////
944946
struct Backtrace;
945947
typedef const char* Signature;
946-
typedef Expression_Ptr (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtrace*, std::vector<Selector_List_Obj>);
948+
typedef Expression_Ptr (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtraces, std::vector<Selector_List_Obj>);
947949
class Definition : public Has_Block {
948950
public:
949951
enum Type { MIXIN, FUNCTION };
@@ -1184,6 +1186,27 @@ namespace Sass {
11841186
}
11851187
}
11861188

1189+
inline static const std::string sass_op_separator(enum Sass_OP op) {
1190+
switch (op) {
1191+
case AND: return "&&";
1192+
case OR: return "||";
1193+
case EQ: return "==";
1194+
case NEQ: return "!=";
1195+
case GT: return ">";
1196+
case GTE: return ">=";
1197+
case LT: return "<";
1198+
case LTE: return "<=";
1199+
case ADD: return "+";
1200+
case SUB: return "-";
1201+
case MUL: return "*";
1202+
case DIV: return "/";
1203+
case MOD: return "%";
1204+
// this is only used internally!
1205+
case NUM_OPS: return "[OPS]";
1206+
default: return "invalid";
1207+
}
1208+
}
1209+
11871210
//////////////////////////////////////////////////////////////////////////
11881211
// Binary expressions. Represents logical, relational, and arithmetic
11891212
// operations. Templatized to avoid large switch statements and repetitive
@@ -1208,44 +1231,10 @@ namespace Sass {
12081231
hash_(ptr->hash_)
12091232
{ }
12101233
const std::string type_name() {
1211-
switch (optype()) {
1212-
case AND: return "and";
1213-
case OR: return "or";
1214-
case EQ: return "eq";
1215-
case NEQ: return "neq";
1216-
case GT: return "gt";
1217-
case GTE: return "gte";
1218-
case LT: return "lt";
1219-
case LTE: return "lte";
1220-
case ADD: return "add";
1221-
case SUB: return "sub";
1222-
case MUL: return "mul";
1223-
case DIV: return "div";
1224-
case MOD: return "mod";
1225-
// this is only used internally!
1226-
case NUM_OPS: return "[OPS]";
1227-
default: return "invalid";
1228-
}
1234+
return sass_op_to_name(optype());
12291235
}
12301236
const std::string separator() {
1231-
switch (optype()) {
1232-
case AND: return "&&";
1233-
case OR: return "||";
1234-
case EQ: return "==";
1235-
case NEQ: return "!=";
1236-
case GT: return ">";
1237-
case GTE: return ">=";
1238-
case LT: return "<";
1239-
case LTE: return "<=";
1240-
case ADD: return "+";
1241-
case SUB: return "-";
1242-
case MUL: return "*";
1243-
case DIV: return "/";
1244-
case MOD: return "%";
1245-
// this is only used internally!
1246-
case NUM_OPS: return "[OPS]";
1247-
default: return "invalid";
1248-
}
1237+
return sass_op_separator(optype());
12491238
}
12501239
bool is_left_interpolant(void) const;
12511240
bool is_right_interpolant(void) const;
@@ -1360,7 +1349,7 @@ namespace Sass {
13601349
: Expression(pstate), value_(val), name_(n), is_rest_argument_(rest), is_keyword_argument_(keyword), hash_(0)
13611350
{
13621351
if (!name_.empty() && is_rest_argument_) {
1363-
error("variable-length argument may not be passed by name", pstate_);
1352+
coreError("variable-length argument may not be passed by name", pstate_);
13641353
}
13651354
}
13661355
Argument(const Argument* ptr)
@@ -1372,7 +1361,7 @@ namespace Sass {
13721361
hash_(ptr->hash_)
13731362
{
13741363
if (!name_.empty() && is_rest_argument_) {
1375-
error("variable-length argument may not be passed by name", pstate_);
1364+
coreError("variable-length argument may not be passed by name", pstate_);
13761365
}
13771366
}
13781367

@@ -2218,22 +2207,22 @@ namespace Sass {
22182207
{
22192208
if (p->default_value()) {
22202209
if (has_rest_parameter()) {
2221-
error("optional parameters may not be combined with variable-length parameters", p->pstate());
2210+
coreError("optional parameters may not be combined with variable-length parameters", p->pstate());
22222211
}
22232212
has_optional_parameters(true);
22242213
}
22252214
else if (p->is_rest_parameter()) {
22262215
if (has_rest_parameter()) {
2227-
error("functions and mixins cannot have more than one variable-length parameter", p->pstate());
2216+
coreError("functions and mixins cannot have more than one variable-length parameter", p->pstate());
22282217
}
22292218
has_rest_parameter(true);
22302219
}
22312220
else {
22322221
if (has_rest_parameter()) {
2233-
error("required parameters must precede variable-length parameters", p->pstate());
2222+
coreError("required parameters must precede variable-length parameters", p->pstate());
22342223
}
22352224
if (has_optional_parameters()) {
2236-
error("required parameters must precede optional parameters", p->pstate());
2225+
coreError("required parameters must precede optional parameters", p->pstate());
22372226
}
22382227
}
22392228
}
@@ -2872,13 +2861,13 @@ namespace Sass {
28722861
Complex_Selector_Obj innermost() { return last(); };
28732862

28742863
size_t length() const;
2875-
Selector_List_Ptr resolve_parent_refs(std::vector<Selector_List_Obj>& pstack, bool implicit_parent = true);
2864+
Selector_List_Ptr resolve_parent_refs(std::vector<Selector_List_Obj>& pstack, Backtraces& traces, bool implicit_parent = true);
28762865
virtual bool is_superselector_of(Compound_Selector_Obj sub, std::string wrapping = "");
28772866
virtual bool is_superselector_of(Complex_Selector_Obj sub, std::string wrapping = "");
28782867
virtual bool is_superselector_of(Selector_List_Obj sub, std::string wrapping = "");
28792868
Selector_List_Ptr unify_with(Complex_Selector_Ptr rhs);
28802869
Combinator clear_innermost();
2881-
void append(Complex_Selector_Obj);
2870+
void append(Complex_Selector_Obj, Backtraces& traces);
28822871
void set_innermost(Complex_Selector_Obj, Combinator);
28832872
virtual size_t hash()
28842873
{
@@ -2994,7 +2983,7 @@ namespace Sass {
29942983
virtual bool has_parent_ref() const;
29952984
virtual bool has_real_parent_ref() const;
29962985
void remove_parent_selectors();
2997-
Selector_List_Ptr resolve_parent_refs(std::vector<Selector_List_Obj>& pstack, bool implicit_parent = true);
2986+
Selector_List_Ptr resolve_parent_refs(std::vector<Selector_List_Obj>& pstack, Backtraces& traces, bool implicit_parent = true);
29982987
virtual bool is_superselector_of(Compound_Selector_Obj sub, std::string wrapping = "");
29992988
virtual bool is_superselector_of(Complex_Selector_Obj sub, std::string wrapping = "");
30002989
virtual bool is_superselector_of(Selector_List_Obj sub, std::string wrapping = "");

‎src/ast_def_macros.hpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ class LocalOption {
3333

3434
#define NESTING_GUARD(name) \
3535
LocalOption<size_t> cnt_##name(name, name + 1); \
36-
if (name > MAX_NESTING) throw Exception::NestingLimitError(pstate); \
36+
if (name > MAX_NESTING) throw Exception::NestingLimitError(pstate, traces); \
3737

3838
#define ATTACH_OPERATIONS()\
3939
virtual void perform(Operation<void>* op) { (*op)(this); }\

‎src/ast_fwd_decl.hpp

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@
1111
#include <unordered_map>
1212
#include <unordered_set>
1313
#include "memory/SharedPtr.hpp"
14+
#include "sass/functions.h"
1415

1516
/////////////////////////////////////////////
1617
// Forward declarations for the AST visitors.
@@ -418,6 +419,8 @@ namespace Sass {
418419
typedef std::set<Compound_Selector_Obj, OrderNodes> CompoundSelectorSet;
419420
typedef std::unordered_set<Simple_Selector_Obj, HashNodes, CompareNodes> SimpleSelectorDict;
420421

422+
typedef std::vector<Sass_Import_Entry>* ImporterStack;
423+
421424
// only to switch implementations for testing
422425
#define environment_map std::map
423426

0 commit comments

Comments
 (0)