mirror of
https://github.com/zeek/zeek.git
synced 2025-10-09 18:18:19 +00:00
Merge remote-tracking branch 'origin/topic/timw/266-namespaces-part2'
* origin/topic/timw/266-namespaces-part2: Rename BroString files to ZeekString Update NEWS entry with note about class renames Rename BroObj to Obj Rename BroString to zeek::String Move Func up to zeek namespace, rename BroFunc to ScriptFunc Mark global val_mgr as deprecated and fix uses of it to use namespaced version Minor cleanup items from PR review Update binpac and bifcl submodules with review changes Move Location to zeek::detail and BroObj to zeek Move BroString to zeek namespace Move Dictionary/PDict, List/PList, and Queue/PQueue to zeek namespace Remove typedef that should have been removed in 3.1 Move Func and associated classes into zeek::detail namespace Move Frame and Scope to zeek::detail namespace Move all Val classes to the zeek namespaces Use type aliases for IntrusivePtr definitions Move deprecation macro to zeek-config.h.in to avoid having to over-include util.h Move IntrusivePtr and utility methods to the zeek namespace
This commit is contained in:
Jon Siwek
commit
76e67ff239
340 changed files with 8293 additions and 7822 deletions
356
src/Expr.h
356
src/Expr.h
|
|
@ -17,12 +17,18 @@
|
|||
#include "Val.h"
|
||||
#include "ZeekArgs.h"
|
||||
|
||||
template <class T> class IntrusivePtr;
|
||||
class Frame;
|
||||
class Scope;
|
||||
struct function_ingredients;
|
||||
ZEEK_FORWARD_DECLARE_NAMESPACED(Frame, zeek::detail);
|
||||
ZEEK_FORWARD_DECLARE_NAMESPACED(Scope, zeek::detail);
|
||||
|
||||
namespace zeek::detail {
|
||||
namespace zeek::detail { struct function_ingredients; }
|
||||
using function_ingredients [[deprecated("Remove in v4.1. Use zeek::detail::function_ingredients.")]] = zeek::detail::function_ingredients;
|
||||
|
||||
namespace zeek {
|
||||
template <class T> class IntrusivePtr;
|
||||
|
||||
namespace detail {
|
||||
|
||||
using IDPtr = zeek::IntrusivePtr<ID>;
|
||||
|
||||
enum BroExprTag : int {
|
||||
EXPR_ANY = -1,
|
||||
|
|
@ -73,39 +79,43 @@ class CallExpr;
|
|||
class EventExpr;
|
||||
class Stmt;
|
||||
|
||||
class Expr : public BroObj {
|
||||
class Expr;
|
||||
using ExprPtr = zeek::IntrusivePtr<Expr>;
|
||||
using EventExprPtr = zeek::IntrusivePtr<EventExpr>;
|
||||
using ListExprPtr = zeek::IntrusivePtr<ListExpr>;
|
||||
|
||||
class Expr : public Obj {
|
||||
public:
|
||||
[[deprecated("Remove in v4.1. Use GetType().")]]
|
||||
zeek::Type* Type() const { return type.get(); }
|
||||
|
||||
const IntrusivePtr<zeek::Type>& GetType() const
|
||||
const zeek::TypePtr& GetType() const
|
||||
{ return type; }
|
||||
|
||||
template <class T>
|
||||
IntrusivePtr<T> GetType() const
|
||||
{ return cast_intrusive<T>(type); }
|
||||
zeek::IntrusivePtr<T> GetType() const
|
||||
{ return zeek::cast_intrusive<T>(type); }
|
||||
|
||||
BroExprTag Tag() const { return tag; }
|
||||
|
||||
Expr* Ref() { ::Ref(this); return this; }
|
||||
Expr* Ref() { zeek::Ref(this); return this; }
|
||||
|
||||
// Evaluates the expression and returns a corresponding Val*,
|
||||
// or nil if the expression's value isn't fixed.
|
||||
virtual IntrusivePtr<Val> Eval(Frame* f) const = 0;
|
||||
virtual ValPtr Eval(Frame* f) const = 0;
|
||||
|
||||
// Same, but the context is that we are adding an element
|
||||
// into the given aggregate of the given type. Note that
|
||||
// return type is void since it's updating an existing
|
||||
// value, rather than creating a new one.
|
||||
virtual void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f)
|
||||
const;
|
||||
virtual void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f) const;
|
||||
|
||||
// Assign to the given value, if appropriate.
|
||||
virtual void Assign(Frame* f, IntrusivePtr<Val> v);
|
||||
virtual void Assign(Frame* f, ValPtr v);
|
||||
|
||||
// Returns the type corresponding to this expression interpreted
|
||||
// as an initialization. Returns nil if the initialization is illegal.
|
||||
virtual IntrusivePtr<zeek::Type> InitType() const;
|
||||
virtual zeek::TypePtr InitType() const;
|
||||
|
||||
// Returns true if this expression, interpreted as an initialization,
|
||||
// constitutes a record element, false otherwise. If the TypeDecl*
|
||||
|
|
@ -118,7 +128,7 @@ public:
|
|||
// with the given type. If "aggr" is non-nil, then this expression
|
||||
// is an element of the given aggregate, and it is added to it
|
||||
// accordingly.
|
||||
virtual IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const;
|
||||
virtual ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const;
|
||||
|
||||
// True if the expression has no side effects, false otherwise.
|
||||
virtual bool IsPure() const;
|
||||
|
|
@ -154,7 +164,7 @@ public:
|
|||
// Return the expression converted to L-value form. If expr
|
||||
// cannot be used as an L-value, reports an error and returns
|
||||
// the current value of expr (this is the default method).
|
||||
virtual IntrusivePtr<Expr> MakeLvalue();
|
||||
virtual ExprPtr MakeLvalue();
|
||||
|
||||
// Marks the expression as one requiring (or at least appearing
|
||||
// with) parentheses. Used for pretty-printing.
|
||||
|
|
@ -187,7 +197,7 @@ protected:
|
|||
// Puts the expression in canonical form.
|
||||
virtual void Canonicize();
|
||||
|
||||
void SetType(IntrusivePtr<zeek::Type> t);
|
||||
void SetType(zeek::TypePtr t);
|
||||
|
||||
// Reports the given error and sets the expression's type to
|
||||
// TYPE_ERROR.
|
||||
|
|
@ -199,19 +209,19 @@ protected:
|
|||
[[noreturn]] void RuntimeErrorWithCallStack(const std::string& msg) const;
|
||||
|
||||
BroExprTag tag;
|
||||
IntrusivePtr<zeek::Type> type;
|
||||
zeek::TypePtr type;
|
||||
bool paren;
|
||||
};
|
||||
|
||||
class NameExpr final : public Expr {
|
||||
public:
|
||||
explicit NameExpr(IntrusivePtr<ID> id, bool const_init = false);
|
||||
explicit NameExpr(zeek::detail::IDPtr id, bool const_init = false);
|
||||
|
||||
ID* Id() const { return id.get(); }
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
void Assign(Frame* f, IntrusivePtr<Val> v) override;
|
||||
IntrusivePtr<Expr> MakeLvalue() override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
void Assign(Frame* f, ValPtr v) override;
|
||||
ExprPtr MakeLvalue() override;
|
||||
bool IsPure() const override;
|
||||
|
||||
TraversalCode Traverse(TraversalCallback* cb) const override;
|
||||
|
|
@ -219,23 +229,23 @@ public:
|
|||
protected:
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
IntrusivePtr<ID> id;
|
||||
zeek::detail::IDPtr id;
|
||||
bool in_const_init;
|
||||
};
|
||||
|
||||
class ConstExpr final : public Expr {
|
||||
public:
|
||||
explicit ConstExpr(IntrusivePtr<Val> val);
|
||||
explicit ConstExpr(ValPtr val);
|
||||
|
||||
Val* Value() const { return val.get(); }
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
TraversalCode Traverse(TraversalCallback* cb) const override;
|
||||
|
||||
protected:
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
IntrusivePtr<Val> val;
|
||||
ValPtr val;
|
||||
};
|
||||
|
||||
class UnaryExpr : public Expr {
|
||||
|
|
@ -245,21 +255,21 @@ public:
|
|||
// UnaryExpr::Eval correctly handles vector types. Any child
|
||||
// class that overrides Eval() should be modified to handle
|
||||
// vectors correctly as necessary.
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
bool IsPure() const override;
|
||||
|
||||
TraversalCode Traverse(TraversalCallback* cb) const override;
|
||||
|
||||
protected:
|
||||
UnaryExpr(BroExprTag arg_tag, IntrusivePtr<Expr> arg_op);
|
||||
UnaryExpr(BroExprTag arg_tag, ExprPtr arg_op);
|
||||
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
// Returns the expression folded using the given constant.
|
||||
virtual IntrusivePtr<Val> Fold(Val* v) const;
|
||||
virtual ValPtr Fold(Val* v) const;
|
||||
|
||||
IntrusivePtr<Expr> op;
|
||||
ExprPtr op;
|
||||
};
|
||||
|
||||
class BinaryExpr : public Expr {
|
||||
|
|
@ -272,13 +282,13 @@ public:
|
|||
// BinaryExpr::Eval correctly handles vector types. Any child
|
||||
// class that overrides Eval() should be modified to handle
|
||||
// vectors correctly as necessary.
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
TraversalCode Traverse(TraversalCallback* cb) const override;
|
||||
|
||||
protected:
|
||||
BinaryExpr(BroExprTag arg_tag,
|
||||
IntrusivePtr<Expr> arg_op1, IntrusivePtr<Expr> arg_op2)
|
||||
ExprPtr arg_op1, ExprPtr arg_op2)
|
||||
: Expr(arg_tag), op1(std::move(arg_op1)), op2(std::move(arg_op2))
|
||||
{
|
||||
if ( ! (op1 && op2) )
|
||||
|
|
@ -288,20 +298,20 @@ protected:
|
|||
}
|
||||
|
||||
// Returns the expression folded using the given constants.
|
||||
virtual IntrusivePtr<Val> Fold(Val* v1, Val* v2) const;
|
||||
virtual ValPtr Fold(Val* v1, Val* v2) const;
|
||||
|
||||
// Same for when the constants are strings.
|
||||
virtual IntrusivePtr<Val> StringFold(Val* v1, Val* v2) const;
|
||||
virtual ValPtr StringFold(Val* v1, Val* v2) const;
|
||||
|
||||
// Same for when the constants are patterns.
|
||||
virtual IntrusivePtr<Val> PatternFold(Val* v1, Val* v2) const;
|
||||
virtual ValPtr PatternFold(Val* v1, Val* v2) const;
|
||||
|
||||
// Same for when the constants are sets.
|
||||
virtual IntrusivePtr<Val> SetFold(Val* v1, Val* v2) const;
|
||||
virtual ValPtr SetFold(Val* v1, Val* v2) const;
|
||||
|
||||
// Same for when the constants are addresses or subnets.
|
||||
virtual IntrusivePtr<Val> AddrFold(Val* v1, Val* v2) const;
|
||||
virtual IntrusivePtr<Val> SubNetFold(Val* v1, Val* v2) const;
|
||||
virtual ValPtr AddrFold(Val* v1, Val* v2) const;
|
||||
virtual ValPtr SubNetFold(Val* v1, Val* v2) const;
|
||||
|
||||
bool BothConst() const { return op1->IsConst() && op2->IsConst(); }
|
||||
|
||||
|
|
@ -317,148 +327,148 @@ protected:
|
|||
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
IntrusivePtr<Expr> op1;
|
||||
IntrusivePtr<Expr> op2;
|
||||
ExprPtr op1;
|
||||
ExprPtr op2;
|
||||
};
|
||||
|
||||
class CloneExpr final : public UnaryExpr {
|
||||
public:
|
||||
explicit CloneExpr(IntrusivePtr<Expr> op);
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
explicit CloneExpr(ExprPtr op);
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
};
|
||||
|
||||
class IncrExpr final : public UnaryExpr {
|
||||
public:
|
||||
IncrExpr(BroExprTag tag, IntrusivePtr<Expr> op);
|
||||
IncrExpr(BroExprTag tag, ExprPtr op);
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
IntrusivePtr<Val> DoSingleEval(Frame* f, Val* v) const;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
ValPtr DoSingleEval(Frame* f, Val* v) const;
|
||||
bool IsPure() const override;
|
||||
};
|
||||
|
||||
class ComplementExpr final : public UnaryExpr {
|
||||
public:
|
||||
explicit ComplementExpr(IntrusivePtr<Expr> op);
|
||||
explicit ComplementExpr(ExprPtr op);
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
};
|
||||
|
||||
class NotExpr final : public UnaryExpr {
|
||||
public:
|
||||
explicit NotExpr(IntrusivePtr<Expr> op);
|
||||
explicit NotExpr(ExprPtr op);
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
};
|
||||
|
||||
class PosExpr final : public UnaryExpr {
|
||||
public:
|
||||
explicit PosExpr(IntrusivePtr<Expr> op);
|
||||
explicit PosExpr(ExprPtr op);
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
};
|
||||
|
||||
class NegExpr final : public UnaryExpr {
|
||||
public:
|
||||
explicit NegExpr(IntrusivePtr<Expr> op);
|
||||
explicit NegExpr(ExprPtr op);
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
};
|
||||
|
||||
class SizeExpr final : public UnaryExpr {
|
||||
public:
|
||||
explicit SizeExpr(IntrusivePtr<Expr> op);
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
explicit SizeExpr(ExprPtr op);
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
};
|
||||
|
||||
class AddExpr final : public BinaryExpr {
|
||||
public:
|
||||
AddExpr(IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2);
|
||||
AddExpr(ExprPtr op1, ExprPtr op2);
|
||||
void Canonicize() override;
|
||||
};
|
||||
|
||||
class AddToExpr final : public BinaryExpr {
|
||||
public:
|
||||
AddToExpr(IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2);
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
AddToExpr(ExprPtr op1, ExprPtr op2);
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
};
|
||||
|
||||
class RemoveFromExpr final : public BinaryExpr {
|
||||
public:
|
||||
RemoveFromExpr(IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2);
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
RemoveFromExpr(ExprPtr op1, ExprPtr op2);
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
};
|
||||
|
||||
class SubExpr final : public BinaryExpr {
|
||||
public:
|
||||
SubExpr(IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2);
|
||||
SubExpr(ExprPtr op1, ExprPtr op2);
|
||||
};
|
||||
|
||||
class TimesExpr final : public BinaryExpr {
|
||||
public:
|
||||
TimesExpr(IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2);
|
||||
TimesExpr(ExprPtr op1, ExprPtr op2);
|
||||
void Canonicize() override;
|
||||
};
|
||||
|
||||
class DivideExpr final : public BinaryExpr {
|
||||
public:
|
||||
DivideExpr(IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2);
|
||||
DivideExpr(ExprPtr op1, ExprPtr op2);
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> AddrFold(Val* v1, Val* v2) const override;
|
||||
ValPtr AddrFold(Val* v1, Val* v2) const override;
|
||||
};
|
||||
|
||||
class ModExpr final : public BinaryExpr {
|
||||
public:
|
||||
ModExpr(IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2);
|
||||
ModExpr(ExprPtr op1, ExprPtr op2);
|
||||
};
|
||||
|
||||
class BoolExpr final : public BinaryExpr {
|
||||
public:
|
||||
BoolExpr(BroExprTag tag, IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2);
|
||||
BoolExpr(BroExprTag tag, ExprPtr op1, ExprPtr op2);
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
IntrusivePtr<Val> DoSingleEval(Frame* f, IntrusivePtr<Val> v1, Expr* op2) const;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
ValPtr DoSingleEval(Frame* f, ValPtr v1, Expr* op2) const;
|
||||
};
|
||||
|
||||
class BitExpr final : public BinaryExpr {
|
||||
public:
|
||||
BitExpr(BroExprTag tag, IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2);
|
||||
BitExpr(BroExprTag tag, ExprPtr op1, ExprPtr op2);
|
||||
};
|
||||
|
||||
class EqExpr final : public BinaryExpr {
|
||||
public:
|
||||
EqExpr(BroExprTag tag, IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2);
|
||||
EqExpr(BroExprTag tag, ExprPtr op1, ExprPtr op2);
|
||||
void Canonicize() override;
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v1, Val* v2) const override;
|
||||
ValPtr Fold(Val* v1, Val* v2) const override;
|
||||
};
|
||||
|
||||
class RelExpr final : public BinaryExpr {
|
||||
public:
|
||||
RelExpr(BroExprTag tag, IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2);
|
||||
RelExpr(BroExprTag tag, ExprPtr op1, ExprPtr op2);
|
||||
void Canonicize() override;
|
||||
};
|
||||
|
||||
class CondExpr final : public Expr {
|
||||
public:
|
||||
CondExpr(IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2, IntrusivePtr<Expr> op3);
|
||||
CondExpr(ExprPtr op1, ExprPtr op2, ExprPtr op3);
|
||||
|
||||
const Expr* Op1() const { return op1.get(); }
|
||||
const Expr* Op2() const { return op2.get(); }
|
||||
const Expr* Op3() const { return op3.get(); }
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
bool IsPure() const override;
|
||||
|
||||
TraversalCode Traverse(TraversalCallback* cb) const override;
|
||||
|
|
@ -466,53 +476,53 @@ public:
|
|||
protected:
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
IntrusivePtr<Expr> op1;
|
||||
IntrusivePtr<Expr> op2;
|
||||
IntrusivePtr<Expr> op3;
|
||||
ExprPtr op1;
|
||||
ExprPtr op2;
|
||||
ExprPtr op3;
|
||||
};
|
||||
|
||||
class RefExpr final : public UnaryExpr {
|
||||
public:
|
||||
explicit RefExpr(IntrusivePtr<Expr> op);
|
||||
explicit RefExpr(ExprPtr op);
|
||||
|
||||
void Assign(Frame* f, IntrusivePtr<Val> v) override;
|
||||
IntrusivePtr<Expr> MakeLvalue() override;
|
||||
void Assign(Frame* f, ValPtr v) override;
|
||||
ExprPtr MakeLvalue() override;
|
||||
};
|
||||
|
||||
class AssignExpr : public BinaryExpr {
|
||||
public:
|
||||
// If val is given, evaluating this expression will always yield the val
|
||||
// yet still perform the assignment. Used for triggers.
|
||||
AssignExpr(IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2, bool is_init,
|
||||
IntrusivePtr<Val> val = nullptr,
|
||||
const IntrusivePtr<Attributes>& attrs = nullptr);
|
||||
AssignExpr(ExprPtr op1, ExprPtr op2, bool is_init,
|
||||
ValPtr val = nullptr,
|
||||
const AttributesPtr& attrs = nullptr);
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f) const override;
|
||||
IntrusivePtr<zeek::Type> InitType() const override;
|
||||
zeek::TypePtr InitType() const override;
|
||||
bool IsRecordElement(TypeDecl* td) const override;
|
||||
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
|
||||
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
|
||||
bool IsPure() const override;
|
||||
|
||||
protected:
|
||||
bool TypeCheck(const IntrusivePtr<Attributes>& attrs = nullptr);
|
||||
bool TypeCheck(const AttributesPtr& attrs = nullptr);
|
||||
bool TypeCheckArithmetics(TypeTag bt1, TypeTag bt2);
|
||||
|
||||
bool is_init;
|
||||
IntrusivePtr<Val> val; // optional
|
||||
ValPtr val; // optional
|
||||
};
|
||||
|
||||
class IndexSliceAssignExpr final : public AssignExpr {
|
||||
public:
|
||||
IndexSliceAssignExpr(IntrusivePtr<Expr> op1,
|
||||
IntrusivePtr<Expr> op2, bool is_init);
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
IndexSliceAssignExpr(ExprPtr op1,
|
||||
ExprPtr op2, bool is_init);
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
};
|
||||
|
||||
class IndexExpr final : public BinaryExpr {
|
||||
public:
|
||||
IndexExpr(IntrusivePtr<Expr> op1,
|
||||
IntrusivePtr<ListExpr> op2, bool is_slice = false);
|
||||
IndexExpr(ExprPtr op1,
|
||||
ListExprPtr op2, bool is_slice = false);
|
||||
|
||||
bool CanAdd() const override;
|
||||
bool CanDel() const override;
|
||||
|
|
@ -520,19 +530,19 @@ public:
|
|||
void Add(Frame* f) override;
|
||||
void Delete(Frame* f) override;
|
||||
|
||||
void Assign(Frame* f, IntrusivePtr<Val> v) override;
|
||||
IntrusivePtr<Expr> MakeLvalue() override;
|
||||
void Assign(Frame* f, ValPtr v) override;
|
||||
ExprPtr MakeLvalue() override;
|
||||
|
||||
// Need to override Eval since it can take a vector arg but does
|
||||
// not necessarily return a vector.
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
TraversalCode Traverse(TraversalCallback* cb) const override;
|
||||
|
||||
bool IsSlice() const { return is_slice; }
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v1, Val* v2) const override;
|
||||
ValPtr Fold(Val* v1, Val* v2) const override;
|
||||
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
|
|
@ -541,7 +551,7 @@ protected:
|
|||
|
||||
class FieldExpr final : public UnaryExpr {
|
||||
public:
|
||||
FieldExpr(IntrusivePtr<Expr> op, const char* field_name);
|
||||
FieldExpr(ExprPtr op, const char* field_name);
|
||||
~FieldExpr() override;
|
||||
|
||||
int Field() const { return field; }
|
||||
|
|
@ -549,13 +559,13 @@ public:
|
|||
|
||||
bool CanDel() const override;
|
||||
|
||||
void Assign(Frame* f, IntrusivePtr<Val> v) override;
|
||||
void Assign(Frame* f, ValPtr v) override;
|
||||
void Delete(Frame* f) override;
|
||||
|
||||
IntrusivePtr<Expr> MakeLvalue() override;
|
||||
ExprPtr MakeLvalue() override;
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
|
|
@ -568,13 +578,13 @@ protected:
|
|||
// "rec?$$attrname" is true if the attribute attrname is not nil.
|
||||
class HasFieldExpr final : public UnaryExpr {
|
||||
public:
|
||||
HasFieldExpr(IntrusivePtr<Expr> op, const char* field_name);
|
||||
HasFieldExpr(ExprPtr op, const char* field_name);
|
||||
~HasFieldExpr() override;
|
||||
|
||||
const char* FieldName() const { return field_name; }
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
|
|
@ -584,76 +594,76 @@ protected:
|
|||
|
||||
class RecordConstructorExpr final : public UnaryExpr {
|
||||
public:
|
||||
explicit RecordConstructorExpr(IntrusivePtr<ListExpr> constructor_list);
|
||||
explicit RecordConstructorExpr(ListExprPtr constructor_list);
|
||||
~RecordConstructorExpr() override;
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
};
|
||||
|
||||
class TableConstructorExpr final : public UnaryExpr {
|
||||
public:
|
||||
TableConstructorExpr(IntrusivePtr<ListExpr> constructor_list,
|
||||
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs,
|
||||
IntrusivePtr<zeek::Type> arg_type = nullptr);
|
||||
TableConstructorExpr(ListExprPtr constructor_list,
|
||||
std::unique_ptr<std::vector<AttrPtr>> attrs,
|
||||
zeek::TypePtr arg_type = nullptr);
|
||||
|
||||
[[deprecated("Remove in v4.1. Use GetAttrs().")]]
|
||||
Attributes* Attrs() { return attrs.get(); }
|
||||
|
||||
const IntrusivePtr<Attributes>& GetAttrs() const
|
||||
const AttributesPtr& GetAttrs() const
|
||||
{ return attrs; }
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
|
||||
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
|
||||
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
IntrusivePtr<Attributes> attrs;
|
||||
AttributesPtr attrs;
|
||||
};
|
||||
|
||||
class SetConstructorExpr final : public UnaryExpr {
|
||||
public:
|
||||
SetConstructorExpr(IntrusivePtr<ListExpr> constructor_list,
|
||||
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs,
|
||||
IntrusivePtr<zeek::Type> arg_type = nullptr);
|
||||
SetConstructorExpr(ListExprPtr constructor_list,
|
||||
std::unique_ptr<std::vector<AttrPtr>> attrs,
|
||||
zeek::TypePtr arg_type = nullptr);
|
||||
|
||||
[[deprecated("Remove in v4.1. Use GetAttrs().")]]
|
||||
Attributes* Attrs() { return attrs.get(); }
|
||||
|
||||
const IntrusivePtr<Attributes>& GetAttrs() const
|
||||
const AttributesPtr& GetAttrs() const
|
||||
{ return attrs; }
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
|
||||
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
|
||||
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
IntrusivePtr<Attributes> attrs;
|
||||
AttributesPtr attrs;
|
||||
};
|
||||
|
||||
class VectorConstructorExpr final : public UnaryExpr {
|
||||
public:
|
||||
explicit VectorConstructorExpr(IntrusivePtr<ListExpr> constructor_list,
|
||||
IntrusivePtr<zeek::Type> arg_type = nullptr);
|
||||
explicit VectorConstructorExpr(ListExprPtr constructor_list,
|
||||
zeek::TypePtr arg_type = nullptr);
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
|
||||
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
|
||||
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
};
|
||||
|
||||
class FieldAssignExpr final : public UnaryExpr {
|
||||
public:
|
||||
FieldAssignExpr(const char* field_name, IntrusivePtr<Expr> value);
|
||||
FieldAssignExpr(const char* field_name, ExprPtr value);
|
||||
|
||||
const char* FieldName() const { return field_name.c_str(); }
|
||||
|
||||
|
|
@ -668,21 +678,21 @@ protected:
|
|||
|
||||
class ArithCoerceExpr final : public UnaryExpr {
|
||||
public:
|
||||
ArithCoerceExpr(IntrusivePtr<Expr> op, zeek::TypeTag t);
|
||||
ArithCoerceExpr(ExprPtr op, zeek::TypeTag t);
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> FoldSingleVal(Val* v, InternalTypeTag t) const;
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr FoldSingleVal(Val* v, InternalTypeTag t) const;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
};
|
||||
|
||||
class RecordCoerceExpr final : public UnaryExpr {
|
||||
public:
|
||||
RecordCoerceExpr(IntrusivePtr<Expr> op, IntrusivePtr<RecordType> r);
|
||||
RecordCoerceExpr(ExprPtr op, RecordTypePtr r);
|
||||
~RecordCoerceExpr() override;
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
|
||||
// For each super-record slot, gives subrecord slot with which to
|
||||
// fill it.
|
||||
|
|
@ -692,20 +702,20 @@ protected:
|
|||
|
||||
class TableCoerceExpr final : public UnaryExpr {
|
||||
public:
|
||||
TableCoerceExpr(IntrusivePtr<Expr> op, IntrusivePtr<TableType> r);
|
||||
TableCoerceExpr(ExprPtr op, TableTypePtr r);
|
||||
~TableCoerceExpr() override;
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
};
|
||||
|
||||
class VectorCoerceExpr final : public UnaryExpr {
|
||||
public:
|
||||
VectorCoerceExpr(IntrusivePtr<Expr> op, IntrusivePtr<VectorType> v);
|
||||
VectorCoerceExpr(ExprPtr op, VectorTypePtr v);
|
||||
~VectorCoerceExpr() override;
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
};
|
||||
|
||||
class ScheduleTimer final : public Timer {
|
||||
|
|
@ -722,11 +732,11 @@ protected:
|
|||
|
||||
class ScheduleExpr final : public Expr {
|
||||
public:
|
||||
ScheduleExpr(IntrusivePtr<Expr> when, IntrusivePtr<EventExpr> event);
|
||||
ScheduleExpr(ExprPtr when, EventExprPtr event);
|
||||
|
||||
bool IsPure() const override;
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
Expr* When() const { return when.get(); }
|
||||
EventExpr* Event() const { return event.get(); }
|
||||
|
|
@ -736,22 +746,22 @@ public:
|
|||
protected:
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
IntrusivePtr<Expr> when;
|
||||
IntrusivePtr<EventExpr> event;
|
||||
ExprPtr when;
|
||||
EventExprPtr event;
|
||||
};
|
||||
|
||||
class InExpr final : public BinaryExpr {
|
||||
public:
|
||||
InExpr(IntrusivePtr<Expr> op1, IntrusivePtr<Expr> op2);
|
||||
InExpr(ExprPtr op1, ExprPtr op2);
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v1, Val* v2) const override;
|
||||
ValPtr Fold(Val* v1, Val* v2) const override;
|
||||
|
||||
};
|
||||
|
||||
class CallExpr final : public Expr {
|
||||
public:
|
||||
CallExpr(IntrusivePtr<Expr> func, IntrusivePtr<ListExpr> args,
|
||||
CallExpr(ExprPtr func, ListExprPtr args,
|
||||
bool in_hook = false);
|
||||
|
||||
Expr* Func() const { return func.get(); }
|
||||
|
|
@ -759,15 +769,15 @@ public:
|
|||
|
||||
bool IsPure() const override;
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
TraversalCode Traverse(TraversalCallback* cb) const override;
|
||||
|
||||
protected:
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
IntrusivePtr<Expr> func;
|
||||
IntrusivePtr<ListExpr> args;
|
||||
ExprPtr func;
|
||||
ListExprPtr args;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -781,7 +791,7 @@ public:
|
|||
LambdaExpr(std::unique_ptr<function_ingredients> ingredients,
|
||||
id_list outer_ids);
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
TraversalCode Traverse(TraversalCallback* cb) const override;
|
||||
|
||||
Scope* GetScope() const;
|
||||
|
|
@ -798,13 +808,13 @@ private:
|
|||
|
||||
class EventExpr final : public Expr {
|
||||
public:
|
||||
EventExpr(const char* name, IntrusivePtr<ListExpr> args);
|
||||
EventExpr(const char* name, ListExprPtr args);
|
||||
|
||||
const char* Name() const { return name.c_str(); }
|
||||
ListExpr* Args() const { return args.get(); }
|
||||
EventHandlerPtr Handler() const { return handler; }
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
TraversalCode Traverse(TraversalCallback* cb) const override;
|
||||
|
||||
|
|
@ -813,16 +823,16 @@ protected:
|
|||
|
||||
std::string name;
|
||||
EventHandlerPtr handler;
|
||||
IntrusivePtr<ListExpr> args;
|
||||
ListExprPtr args;
|
||||
};
|
||||
|
||||
class ListExpr : public Expr {
|
||||
public:
|
||||
ListExpr();
|
||||
explicit ListExpr(IntrusivePtr<Expr> e);
|
||||
explicit ListExpr(ExprPtr e);
|
||||
~ListExpr() override;
|
||||
|
||||
void Append(IntrusivePtr<Expr> e);
|
||||
void Append(ExprPtr e);
|
||||
|
||||
const expr_list& Exprs() const { return exprs; }
|
||||
expr_list& Exprs() { return exprs; }
|
||||
|
|
@ -830,17 +840,17 @@ public:
|
|||
// True if the entire list represents pure values.
|
||||
bool IsPure() const override;
|
||||
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
|
||||
IntrusivePtr<zeek::Type> InitType() const override;
|
||||
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
|
||||
IntrusivePtr<Expr> MakeLvalue() override;
|
||||
void Assign(Frame* f, IntrusivePtr<Val> v) override;
|
||||
zeek::TypePtr InitType() const override;
|
||||
ValPtr InitVal(const zeek::Type* t, ValPtr aggr) const override;
|
||||
ExprPtr MakeLvalue() override;
|
||||
void Assign(Frame* f, ValPtr v) override;
|
||||
|
||||
TraversalCode Traverse(TraversalCallback* cb) const override;
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> AddSetInit(const zeek::Type* t, IntrusivePtr<Val> aggr) const;
|
||||
ValPtr AddSetInit(const zeek::Type* t, ValPtr aggr) const;
|
||||
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
|
|
@ -850,28 +860,28 @@ protected:
|
|||
|
||||
class RecordAssignExpr final : public ListExpr {
|
||||
public:
|
||||
RecordAssignExpr(const IntrusivePtr<Expr>& record, const IntrusivePtr<Expr>& init_list, bool is_init);
|
||||
RecordAssignExpr(const ExprPtr& record, const ExprPtr& init_list, bool is_init);
|
||||
};
|
||||
|
||||
class CastExpr final : public UnaryExpr {
|
||||
public:
|
||||
CastExpr(IntrusivePtr<Expr> op, IntrusivePtr<zeek::Type> t);
|
||||
CastExpr(ExprPtr op, zeek::TypePtr t);
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Eval(Frame* f) const override;
|
||||
ValPtr Eval(Frame* f) const override;
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
};
|
||||
|
||||
class IsExpr final : public UnaryExpr {
|
||||
public:
|
||||
IsExpr(IntrusivePtr<Expr> op, IntrusivePtr<zeek::Type> t);
|
||||
IsExpr(ExprPtr op, zeek::TypePtr t);
|
||||
|
||||
protected:
|
||||
IntrusivePtr<Val> Fold(Val* v) const override;
|
||||
ValPtr Fold(Val* v) const override;
|
||||
void ExprDescribe(ODesc* d) const override;
|
||||
|
||||
private:
|
||||
IntrusivePtr<zeek::Type> t;
|
||||
zeek::TypePtr t;
|
||||
};
|
||||
|
||||
inline Val* Expr::ExprVal() const
|
||||
|
|
@ -882,8 +892,9 @@ inline Val* Expr::ExprVal() const
|
|||
}
|
||||
|
||||
// Decides whether to return an AssignExpr or a RecordAssignExpr.
|
||||
IntrusivePtr<Expr> get_assign_expr(IntrusivePtr<Expr> op1,
|
||||
IntrusivePtr<Expr> op2, bool is_init);
|
||||
ExprPtr get_assign_expr(
|
||||
ExprPtr op1,
|
||||
ExprPtr op2, bool is_init);
|
||||
|
||||
// Type-check the given expression(s) against the given type(s). Complain
|
||||
// if the expression cannot match the given type, returning 0. If it can
|
||||
|
|
@ -900,7 +911,7 @@ IntrusivePtr<Expr> get_assign_expr(IntrusivePtr<Expr> op1,
|
|||
* Returns nullptr if the expression cannot match or a promoted
|
||||
* expression.
|
||||
*/
|
||||
extern IntrusivePtr<Expr> check_and_promote_expr(Expr* e, Type* t);
|
||||
extern ExprPtr check_and_promote_expr(Expr* e, Type* t);
|
||||
|
||||
extern bool check_and_promote_exprs(ListExpr* elements, TypeList* types);
|
||||
extern bool check_and_promote_args(ListExpr* args, RecordType* types);
|
||||
|
|
@ -908,7 +919,7 @@ extern bool check_and_promote_exprs_to_type(ListExpr* elements, Type* type);
|
|||
|
||||
// Returns a ListExpr simplified down to a list a values, or nil
|
||||
// if they couldn't all be reduced.
|
||||
std::optional<std::vector<IntrusivePtr<Val>>> eval_list(Frame* f, const ListExpr* l);
|
||||
std::optional<std::vector<ValPtr>> eval_list(Frame* f, const ListExpr* l);
|
||||
|
||||
// Returns true if e1 is "greater" than e2 - here "greater" is just
|
||||
// a heuristic, used with commutative operators to put them into
|
||||
|
|
@ -917,9 +928,10 @@ extern bool expr_greater(const Expr* e1, const Expr* e2);
|
|||
|
||||
// True if the given Expr* has a vector type
|
||||
inline bool is_vector(Expr* e) { return e->GetType()->Tag() == TYPE_VECTOR; }
|
||||
inline bool is_vector(const IntrusivePtr<Expr>& e) { return is_vector(e.get()); }
|
||||
inline bool is_vector(const ExprPtr& e) { return is_vector(e.get()); }
|
||||
|
||||
}
|
||||
} // namespace detail
|
||||
} // namespace zeek
|
||||
|
||||
using Expr [[deprecated("Remove in v4.1. Use zeek::detail::Expr instead.")]] = zeek::detail::Expr;
|
||||
using NameExpr [[deprecated("Remove in v4.1. Use zeek::detail::NameExpr instead.")]] = zeek::detail::NameExpr;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue