Merge pull request #252 from MrAnno/filterx-freeze-more-objects

Filterx freeze more objects

lib/filterx/expr-getattr.c

@@ -102,7 +102,7 @@ _free(FilterXExpr *s)
 
 /* NOTE: takes the object reference */
 FilterXExpr *
-filterx_getattr_new(FilterXExpr *operand, const gchar *attr_name)
+filterx_getattr_new(FilterXExpr *operand, FilterXString *attr_name)
 {
   FilterXGetAttr *self = g_new0(FilterXGetAttr, 1);
 
@@ -112,6 +112,8 @@ filterx_getattr_new(FilterXExpr *operand, const gchar *attr_name)
   self->super.is_set = _isset;
   self->super.free_fn = _free;
   self->operand = operand;
-  self->attr = filterx_string_new(attr_name, -1);
+
+  self->attr = (FilterXObject *) attr_name;
+
   return &self->super;
 }

lib/filterx/expr-getattr.h

@@ -24,8 +24,9 @@
 #define FILTERX_GETATTR_H_INCLUDED
 
 #include "filterx/filterx-expr.h"
+#include "filterx/object-string.h"
 
-FilterXExpr *filterx_getattr_new(FilterXExpr *lhs, const gchar *attr_name);
+FilterXExpr *filterx_getattr_new(FilterXExpr *lhs, FilterXString *attr_name);
 
 
 #endif

lib/filterx/expr-setattr.c

@@ -85,15 +85,17 @@ _free(FilterXExpr *s)
 
 /* Takes reference of object and new_value */
 FilterXExpr *
-filterx_setattr_new(FilterXExpr *object, const gchar *attr_name, FilterXExpr *new_value)
+filterx_setattr_new(FilterXExpr *object, FilterXString *attr_name, FilterXExpr *new_value)
 {
   FilterXSetAttr *self = g_new0(FilterXSetAttr, 1);
 
   filterx_expr_init_instance(&self->super);
   self->super.eval = _eval;
   self->super.free_fn = _free;
   self->object = object;
-  self->attr = filterx_string_new(attr_name, -1);
+
+  self->attr = (FilterXObject *) attr_name;
+
   self->new_value = new_value;
   self->super.ignore_falsy_result = TRUE;
   return &self->super;

lib/filterx/expr-setattr.h

@@ -24,8 +24,9 @@
 #define FILTERX_SETATTR_H_INCLUDED
 
 #include "filterx/filterx-expr.h"
+#include "filterx/object-string.h"
 
-FilterXExpr *filterx_setattr_new(FilterXExpr *object, const gchar *attr_name, FilterXExpr *new_value);
+FilterXExpr *filterx_setattr_new(FilterXExpr *object, FilterXString *attr_name, FilterXExpr *new_value);
 
 
 #endif

lib/filterx/expr-variable.c

@@ -27,6 +27,7 @@
 #include "filterx/filterx-eval.h"
 #include "logmsg/logmsg.h"
 
+
 typedef struct _FilterXVariableExpr
 {
   FilterXExpr super;
@@ -164,7 +165,7 @@ _free(FilterXExpr *s)
 }
 
 static FilterXExpr *
-filterx_variable_expr_new(const gchar *name, FilterXVariableType type)
+filterx_variable_expr_new(FilterXString *name, FilterXVariableType type)
 {
   FilterXVariableExpr *self = g_new0(FilterXVariableExpr, 1);
 
@@ -175,27 +176,21 @@ filterx_variable_expr_new(const gchar *name, FilterXVariableType type)
   self->super.assign = _assign;
   self->super.is_set = _isset;
   self->super.unset = _unset;
-  self->handle = filterx_scope_map_variable_to_handle(name, type);
-  if (type == FX_VAR_MESSAGE)
-    {
-      gchar *dollar_name = g_strdup_printf("$%s", name);
-      self->variable_name = filterx_string_new(dollar_name, -1);
-      g_free(dollar_name);
-    }
-  else
-    self->variable_name = filterx_string_new(name, -1);
+
+  self->variable_name = (FilterXObject *) name;
+  self->handle = filterx_scope_map_variable_to_handle(filterx_string_get_value(self->variable_name, NULL), type);
 
   return &self->super;
 }
 
 FilterXExpr *
-filterx_msg_variable_expr_new(const gchar *name)
+filterx_msg_variable_expr_new(FilterXString *name)
 {
   return filterx_variable_expr_new(name, FX_VAR_MESSAGE);
 }
 
 FilterXExpr *
-filterx_floating_variable_expr_new(const gchar *name)
+filterx_floating_variable_expr_new(FilterXString *name)
 {
   return filterx_variable_expr_new(name, FX_VAR_FLOATING);
 }

lib/filterx/expr-variable.h

@@ -24,9 +24,22 @@
 #define FILTERX_EXPR_VARIABLE_H_INCLUDED
 
 #include "filterx/filterx-expr.h"
+#include "filterx/filterx-config.h"
+#include "filterx/object-string.h"
+#include "cfg.h"
 
-FilterXExpr *filterx_msg_variable_expr_new(const gchar *name);
-FilterXExpr *filterx_floating_variable_expr_new(const gchar *name);
+FilterXExpr *filterx_msg_variable_expr_new(FilterXString *name);
+FilterXExpr *filterx_floating_variable_expr_new(FilterXString *name);
 void filterx_variable_expr_declare(FilterXExpr *s);
 
+static inline FilterXString *
+filterx_frozen_dollar_msg_varname(GlobalConfig *cfg, const gchar *name)
+{
+  gchar *dollar_name = g_strdup_printf("$%s", name);
+  FilterXString *dollar_name_obj = filterx_config_frozen_string(cfg, dollar_name);
+  g_free(dollar_name);
+
+  return dollar_name_obj;
+}
+
 #endif

lib/filterx/filterx-config.c

@@ -64,3 +64,12 @@ filterx_config_freeze_object(GlobalConfig *cfg, FilterXObject *object)
     g_ptr_array_add(fxc->frozen_objects, object);
   return object;
 }
+
+FilterXString *
+filterx_config_frozen_string(GlobalConfig *cfg, const gchar *str)
+{
+  FilterXString *frozen_str = filterx_string_typed_new(str);
+  filterx_config_freeze_object(cfg, (FilterXObject *) frozen_str);
+
+  return frozen_str;
+}

lib/filterx/filterx-config.h

@@ -25,6 +25,7 @@
 
 #include "module-config.h"
 #include "filterx/filterx-object.h"
+#include "filterx/object-string.h"
 
 typedef struct _FilterXConfig
 {
@@ -34,5 +35,6 @@ typedef struct _FilterXConfig
 
 FilterXConfig *filterx_config_get(GlobalConfig *cfg);
 FilterXObject *filterx_config_freeze_object(GlobalConfig *cfg, FilterXObject *object);
+FilterXString *filterx_config_frozen_string(GlobalConfig *cfg, const gchar *str);
 
 #endif

lib/filterx/filterx-grammar.ym

@@ -66,12 +66,10 @@ construct_template_expr(LogTemplate *template)
   FilterXExpr *result;
 
   if (log_template_is_literal_string(template))
-    result = filterx_literal_new(
-		filterx_config_freeze_object(configuration,
-			filterx_string_new(log_template_get_literal_value(template, NULL), -1)));
+    result = filterx_literal_new(filterx_config_freeze_object(configuration, filterx_string_new(log_template_get_literal_value(template, NULL), -1)));
   else if (log_template_is_trivial(template))
-    result = filterx_msg_variable_expr_new(
-                log_msg_get_value_name(log_template_get_trivial_value_handle(template), NULL));
+    result = filterx_msg_variable_expr_new(filterx_frozen_dollar_msg_varname(configuration,
+				log_msg_get_value_name(log_template_get_trivial_value_handle(template), NULL)));
   else
     result = filterx_template_new(log_template_ref(template));
   log_template_unref(template);
@@ -193,7 +191,7 @@ plus_assignment
 	| expr '[' expr ']' KW_PLUS_ASSIGN expr	{ $$ = filterx_set_subscript_new(filterx_expr_ref($1), filterx_expr_ref($3), filterx_operator_plus_new(filterx_get_subscript_new($1, $3), $6)); }
 	| expr '.' identifier KW_PLUS_ASSIGN expr
 						{
-							$$ = filterx_setattr_new(filterx_expr_ref($1), $3, filterx_operator_plus_new(filterx_getattr_new($1, $3), $5));
+							$$ = filterx_setattr_new(filterx_expr_ref($1), filterx_config_frozen_string(configuration, $3), filterx_operator_plus_new(filterx_getattr_new($1, filterx_config_frozen_string(configuration, $3)), $5));
 							free($3);
 						}
 	;
@@ -202,7 +200,7 @@ plus_assignment
 assignment
 	/* TODO extract lvalues */
 	: variable KW_ASSIGN expr			{ $$ = filterx_assign_new($1, $3); }
-	| expr '.' identifier KW_ASSIGN expr	{ $$ = filterx_setattr_new($1, $3, $5); free($3); }
+	| expr '.' identifier KW_ASSIGN expr	{ $$ = filterx_setattr_new($1, filterx_config_frozen_string(configuration, $3), $5); free($3); }
 	| expr '[' expr ']' KW_ASSIGN expr	{ $$ = filterx_set_subscript_new($1, $3, $6); }
 	| expr '[' ']' KW_ASSIGN expr  		{ $$ = filterx_set_subscript_new($1, NULL, $5); }
 	| generator_assignment
@@ -215,10 +213,10 @@ generator_assignment
 	/* TODO extract lvalues */
 	: expr '.' identifier KW_ASSIGN expr_generator
 						{
-						  filterx_generator_set_fillable($5, filterx_getattr_new(filterx_expr_ref($1), $3));
+						  filterx_generator_set_fillable($5, filterx_getattr_new(filterx_expr_ref($1), filterx_config_frozen_string(configuration, $3)));
 
 						  $$ = filterx_compound_expr_new_va(TRUE,
-						    filterx_setattr_new($1, $3, filterx_generator_create_container_new($5, $1)),
+						    filterx_setattr_new($1, filterx_config_frozen_string(configuration, $3), filterx_generator_create_container_new($5, $1)),
 						    $5,
 						    NULL
                                                   );
@@ -265,7 +263,7 @@ generator_assignment
 generator_plus_assignment
 	: variable KW_PLUS_ASSIGN expr_generator			{ $$ = $3; filterx_generator_set_fillable($3, $1); }
 	| expr '[' expr ']' KW_PLUS_ASSIGN expr_generator	{ $$ = $6; filterx_generator_set_fillable($6, filterx_get_subscript_new($1, $3)); }
-	| expr '.' identifier KW_PLUS_ASSIGN expr_generator	{ $$ = $5; filterx_generator_set_fillable($5, filterx_getattr_new($1, $3)); free($3);}
+	| expr '.' identifier KW_PLUS_ASSIGN expr_generator	{ $$ = $5; filterx_generator_set_fillable($5, filterx_getattr_new($1, filterx_config_frozen_string(configuration, $3))); free($3);}
 
 generator_casted_assignment
 	/* TODO extract lvalues */
@@ -290,10 +288,10 @@ generator_casted_assignment
 						  FilterXExpr *func = filterx_function_lookup(configuration, $5, NULL, &error);
 						  CHECK_FUNCTION_ERROR(func, @5, $5, error);
 
-						  filterx_generator_set_fillable($7, filterx_getattr_new(filterx_expr_ref($1), $3));
+						  filterx_generator_set_fillable($7, filterx_getattr_new(filterx_expr_ref($1), filterx_config_frozen_string(configuration, $3)));
 
 						  $$ = filterx_compound_expr_new_va(TRUE,
-						    filterx_setattr_new($1, $3, func),
+						    filterx_setattr_new($1, filterx_config_frozen_string(configuration, $3), func),
 						    $7,
 						    NULL
 						  );
@@ -343,7 +341,7 @@ expr
 	| expr KW_OR expr			{ $$ = filterx_binary_or_new($1, $3); }
 	| expr KW_AND expr                      { $$ = filterx_binary_and_new($1, $3); }
 	/* TODO extract lvalues */
-	| expr '.' identifier			{ $$ = filterx_getattr_new($1, $3); free($3); }
+	| expr '.' identifier		{ $$ = filterx_getattr_new($1, filterx_config_frozen_string(configuration, $3)); free($3); }
 	| expr '[' expr ']'			{ $$ = filterx_get_subscript_new($1, $3); }
         | expr KW_TA_LT expr		        { $$ = filterx_comparison_new($1, $3, FCMPX_TYPE_AWARE | FCMPX_LT); }
         | expr KW_TA_LE expr			{ $$ = filterx_comparison_new($1, $3, FCMPX_TYPE_AWARE | FCMPX_LT | FCMPX_EQ); }
@@ -467,13 +465,13 @@ literal_object
 	;
 
 variable
-	: '$' identifier			{ $$ = filterx_msg_variable_expr_new($2); free($2); }
-	| LL_MESSAGE_REF			{ $$ = filterx_msg_variable_expr_new($1); free($1); }
+	: '$' identifier			{ $$ = filterx_msg_variable_expr_new(filterx_frozen_dollar_msg_varname(configuration, $2)); free($2); }
+	| LL_MESSAGE_REF			{ $$ = filterx_msg_variable_expr_new(filterx_frozen_dollar_msg_varname(configuration, $1)); free($1); }
 	| filterx_variable
 	;
 
 filterx_variable
-	: identifier				{ $$ = filterx_floating_variable_expr_new($1); free($1); }
+	: identifier				{ $$ = filterx_floating_variable_expr_new(filterx_config_frozen_string(configuration, $1)); free($1); }
 	;
 
 boolean

lib/filterx/filterx-scope.c

@@ -153,6 +153,9 @@ filterx_scope_is_dirty(FilterXScope *self)
 FilterXVariableHandle
 filterx_scope_map_variable_to_handle(const gchar *name, FilterXVariableType type)
 {
+  if (type == FX_VAR_MESSAGE)
+    name++;
+
   NVHandle nv_handle = log_msg_get_value_handle(name);
 
   if (type == FX_VAR_MESSAGE)

lib/filterx/object-string.c

@@ -29,12 +29,12 @@
 #include "str-format.h"
 #include "str-utils.h"
 
-typedef struct _FilterXString
+struct _FilterXString
 {
   FilterXObject super;
   gsize str_len;
   gchar str[];
-} FilterXString;
+};
 
 /* NOTE: Consider using filterx_object_extract_string() to also support message_value. */
 const gchar *
@@ -142,18 +142,33 @@ _string_add(FilterXObject *s, FilterXObject *object)
   return filterx_string_new(buffer->str, buffer->len);
 }
 
-FilterXObject *
-filterx_string_new(const gchar *str, gssize str_len)
+FilterXString *
+_string_new(const gchar *str, gssize str_len)
 {
   if (str_len < 0)
     str_len = strlen(str);
+
   FilterXString *self = g_malloc(sizeof(FilterXString) + str_len + 1);
   memset(self, 0, sizeof(FilterXString));
   filterx_object_init_instance(&self->super, &FILTERX_TYPE_NAME(string));
+
   self->str_len = str_len;
   memcpy(self->str, str, str_len);
   self->str[str_len] = 0;
-  return &self->super;
+
+  return self;
+}
+
+FilterXObject *
+filterx_string_new(const gchar *str, gssize str_len)
+{
+  return &_string_new(str, str_len)->super;
+}
+
+FilterXString *
+filterx_string_typed_new(const gchar *str)
+{
+  return _string_new(str, -1);
 }
 
 static inline gsize

lib/filterx/object-string.h

@@ -25,6 +25,8 @@
 
 #include "filterx-object.h"
 
+typedef struct _FilterXString FilterXString;
+
 FILTERX_DECLARE_TYPE(string);
 FILTERX_DECLARE_TYPE(bytes);
 FILTERX_DECLARE_TYPE(protobuf);
@@ -40,4 +42,6 @@ FilterXObject *filterx_string_new(const gchar *str, gssize str_len);
 FilterXObject *filterx_bytes_new(const gchar *str, gssize str_len);
 FilterXObject *filterx_protobuf_new(const gchar *str, gssize str_len);
 
+FilterXString *filterx_string_typed_new(const gchar *str);
+
 #endif

lib/filterx/tests/test_expr_compound.c

@@ -38,7 +38,7 @@
 FilterXExpr *
 _assert_assign_var(const char *var_name, FilterXExpr *value)
 {
-  FilterXExpr *control_variable = filterx_msg_variable_expr_new(var_name);
+  FilterXExpr *control_variable = filterx_msg_variable_expr_new(filterx_string_typed_new(var_name));
   cr_assert(control_variable != NULL);
 
   return filterx_assign_new(control_variable, value);
@@ -76,7 +76,7 @@ _assert_set_test_variable(const char *var_name, FilterXExpr *expr)
 FilterXObject *
 _assert_get_test_variable(const char *var_name)
 {
-  FilterXExpr *control_variable = filterx_msg_variable_expr_new(var_name);
+  FilterXExpr *control_variable = filterx_msg_variable_expr_new(filterx_string_typed_new(var_name));
   cr_assert(control_variable != NULL);
   FilterXObject *result = filterx_expr_eval(control_variable);
   filterx_expr_unref(control_variable);

lib/filterx/tests/test_expr_condition.c

@@ -62,7 +62,7 @@ _assert_cmp_string_to_filterx_object(const char *str, FilterXObject *obj)
 FilterXExpr *
 _assert_assign_var(const char *var_name, FilterXExpr *value)
 {
-  FilterXExpr *control_variable = filterx_msg_variable_expr_new(var_name);
+  FilterXExpr *control_variable = filterx_msg_variable_expr_new(filterx_string_typed_new(var_name));
   cr_assert(control_variable != NULL);
 
   return filterx_assign_new(control_variable, value);
@@ -85,7 +85,7 @@ _assert_set_test_variable(const char *var_name, FilterXExpr *expr)
 FilterXObject *
 _assert_get_test_variable(const char *var_name)
 {
-  FilterXExpr *control_variable = filterx_msg_variable_expr_new(var_name);
+  FilterXExpr *control_variable = filterx_msg_variable_expr_new(filterx_string_typed_new(var_name));
   cr_assert(control_variable != NULL);
   FilterXObject *result = filterx_expr_eval(control_variable);
   filterx_expr_unref(control_variable);