- Parser location is now a custom class. It holds a shared pointer
with the file name; If the parser fails, the resource is deleted.
- To follow the parser change, the Rule class now holds the file
name in a shared pointer instead of a unique pointer. As a shared
pointer we avoid duplication of the file name in memory, plus,
it frees itself when not in use anymore.
- Operator init also accepting the filename as a shared pointer.
- Driver is treating m_location was privative. Now it holds a
std::list<std::shared_ptr<yy::seclang_parser::location_type>>
instead of: std::list<yy::seclang_parser::location_type *>.
- Fix: addSecRule on Driver() was changed from RuleWithAction to
RuleWithOperator.
- Minor changes on the regression and rules-check utility to force
deletion of resources even when they fail.
- Couple of virtual destructors were placed to force the shared
pointer decrementing on shared variables.
- Deleted constructors for copy were placed for the sake of
readability.
On `Use std::shared_ptr for variable resolution` @WGH changes
VariableValue to be a shared_ptr. As shared pointer, the copy
on AnchoredVariable is no longer necessary. The copy was removed
along with the copy constructor.
AnchoredSetVariable::resolve is called for every rule
(see RuleWithOperator::evaluate). The previous implementation allocated
a new copy of every variable, which quickly added up. In my tests,
AnchoredSetVariable::resolve function consumed 7.8% of run time.
AnchoredSetVariable (which is a multimap) values are never changed,
only added. This means it's safe to store them in std::shared_ptr,
and make resolve return shared_ptr pointing to the same object.
Other resolve implementation could also use this optimization by not
allocating new objects, however, they are not hot spots, so this
optimization was not implemented there.
In my benchmark, this raises performance from 117 requests per second to
131 RPS, and overhead is lowered from 7.8% to 2.4%.
As a bonus, replacing plain pointer with smart pointers make code
cleaner, since using smart pointers makes manual deletes no longer necessary.
Additionally, VariableOrigin is now stored in plain std::vector,
since it's wasteful to store structure containing just two integer
values using std::list<std::unique_ptr<T>>.
