mirror of
https://github.com/zeek/zeek.git
synced 2025-10-16 13:38:19 +00:00
a3001f1b2b
This allows anonymous functions in Zeek to capture their closures. they do so by creating a copy of their enclosing frame and joining that with their own frame. There is no way to specify what specific items to capture from the closure like C++, nor is there a nonlocal keyword like Python. Attemptying to declare a local variable that has already been caught by the closure will error nicely. At the worst this is an inconvenience for people who are using lambdas which use the same variable names as their closures. As a result of functions copying their enclosing frames there is no way for a function with a closure to reach back up and modify the state of the frame that it was created in. This lets functions that generate functions work as expected. The function can reach back and modify its copy of the frame that it is captured in though. Implementation wise this is done by creating two new subclasses in Zeek. The first is a LambdaExpression which can be thought of as a function generator. It gathers all of the ingredients for a function at parse time, and then when evaluated creats a new version of that function with the frame it is being evaluated in as a closure. The second subclass is a ClosureFrame. This acts for most intents and purposes like a regular Frame, but it routes lookups of values to its closure as needed.
48 lines
1.8 KiB
C++
48 lines
1.8 KiB
C++
// See the file "COPYING" in the main distribution directory for copyright.
|
|
|
|
#ifndef var_h
|
|
#define var_h
|
|
|
|
#include <memory> // std::unique_ptr
|
|
|
|
#include "ID.h"
|
|
#include "Expr.h"
|
|
#include "Type.h"
|
|
#include "Func.h" // function_ingredients
|
|
|
|
class Func;
|
|
class EventHandlerPtr;
|
|
|
|
typedef enum { VAR_REGULAR, VAR_CONST, VAR_REDEF, VAR_OPTION, } decl_type;
|
|
|
|
extern void add_global(ID* id, BroType* t, init_class c, Expr* init,
|
|
attr_list* attr, decl_type dt);
|
|
extern Stmt* add_local(ID* id, BroType* t, init_class c, Expr* init,
|
|
attr_list* attr, decl_type dt);
|
|
extern Expr* add_and_assign_local(ID* id, Expr* init, Val* val = 0);
|
|
|
|
extern void add_type(ID* id, BroType* t, attr_list* attr);
|
|
|
|
extern void begin_func(ID* id, const char* module_name, function_flavor flavor,
|
|
int is_redef, FuncType* t, attr_list* attrs = nullptr);
|
|
extern void end_func(Stmt* body);
|
|
extern std::unique_ptr<function_ingredients>
|
|
gather_function_ingredients(Stmt* body);
|
|
extern std::shared_ptr<id_list> gather_outer_ids(Scope* scope, Stmt* body);
|
|
|
|
extern Val* internal_val(const char* name);
|
|
extern Val* internal_const_val(const char* name); // internal error if not const
|
|
extern Val* opt_internal_val(const char* name); // returns nil if not defined
|
|
extern double opt_internal_double(const char* name);
|
|
extern bro_int_t opt_internal_int(const char* name);
|
|
extern bro_uint_t opt_internal_unsigned(const char* name);
|
|
extern StringVal* opt_internal_string(const char* name);
|
|
extern TableVal* opt_internal_table(const char* name); // nil if not defined
|
|
extern ListVal* internal_list_val(const char* name);
|
|
extern BroType* internal_type(const char* name);
|
|
extern Func* internal_func(const char* name);
|
|
extern EventHandlerPtr internal_handler(const char* name);
|
|
|
|
extern int signal_val; // 0 if no signal pending
|
|
|
|
#endif
|