OpenVAS Scanner  7.0.0~git
nasl_var.h File Reference
#include "nasl_tree.h"
Include dependency graph for nasl_var.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  st_nasl_string
 
struct  st_nasl_array
 
struct  st_a_nasl_var
 
struct  st_n_nasl_var
 
struct  nasl_iterator
 

Macros

#define VAR_NAME_HASH   17
 

Typedefs

typedef struct st_nasl_string nasl_string_t
 
typedef struct st_nasl_array nasl_array
 
typedef struct st_a_nasl_var anon_nasl_var
 
typedef struct st_n_nasl_var named_nasl_var
 

Enumerations

enum  {
  VAR2_UNDEF = 0, VAR2_INT, VAR2_STRING, VAR2_DATA,
  VAR2_ARRAY
}
 

Functions

tree_cellnasl_affect (tree_cell *, tree_cell *)
 
void clear_unnamed_var (anon_nasl_var *)
 
const char * var2str (anon_nasl_var *)
 
anon_nasl_varnasl_get_var_by_num (void *, nasl_array *, int, int)
 
nasl_iterator nasl_array_iterator (void *, tree_cell *)
 
tree_cellnasl_iterate_array (nasl_iterator *)
 
int add_var_to_list (nasl_array *, int, const anon_nasl_var *)
 
int add_var_to_array (nasl_array *, char *, const anon_nasl_var *)
 
int array_max_index (nasl_array *)
 
void free_array (nasl_array *)
 
tree_cellcopy_ref_array (const tree_cell *)
 
int hash_str2 (const char *, int)
 
tree_cellvar2cell (anon_nasl_var *)
 
tree_cellmake_array_from_elems (tree_cell *)
 
char * array2str (const nasl_array *)
 

Macro Definition Documentation

◆ VAR_NAME_HASH

#define VAR_NAME_HASH   17

Definition at line 33 of file nasl_var.h.

Typedef Documentation

◆ anon_nasl_var

typedef struct st_a_nasl_var anon_nasl_var

◆ named_nasl_var

typedef struct st_n_nasl_var named_nasl_var

◆ nasl_array

typedef struct st_nasl_array nasl_array

◆ nasl_string_t

typedef struct st_nasl_string nasl_string_t

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
VAR2_UNDEF 
VAR2_INT 
VAR2_STRING 
VAR2_DATA 
VAR2_ARRAY 

Definition at line 24 of file nasl_var.h.

25 {
26  VAR2_UNDEF = 0,
27  VAR2_INT,
29  VAR2_DATA,
31 };

Function Documentation

◆ add_var_to_array()

int add_var_to_array ( nasl_array ,
char *  ,
const anon_nasl_var  
)

Definition at line 1286 of file nasl_var.c.

1287  {
1288  named_nasl_var *v2;
1289  int h = hash_str (name);
1290 
1291  if (a->hash_elt == NULL)
1292  {
1293  a->hash_elt = g_malloc0 (VAR_NAME_HASH * sizeof (named_nasl_var *));
1294  }
1295 
1296  v2 = g_malloc0 (sizeof (named_nasl_var));
1297  v2->var_name = g_strdup (name);
1298  v2->u.var_type = VAR2_UNDEF;
1299  v2->next_var = a->hash_elt[h];
1300  a->hash_elt[h] = v2;
1301 
1302  copy_anon_var (&(v2->u), v);
1303  return 0;
1304  }

References copy_anon_var(), st_nasl_array::hash_elt, hash_str(), name, st_n_nasl_var::next_var, st_n_nasl_var::u, VAR2_UNDEF, st_n_nasl_var::var_name, VAR_NAME_HASH, and st_a_nasl_var::var_type.

Referenced by get_kb_list(), make_array_from_elems(), nasl_localtime(), and nasl_make_array().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ add_var_to_list()

int add_var_to_list ( nasl_array ,
int  ,
const anon_nasl_var  
)

Definition at line 1254 of file nasl_var.c.

1255  {
1256  anon_nasl_var *v2 = NULL;
1257 
1258  if (i < 0)
1259  {
1260  nasl_perror (
1261  NULL, "add_var_to_list: negative index are not (yet) supported\n");
1262  return -1;
1263  }
1264 
1265  if (i >= a->max_idx)
1266  {
1267  a->num_elt = g_realloc (a->num_elt, sizeof (anon_nasl_var *) * (i + 1));
1268  bzero (a->num_elt + a->max_idx,
1269  sizeof (anon_nasl_var *) * (i + 1 - a->max_idx));
1270  a->max_idx = i + 1;
1271  }
1272 
1273  if (a->num_elt)
1274  {
1275  free_anon_var (a->num_elt[i]);
1276  v2 = dup_anon_var (v); /* May return NULL */
1277  a->num_elt[i] = v2;
1278  }
1279  if (v2 == NULL)
1280  return 0;
1281  else
1282  return 1;
1283  }

References dup_anon_var(), free_anon_var(), st_nasl_array::max_idx, nasl_perror(), and st_nasl_array::num_elt.

Referenced by get_hostnames(), make_array_from_elems(), nasl_bf_cbc(), nasl_eregmatch(), nasl_get_sock_info(), nasl_keys(), nasl_make_array(), nasl_make_list(), and nasl_split().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ array2str()

char* array2str ( const nasl_array )

Definition at line 1004 of file nasl_var.c.

1005  {
1006  GString *str;
1007  int i, n1 = 0;
1008  anon_nasl_var *u;
1009  named_nasl_var *v;
1010 
1011  if (a == NULL)
1012  return NULL;
1013 
1014  str = g_string_new ("[ ");
1015  if (a->num_elt != NULL)
1016  for (i = 0; i < a->max_idx; i++)
1017  if ((u = a->num_elt[i]) != NULL && u->var_type != VAR2_UNDEF)
1018  {
1019  if (n1 > 0)
1020  g_string_append (str, ", ");
1021  n1++;
1022  switch (u->var_type)
1023  {
1024  case VAR2_INT:
1025  g_string_append_printf (str, "%d: %ld", i, u->v.v_int);
1026  break;
1027  case VAR2_STRING:
1028  case VAR2_DATA:
1029  if (u->v.v_str.s_siz < 64)
1030  g_string_append_printf (str, "%d: '%s'", i, u->v.v_str.s_val);
1031  else
1032  g_string_append_printf (str, "%d: '%s'...", i,
1033  u->v.v_str.s_val);
1034  break;
1035  default:
1036  g_string_append_printf (str, "%d: ????", i);
1037  break;
1038  }
1039  }
1040 
1041  if (a->hash_elt != NULL)
1042  for (i = 0; i < VAR_NAME_HASH; i++)
1043  for (v = a->hash_elt[i]; v != NULL; v = v->next_var)
1044  if (v->u.var_type != VAR2_UNDEF)
1045  {
1046  u = &v->u;
1047  if (n1 > 0)
1048  g_string_append (str, ", ");
1049  n1++;
1050  switch (u->var_type)
1051  {
1052  case VAR2_INT:
1053  g_string_append_printf (str, "%s: %ld", v->var_name,
1054  u->v.v_int);
1055  break;
1056  case VAR2_STRING:
1057  case VAR2_DATA:
1058  if (u->v.v_str.s_siz < 64)
1059  g_string_append_printf (str, "%s: '%s'", v->var_name,
1060  u->v.v_str.s_val);
1061  else
1062  g_string_append_printf (str, "%s: '%s'...", v->var_name,
1063  u->v.v_str.s_val);
1064  break;
1065  default:
1066  g_string_append_printf (str, "%s: ????", v->var_name);
1067  break;
1068  }
1069  }
1070 
1071  g_string_append (str, " ]");
1072  return g_string_free (str, FALSE);
1073  }

References st_nasl_array::hash_elt, st_nasl_array::max_idx, st_n_nasl_var::next_var, st_nasl_array::num_elt, st_nasl_string::s_siz, st_nasl_string::s_val, st_n_nasl_var::u, st_a_nasl_var::v, st_a_nasl_var::v_int, st_a_nasl_var::v_str, VAR2_DATA, VAR2_INT, VAR2_STRING, VAR2_UNDEF, st_n_nasl_var::var_name, VAR_NAME_HASH, and st_a_nasl_var::var_type.

Referenced by cell2str(), and var2str().

Here is the caller graph for this function:

◆ array_max_index()

int array_max_index ( nasl_array a)

The name is not great: this function does not returns the index of the last element, but the index of the next free slot

Definition at line 1311 of file nasl_var.c.

1312  {
1313  int i;
1314 
1315  for (i = a->max_idx - 1; i >= 0; i--)
1316  if (a->num_elt[i] != NULL && a->num_elt[i]->var_type != VAR2_UNDEF)
1317  {
1318  /* Fixing max_index will realloc() at next store.
1319  * I am not sure it is a good idea
1320  * Wait and see */
1321  a->max_idx = i + 1;
1322  return i + 1;
1323  }
1324  return 0;
1325  }

References st_nasl_array::max_idx, st_nasl_array::num_elt, VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by nasl_max_index(), nasl_rawstring(), nasl_strcat(), and nasl_string().

Here is the caller graph for this function:

◆ clear_unnamed_var()

void clear_unnamed_var ( anon_nasl_var )

◆ copy_ref_array()

tree_cell* copy_ref_array ( const tree_cell )

Definition at line 549 of file nasl_var.c.

550  {
551  tree_cell *c2;
552  nasl_array *a2;
553 
554  if (c1 == NULL || c1 == FAKE_CELL || c1->type != REF_ARRAY)
555  return NULL;
556 
558  c2->x.ref_val = a2 = g_malloc0 (sizeof (nasl_array));
559  copy_array (a2, c1->x.ref_val, 1);
560  return c2;
561  }

References alloc_typed_cell(), copy_array(), DYN_ARRAY, FAKE_CELL, REF_ARRAY, TC::ref_val, TC::type, and TC::x.

Referenced by nasl_return().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_array()

void free_array ( nasl_array a)

Note: the function does not free the nasl_array structure. Do it if necessary

Definition at line 354 of file nasl_var.c.

355  {
356  int i;
357 
358  if (a == NULL)
359  return;
360  if (a->num_elt != NULL)
361  {
362  for (i = 0; i < a->max_idx; i++)
363  free_anon_var (a->num_elt[i]);
364  g_free (a->num_elt);
365  a->num_elt = NULL;
366  }
367  a->max_idx = 0;
368  if (a->hash_elt != NULL)
369  {
370  for (i = 0; i < VAR_NAME_HASH; i++)
371  free_var_chain (a->hash_elt[i]);
372  g_free (a->hash_elt);
373  a->hash_elt = NULL;
374  }
375  }

References free_anon_var(), free_var_chain(), st_nasl_array::hash_elt, st_nasl_array::max_idx, st_nasl_array::num_elt, and VAR_NAME_HASH.

Referenced by clear_anon_var(), copy_array(), free_anon_var(), free_lex_ctxt(), free_tree(), free_var_chain(), and nasl_exec().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ hash_str2()

int hash_str2 ( const char *  s,
int  n 
)
Todo:
Consider using GLibs string hash function.

Definition at line 38 of file nasl_var.c.

39 {
40  unsigned long h = 0;
41  const char *p;
42 
43  if (s == NULL)
44  return 0;
45 
46  for (p = s; *p != '\0'; p++)
47  h = (h << 3) + (unsigned char) *p;
48  return h % n;
49 }

Referenced by hash_str().

Here is the caller graph for this function:

◆ make_array_from_elems()

tree_cell* make_array_from_elems ( tree_cell el)

make_array_from_list is used by the parser only The list of elements is freed after use

Definition at line 1332 of file nasl_var.c.

1333  {
1334  int n;
1335  tree_cell *c, *c2;
1336  nasl_array *a;
1337  anon_nasl_var *v;
1338 
1339  v = g_malloc0 (sizeof (anon_nasl_var));
1340  a = g_malloc0 (sizeof (nasl_array));
1341  /* Either the elements are all "named", or they are "numbered". No mix! */
1342  if (el->x.str_val == NULL) /* numbered */
1343  {
1344  for (n = 0, c = el; c != NULL; c = c->link[1])
1345  n++;
1346  a->max_idx = n;
1347  a->num_elt = g_malloc0 (sizeof (anon_nasl_var *) * n);
1348  a->hash_elt = NULL;
1349  }
1350  else
1351  {
1352  a->num_elt = NULL;
1353  a->hash_elt = g_malloc0 (VAR_NAME_HASH * sizeof (named_nasl_var *));
1354  }
1355 
1356  for (n = 0, c = el; c != NULL; c = c->link[1])
1357  {
1358  c2 = c->link[0];
1359  if (c2 != NULL && c2 != FAKE_CELL)
1360  {
1361  switch (c2->type)
1362  {
1363  case CONST_INT:
1364  v->var_type = VAR2_INT;
1365  v->v.v_int = c2->x.i_val;
1366  break;
1367  case CONST_STR:
1368  case CONST_DATA:
1369  v->var_type = c2->type == CONST_STR ? VAR2_STRING : VAR2_DATA;
1370  if (c2->x.str_val == NULL)
1371  {
1372  v->v.v_str.s_val = NULL;
1373  v->v.v_str.s_siz = 0;
1374  }
1375  else
1376  {
1377  v->v.v_str.s_siz = c2->size;
1378  v->v.v_str.s_val = (unsigned char *) c2->x.str_val;
1379  }
1380  break;
1381  default:
1382  nasl_perror (NULL,
1383  "make_array_from_list: unhandled cell type %s at "
1384  "position %d\n",
1385  nasl_type_name (c2->type), n);
1386  v->var_type = VAR2_UNDEF;
1387  break;
1388  }
1389  }
1390 
1391  if (c->x.str_val == NULL)
1392  add_var_to_list (a, n++, v);
1393  else
1394  add_var_to_array (a, c->x.str_val, v);
1395  }
1396 
1397  g_free (v);
1399  c->x.ref_val = a;
1400  deref_cell (el);
1401  return c;
1402  }

References add_var_to_array(), add_var_to_list(), alloc_typed_cell(), CONST_DATA, CONST_INT, CONST_STR, deref_cell(), DYN_ARRAY, FAKE_CELL, st_nasl_array::hash_elt, TC::i_val, TC::link, st_nasl_array::max_idx, nasl_perror(), nasl_type_name(), st_nasl_array::num_elt, TC::ref_val, st_nasl_string::s_siz, st_nasl_string::s_val, TC::size, TC::str_val, TC::type, st_a_nasl_var::v, st_a_nasl_var::v_int, st_a_nasl_var::v_str, VAR2_DATA, VAR2_INT, VAR2_STRING, VAR2_UNDEF, VAR_NAME_HASH, st_a_nasl_var::var_type, and TC::x.

Referenced by yyparse().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ nasl_affect()

tree_cell* nasl_affect ( tree_cell ,
tree_cell  
)

Definition at line 712 of file nasl_var.c.

713  {
714  anon_nasl_var *v1 = NULL;
715 
716  if (lval == NULL)
717  {
718  nasl_perror (NULL, "nasl_effect: invalid lvalue\n");
719  return NULL;
720  }
721 
722  if (lval->type != REF_VAR)
723  {
724  nasl_perror (NULL, "nasl_affect: cannot affect to non variable %s\n",
725  nasl_type_name (lval->type));
726  return NULL;
727  }
728 
729  v1 = lval->x.ref_val;
730  return affect_to_anon_var (v1, rval);
731  }

References affect_to_anon_var(), nasl_perror(), nasl_type_name(), TC::ref_val, REF_VAR, TC::type, and TC::x.

Referenced by nasl_exec().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ nasl_array_iterator()

nasl_iterator nasl_array_iterator ( void *  ,
tree_cell  
)

Definition at line 1178 of file nasl_var.c.

1179  {
1180  nasl_iterator it;
1181  anon_nasl_var *v;
1182 
1183  it.a = NULL;
1184  it.v = NULL;
1185  it.i1 = 0;
1186  it.iH = 0;
1187 
1188  if (c == NULL || c == FAKE_CELL)
1189  return it;
1190 
1191  if (c->type == REF_VAR)
1192  {
1193  v = c->x.ref_val;
1194  if (v == NULL || v->var_type != VAR2_ARRAY)
1195  return it;
1196  it.a = g_malloc0 (sizeof (nasl_array));
1197  copy_array (it.a, &v->v.v_arr, 1);
1198  }
1199  else if (c->type == REF_ARRAY || c->type == DYN_ARRAY)
1200  {
1201  it.a = g_malloc0 (sizeof (nasl_array));
1202  copy_array (it.a, c->x.ref_val, 1);
1203  }
1204  else
1205  {
1206  nasl_perror (ctxt, "nasl_array_iterator: unhandled type %d (0x%x)\n",
1207  c->type, c->type);
1208  }
1209 
1210  return it;
1211  }

References nasl_iterator::a, copy_array(), DYN_ARRAY, FAKE_CELL, nasl_iterator::i1, nasl_iterator::iH, nasl_perror(), REF_ARRAY, TC::ref_val, REF_VAR, TC::type, st_a_nasl_var::v, nasl_iterator::v, st_a_nasl_var::v_arr, VAR2_ARRAY, st_a_nasl_var::var_type, and TC::x.

Referenced by nasl_exec().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ nasl_get_var_by_num()

anon_nasl_var* nasl_get_var_by_num ( void *  ,
nasl_array ,
int  ,
int   
)

Definition at line 58 of file nasl_var.c.

59 {
60  anon_nasl_var *v = NULL;
61 
62  if (num < 0)
63  {
64  /* TBD: implement a min_index field, just like $[ in Perl */
65  nasl_perror (ctxt, "Negative integer index %d are not supported yet!\n",
66  num);
67  return NULL;
68  }
69 
70  if (num < a->max_idx)
71  v = a->num_elt[num];
72  if (v != NULL || !create)
73  return v;
74 
75  if (num >= a->max_idx)
76  {
77  a->num_elt = g_realloc (a->num_elt, sizeof (anon_nasl_var *) * (num + 1));
78  bzero (a->num_elt + a->max_idx,
79  sizeof (anon_nasl_var *) * (num + 1 - a->max_idx));
80  a->max_idx = num + 1;
81  }
82  v = g_malloc0 (sizeof (anon_nasl_var));
83  v->var_type = VAR2_UNDEF;
84 
85  a->num_elt[num] = v;
86  return v;
87 }

References st_nasl_array::max_idx, nasl_perror(), st_nasl_array::num_elt, VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by get_array_elem(), nasl_keys(), nasl_make_array(), nasl_make_list(), nasl_max_index(), and nasl_typeof().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ nasl_iterate_array()

tree_cell* nasl_iterate_array ( nasl_iterator )

Definition at line 1214 of file nasl_var.c.

1215  {
1216  anon_nasl_var *av;
1217 
1218  if (it == NULL || it->a == NULL)
1219  return NULL;
1220 
1221  if (it->i1 >= 0)
1222  {
1223  while (it->i1 < it->a->max_idx)
1224  {
1225  av = it->a->num_elt[it->i1++];
1226  if (av != NULL && av->var_type != VAR2_UNDEF)
1227  return var2cell (av);
1228  }
1229  it->i1 = -1;
1230  }
1231 
1232  if (it->a->hash_elt == NULL)
1233  return NULL;
1234 
1235  if (it->v != NULL)
1236  it->v = it->v->next_var;
1237  do
1238  {
1239  while (it->v == NULL)
1240  if (it->iH >= VAR_NAME_HASH)
1241  return NULL;
1242  else
1243  it->v = it->a->hash_elt[it->iH++];
1244 
1245  while (it->v != NULL && it->v->u.var_type == VAR2_UNDEF)
1246  it->v = it->v->next_var;
1247  }
1248  while (it->v == NULL);
1249 
1250  return var2cell (&it->v->u);
1251  }

References nasl_iterator::a, st_nasl_array::hash_elt, nasl_iterator::i1, nasl_iterator::iH, st_nasl_array::max_idx, st_n_nasl_var::next_var, st_nasl_array::num_elt, st_n_nasl_var::u, nasl_iterator::v, VAR2_UNDEF, var2cell(), VAR_NAME_HASH, and st_a_nasl_var::var_type.

Referenced by nasl_exec().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ var2cell()

tree_cell* var2cell ( anon_nasl_var )

Definition at line 183 of file nasl_var.c.

184 {
186  tc->x.ref_val = v; /* No need to free this later! */
187  return tc;
188 }

References alloc_typed_cell(), TC::ref_val, REF_VAR, and TC::x.

Referenced by get_array_elem(), get_variable_by_name(), nasl_iterate_array(), and var_cmp().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ var2str()

const char* var2str ( anon_nasl_var )

Definition at line 1076 of file nasl_var.c.

1077  {
1078  if (v == NULL)
1079  return NULL;
1080 
1081  if (v->string_form)
1082  return v->string_form;
1083  switch (v->var_type)
1084  {
1085  case VAR2_INT:
1086  v->string_form = g_strdup_printf ("%ld", v->v.v_int);
1087  break;
1088  case VAR2_STRING:
1089  case VAR2_DATA:
1090  v->string_form =
1091  g_memdup ((char *) v->v.v_str.s_val ?: "", v->v.v_str.s_siz + 1);
1092  break;
1093  case VAR2_UNDEF:
1094  break;
1095  case VAR2_ARRAY:
1096  v->string_form = array2str (&v->v.v_arr);
1097  break;
1098  default:
1099  v->string_form = g_strdup ("");
1100  break;
1101  }
1102  return v->string_form;
1103  }

References array2str(), st_nasl_string::s_siz, st_nasl_string::s_val, st_a_nasl_var::string_form, st_a_nasl_var::v, st_a_nasl_var::v_arr, st_a_nasl_var::v_int, st_a_nasl_var::v_str, VAR2_ARRAY, VAR2_DATA, VAR2_INT, VAR2_STRING, VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by dump_tree(), get_str_var_by_name(), get_str_var_by_num(), nasl_make_array(), and nasl_pread().

Here is the call graph for this function:
Here is the caller graph for this function:
nasl_iterator::i1
int i1
Definition: nasl_var.h:79
st_a_nasl_var
Definition: nasl_var.h:50
nasl_type_name
const char * nasl_type_name(int t)
Definition: nasl_tree.c:357
VAR2_ARRAY
@ VAR2_ARRAY
Definition: nasl_var.h:30
dup_anon_var
static anon_nasl_var * dup_anon_var(const anon_nasl_var *v)
Definition: nasl_var.c:481
CONST_DATA
@ CONST_DATA
Definition: nasl_tree.h:93
TC::str_val
char * str_val
Definition: nasl_tree.h:112
copy_array
static void copy_array(nasl_array *, const nasl_array *, int)
Definition: nasl_var.c:508
CONST_STR
@ CONST_STR
Definition: nasl_tree.h:91
st_n_nasl_var
Definition: nasl_var.h:65
array2str
char * array2str(const nasl_array *a)
Definition: nasl_var.c:1004
st_nasl_array::max_idx
int max_idx
Definition: nasl_var.h:45
st_a_nasl_var::v_arr
nasl_array v_arr
Definition: nasl_var.h:60
st_nasl_array::hash_elt
struct st_n_nasl_var ** hash_elt
Definition: nasl_var.h:47
DYN_ARRAY
@ DYN_ARRAY
Definition: nasl_tree.h:101
FAKE_CELL
#define FAKE_CELL
Definition: nasl_tree.h:119
TC::x
union TC::@2 x
st_n_nasl_var::var_name
char * var_name
Definition: nasl_var.h:69
st_a_nasl_var::v_str
nasl_string_t v_str
Definition: nasl_var.h:58
st_nasl_string::s_siz
int s_siz
Definition: nasl_var.h:38
name
const char * name
Definition: nasl_init.c:377
st_nasl_array
Definition: nasl_var.h:43
free_var_chain
static void free_var_chain(named_nasl_var *)
Definition: nasl_var.c:378
nasl_iterator::v
named_nasl_var * v
Definition: nasl_var.h:81
st_n_nasl_var::next_var
struct st_n_nasl_var * next_var
Definition: nasl_var.h:73
affect_to_anon_var
static tree_cell * affect_to_anon_var(anon_nasl_var *v1, tree_cell *rval)
Definition: nasl_var.c:566
nasl_iterator::iH
int iH
Definition: nasl_var.h:80
nasl_perror
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
copy_anon_var
static void copy_anon_var(anon_nasl_var *v1, const anon_nasl_var *v2)
Definition: nasl_var.c:442
add_var_to_array
int add_var_to_array(nasl_array *a, char *name, const anon_nasl_var *v)
Definition: nasl_var.c:1286
VAR2_UNDEF
@ VAR2_UNDEF
Definition: nasl_var.h:26
TC::size
int size
Definition: nasl_tree.h:109
var2cell
tree_cell * var2cell(anon_nasl_var *v)
Definition: nasl_var.c:183
VAR2_DATA
@ VAR2_DATA
Definition: nasl_var.h:29
TC::ref_val
void * ref_val
Definition: nasl_tree.h:114
st_a_nasl_var::var_type
int var_type
Definition: nasl_var.h:52
TC
Definition: nasl_tree.h:104
TC::type
short type
Definition: nasl_tree.h:106
TC::link
struct TC * link[4]
Definition: nasl_tree.h:116
REF_VAR
@ REF_VAR
Definition: nasl_tree.h:99
CONST_INT
@ CONST_INT
Definition: nasl_tree.h:90
nasl_iterator::a
nasl_array * a
Definition: nasl_var.h:78
hash_str
static int hash_str(const char *s)
Definition: nasl_var.c:52
nasl_iterator
Definition: nasl_var.h:76
add_var_to_list
int add_var_to_list(nasl_array *a, int i, const anon_nasl_var *v)
Definition: nasl_var.c:1254
st_a_nasl_var::v
union st_a_nasl_var::@4 v
VAR2_STRING
@ VAR2_STRING
Definition: nasl_var.h:28
st_a_nasl_var::v_int
long int v_int
Definition: nasl_var.h:59
REF_ARRAY
@ REF_ARRAY
Definition: nasl_tree.h:100
free_anon_var
static void free_anon_var(anon_nasl_var *)
Definition: nasl_var.c:399
deref_cell
void deref_cell(tree_cell *c)
Definition: nasl_tree.c:192
alloc_typed_cell
tree_cell * alloc_typed_cell(int typ)
Definition: nasl_tree.c:40
st_n_nasl_var::u
struct st_a_nasl_var u
Definition: nasl_var.h:67
VAR2_INT
@ VAR2_INT
Definition: nasl_var.h:27
VAR_NAME_HASH
#define VAR_NAME_HASH
Definition: nasl_var.h:33
st_nasl_string::s_val
unsigned char * s_val
Definition: nasl_var.h:37
TC::i_val
long int i_val
Definition: nasl_tree.h:113
st_nasl_array::num_elt
struct st_a_nasl_var ** num_elt
Definition: nasl_var.h:46