src/vppinfra/macros.c - fdio/vpp - Gitiles

 /*
  * macros.c - a simple macro expander
  *
  *  Copyright (c) 2010-2020 Cisco and/or its affiliates.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
 */

 #include <vppinfra/macros.h>

 static inline int
 macro_isalnum (i8 c)
 {
   if ((c >= 'A' && c <= 'Z')
       || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || (c == '_'))
     return 1;
   return 0;
 }

 static i8 *
 builtin_eval (clib_macro_main_t * mm, i8 * varname, i32 complain)
 {
   uword *p;
   i8 *(*fp) (clib_macro_main_t *, i32);

   p = hash_get_mem (mm->the_builtin_eval_hash, varname);
   if (p == 0)
     return 0;
   fp = (void *) (p[0]);
   return (*fp) (mm, complain);
 }

 __clib_export int
 clib_macro_unset (clib_macro_main_t * mm, char *name)
 {
   hash_pair_t *p;
   u8 *key, *value;

   p = hash_get_pair (mm->the_value_table_hash, name);

   if (p == 0)
     return 1;

   key = (u8 *) (p->key);
   value = (u8 *) (p->value[0]);
   hash_unset_mem (mm->the_value_table_hash, name);

   vec_free (value);
   vec_free (key);
   return 0;
 }

 __clib_export int
 clib_macro_set_value (clib_macro_main_t * mm, char *name, char *value)
 {
   u8 *key_copy, *value_copy;
   int rv;

   rv = clib_macro_unset (mm, name);

   key_copy = format (0, "%s%c", name, 0);
   value_copy = format (0, "%s%c", value, 0);

   hash_set_mem (mm->the_value_table_hash, key_copy, value_copy);
   return rv;
 }

 i8 *
 clib_macro_get_value (clib_macro_main_t * mm, char *name)
 {
   uword *p;

   p = hash_get_mem (mm->the_value_table_hash, name);
   if (p)
     return (i8 *) (p[0]);
   else
     return 0;
 }

 /*
  * eval: takes a string, returns a vector.
  * looks up $foobar in the variable table.
  */
 __clib_export i8 *
 clib_macro_eval (clib_macro_main_t * mm, i8 * s, i32 complain, u16 level,
 		 u16 max_level)
 {
   i8 *rv = 0;
   i8 *varname, *varvalue;
   i8 *ts;

   if (level >= max_level)
     {
       if (complain)
 	clib_warning ("circular definition, level %d", level);
       return (i8 *) format (0, " CIRCULAR ");
     }

   while (*s)
     {
       switch (*s)
 	{
 	case '\\':
 	  s++;
 	  /* fallthrough */

 	default:
 	  vec_add1 (rv, *s);
 	  s++;
 	  break;

 	case '$':
 	  s++;
 	  varname = 0;
 	  /*
 	   * Make vector with variable name in it.
 	   */
 	  while (*s && (macro_isalnum (*s) || (*s == '_') || (*s == '(')))
 	    {

 	      /* handle $(foo) */
 	      if (*s == '(')
 		{
 		  s++;		/* skip '(' */
 		  while (*s && *s != ')')
 		    {
 		      vec_add1 (varname, *s);
 		      s++;
 		    }
 		  if (*s)
 		    s++;	/* skip ')' */
 		  break;
 		}
 	      vec_add1 (varname, *s);
 	      s++;
 	    }
 	  /* null terminate */
 	  vec_add1 (varname, 0);
 	  /* Look for a builtin, e.g. $my_hostname */
 	  if (!(varvalue = builtin_eval (mm, varname, complain)))
 	    {
 	      /* Look in value table */
 	      if (!varvalue)
 		{
 		  i8 *tmp = clib_macro_get_value (mm, (char *) varname);
 		  if (tmp)
 		    varvalue = (i8 *) format (0, "%s%c", tmp, 0);
 		}
 #ifdef CLIB_UNIX
 	      /* Look in environment. */
 	      if (!varvalue)
 		{
 		  char *tmp = getenv ((char *) varname);
 		  if (tmp)
 		    varvalue = (i8 *) format (0, "%s%c", tmp, 0);
 		}
 #endif /* CLIB_UNIX */
 	    }
 	  if (varvalue)
 	    {
 	      /* recursively evaluate */
 	      ts = clib_macro_eval (mm, varvalue, complain, level + 1,
 				    max_level);
 	      vec_free (varvalue);
 	      /* add results to answer */
 	      vec_append (rv, ts);
 	      /* Remove NULL termination or the results are sad */
 	      _vec_len (rv) = vec_len (rv) - 1;
 	      vec_free (ts);
 	    }
 	  else
 	    {
 	      if (complain)
 		clib_warning ("Undefined Variable Reference: %s\n", varname);
 	      vec_append (rv, format (0, "UNSET "));
 	      _vec_len (rv) = vec_len (rv) - 1;

 	    }
 	  vec_free (varname);
 	}
     }
   vec_add1 (rv, 0);
   return (rv);
 }

 /*
  * eval: takes a string, returns a vector.
  * looks up $foobar in the variable table.
  */
 i8 *
 clib_macro_eval_dollar (clib_macro_main_t * mm, i8 * s, i32 complain)
 {
   i8 *s2;
   i8 *rv;

   s2 = (i8 *) format (0, "$(%s)%c", s, 0);
   rv = clib_macro_eval (mm, s2, complain, 0 /* level */ , 8 /* max_level */ );
   vec_free (s2);
   return (rv);
 }

 __clib_export void
 clib_macro_add_builtin (clib_macro_main_t * mm, char *name, void *eval_fn)
 {
   hash_set_mem (mm->the_builtin_eval_hash, name, (uword) eval_fn);
 }

 #ifdef CLIB_UNIX
 static i8 *
 eval_hostname (clib_macro_main_t * mm, i32 complain)
 {
   char tmp[128];
   if (gethostname (tmp, sizeof (tmp)))
     return ((i8 *) format (0, "gethostname-error%c", 0));
   return ((i8 *) format (0, "%s%c", tmp, 0));
 }
 #endif

 __clib_export void
 clib_macro_init (clib_macro_main_t * mm)
 {
   if (mm->the_builtin_eval_hash != 0)
     {
       clib_warning ("mm %p already initialized", mm);
       return;
     }

   mm->the_builtin_eval_hash = hash_create_string (0, sizeof (uword));
   mm->the_value_table_hash = hash_create_string (0, sizeof (uword));

 #ifdef CLIB_UNIX
   hash_set_mem (mm->the_builtin_eval_hash, "hostname", (uword) eval_hostname);
 #endif
 }

 __clib_export void
 clib_macro_free (clib_macro_main_t * mm)
 {
   hash_pair_t *p;
   u8 **strings_to_free = 0;
   int i;

   hash_free (mm->the_builtin_eval_hash);

   /* *INDENT-OFF* */
   hash_foreach_pair (p, mm->the_value_table_hash,
   ({
     vec_add1 (strings_to_free, (u8 *) (p->key));
     vec_add1 (strings_to_free, (u8 *) (p->value[0]));
   }));
   /* *INDENT-ON* */

   for (i = 0; i < vec_len (strings_to_free); i++)
     vec_free (strings_to_free[i]);
   vec_free (strings_to_free);
   hash_free (mm->the_value_table_hash);
 }

 typedef struct
 {
   u8 *name;
   u8 *value;
 } name_sort_t;

 static int
 name_compare (void *a1, void *a2)
 {
   name_sort_t *ns1 = a1;
   name_sort_t *ns2 = a2;

   return strcmp ((char *) ns1->name, (char *) ns2->name);
 }


 __clib_export u8 *
 format_clib_macro_main (u8 * s, va_list * args)
 {
   clib_macro_main_t *mm = va_arg (*args, clib_macro_main_t *);
   int evaluate = va_arg (*args, int);
   hash_pair_t *p;
   name_sort_t *nses = 0, *ns;
   int i;

   /* *INDENT-OFF* */
   hash_foreach_pair (p, mm->the_value_table_hash,
   ({
     vec_add2 (nses, ns, 1);
     ns->name = (u8 *)(p->key);
     ns->value = (u8 *)(p->value[0]);
   }));
   /* *INDENT-ON* */

   if (vec_len (nses) == 0)
     return s;

   vec_sort_with_function (nses, name_compare);

   for (i = 0; i < vec_len (nses); i++)
     {
       s = format (s, "%-20s", nses[i].name);
       if (evaluate == 0)
 	s = format (s, "%s\n", nses[i].value);
       else
 	{
 	  u8 *rv = (u8 *) clib_macro_eval_dollar (mm, (i8 *) nses[i].name,
 						  0 /* no complain */ );
 	  s = format (s, "%s\n", rv);
 	  vec_free (rv);
 	}
     }
   return s;
 }


 /*
  * fd.io coding-style-patch-verification: ON
  *
  * Local Variables:
  * eval: (c-set-style "gnu")
  * End:
  */
	/*
	* macros.c - a simple macro expander
	*
	* Copyright (c) 2010-2020 Cisco and/or its affiliates.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at:
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <vppinfra/macros.h>

	static inline int
	macro_isalnum (i8 c)
	{
	if ((c >= 'A' && c <= 'Z')
	\|\| (c >= 'a' && c <= 'z') \|\| (c >= '0' && c <= '9') \|\| (c == '_'))
	return 1;
	return 0;
	}

	static i8 *
	builtin_eval (clib_macro_main_t * mm, i8 * varname, i32 complain)
	{
	uword *p;
	i8 (fp) (clib_macro_main_t *, i32);

	p = hash_get_mem (mm->the_builtin_eval_hash, varname);
	if (p == 0)
	return 0;
	fp = (void *) (p[0]);
	return (*fp) (mm, complain);
	}

	__clib_export int
	clib_macro_unset (clib_macro_main_t * mm, char *name)
	{
	hash_pair_t *p;
	u8 key, value;

	p = hash_get_pair (mm->the_value_table_hash, name);

	if (p == 0)
	return 1;

	key = (u8 *) (p->key);
	value = (u8 *) (p->value[0]);
	hash_unset_mem (mm->the_value_table_hash, name);

	vec_free (value);
	vec_free (key);
	return 0;
	}

	__clib_export int
	clib_macro_set_value (clib_macro_main_t * mm, char name, char value)
	{
	u8 key_copy, value_copy;
	int rv;

	rv = clib_macro_unset (mm, name);

	key_copy = format (0, "%s%c", name, 0);
	value_copy = format (0, "%s%c", value, 0);

	hash_set_mem (mm->the_value_table_hash, key_copy, value_copy);
	return rv;
	}

	i8 *
	clib_macro_get_value (clib_macro_main_t * mm, char *name)
	{
	uword *p;

	p = hash_get_mem (mm->the_value_table_hash, name);
	if (p)
	return (i8 *) (p[0]);
	else
	return 0;
	}

	/*
	* eval: takes a string, returns a vector.
	* looks up $foobar in the variable table.
	*/
	__clib_export i8 *
	clib_macro_eval (clib_macro_main_t * mm, i8 * s, i32 complain, u16 level,
	u16 max_level)
	{
	i8 *rv = 0;
	i8 varname, varvalue;
	i8 *ts;

	if (level >= max_level)
	{
	if (complain)
	clib_warning ("circular definition, level %d", level);
	return (i8 *) format (0, " CIRCULAR ");
	}

	while (*s)
	{
	switch (*s)
	{
	case '\\':
	s++;
	/* fallthrough */

	default:
	vec_add1 (rv, *s);
	s++;
	break;

	case '$':
	s++;
	varname = 0;
	/*
	* Make vector with variable name in it.
	*/
	while (s && (macro_isalnum (s) \|\| (s == '_') \|\| (s == '(')))
	{

	/* handle $(foo) */
	if (*s == '(')
	{
	s++; /* skip '(' */
	while (s && s != ')')
	{
	vec_add1 (varname, *s);
	s++;
	}
	if (*s)
	s++; /* skip ')' */
	break;
	}
	vec_add1 (varname, *s);
	s++;
	}
	/* null terminate */
	vec_add1 (varname, 0);
	/* Look for a builtin, e.g. $my_hostname */
	if (!(varvalue = builtin_eval (mm, varname, complain)))
	{
	/* Look in value table */
	if (!varvalue)
	{
	i8 tmp = clib_macro_get_value (mm, (char ) varname);
	if (tmp)
	varvalue = (i8 *) format (0, "%s%c", tmp, 0);
	}
	#ifdef CLIB_UNIX
	/* Look in environment. */
	if (!varvalue)
	{
	char tmp = getenv ((char ) varname);
	if (tmp)
	varvalue = (i8 *) format (0, "%s%c", tmp, 0);
	}
	#endif /* CLIB_UNIX */
	}
	if (varvalue)
	{
	/* recursively evaluate */
	ts = clib_macro_eval (mm, varvalue, complain, level + 1,
	max_level);
	vec_free (varvalue);
	/* add results to answer */
	vec_append (rv, ts);
	/* Remove NULL termination or the results are sad */
	_vec_len (rv) = vec_len (rv) - 1;
	vec_free (ts);
	}
	else
	{
	if (complain)
	clib_warning ("Undefined Variable Reference: %s\n", varname);
	vec_append (rv, format (0, "UNSET "));
	_vec_len (rv) = vec_len (rv) - 1;

	}
	vec_free (varname);
	}
	}
	vec_add1 (rv, 0);
	return (rv);
	}

	/*
	* eval: takes a string, returns a vector.
	* looks up $foobar in the variable table.
	*/
	i8 *
	clib_macro_eval_dollar (clib_macro_main_t * mm, i8 * s, i32 complain)
	{
	i8 *s2;
	i8 *rv;

	s2 = (i8 *) format (0, "$(%s)%c", s, 0);
	rv = clib_macro_eval (mm, s2, complain, 0 /* level / , 8 / max_level */ );
	vec_free (s2);
	return (rv);
	}

	__clib_export void
	clib_macro_add_builtin (clib_macro_main_t * mm, char name, void eval_fn)
	{
	hash_set_mem (mm->the_builtin_eval_hash, name, (uword) eval_fn);
	}

	#ifdef CLIB_UNIX
	static i8 *
	eval_hostname (clib_macro_main_t * mm, i32 complain)
	{
	char tmp[128];
	if (gethostname (tmp, sizeof (tmp)))
	return ((i8 *) format (0, "gethostname-error%c", 0));
	return ((i8 *) format (0, "%s%c", tmp, 0));
	}
	#endif

	__clib_export void
	clib_macro_init (clib_macro_main_t * mm)
	{
	if (mm->the_builtin_eval_hash != 0)
	{
	clib_warning ("mm %p already initialized", mm);
	return;
	}

	mm->the_builtin_eval_hash = hash_create_string (0, sizeof (uword));
	mm->the_value_table_hash = hash_create_string (0, sizeof (uword));

	#ifdef CLIB_UNIX
	hash_set_mem (mm->the_builtin_eval_hash, "hostname", (uword) eval_hostname);
	#endif
	}

	__clib_export void
	clib_macro_free (clib_macro_main_t * mm)
	{
	hash_pair_t *p;
	u8 **strings_to_free = 0;
	int i;

	hash_free (mm->the_builtin_eval_hash);

	/* INDENT-OFF */
	hash_foreach_pair (p, mm->the_value_table_hash,
	({
	vec_add1 (strings_to_free, (u8 *) (p->key));
	vec_add1 (strings_to_free, (u8 *) (p->value[0]));
	}));
	/* INDENT-ON */

	for (i = 0; i < vec_len (strings_to_free); i++)
	vec_free (strings_to_free[i]);
	vec_free (strings_to_free);
	hash_free (mm->the_value_table_hash);
	}

	typedef struct
	{
	u8 *name;
	u8 *value;
	} name_sort_t;

	static int
	name_compare (void a1, void a2)
	{
	name_sort_t *ns1 = a1;
	name_sort_t *ns2 = a2;

	return strcmp ((char ) ns1->name, (char ) ns2->name);
	}


	__clib_export u8 *
	format_clib_macro_main (u8 * s, va_list * args)
	{
	clib_macro_main_t mm = va_arg (args, clib_macro_main_t *);
	int evaluate = va_arg (*args, int);
	hash_pair_t *p;
	name_sort_t nses = 0, ns;
	int i;

	/* INDENT-OFF */
	hash_foreach_pair (p, mm->the_value_table_hash,
	({
	vec_add2 (nses, ns, 1);
	ns->name = (u8 *)(p->key);
	ns->value = (u8 *)(p->value[0]);
	}));
	/* INDENT-ON */

	if (vec_len (nses) == 0)
	return s;

	vec_sort_with_function (nses, name_compare);

	for (i = 0; i < vec_len (nses); i++)
	{
	s = format (s, "%-20s", nses[i].name);
	if (evaluate == 0)
	s = format (s, "%s\n", nses[i].value);
	else
	{
	u8 rv = (u8 ) clib_macro_eval_dollar (mm, (i8 *) nses[i].name,
	0 /* no complain */ );
	s = format (s, "%s\n", rv);
	vec_free (rv);
	}
	}
	return s;
	}


	/*
	* fd.io coding-style-patch-verification: ON
	*
	* Local Variables:
	* eval: (c-set-style "gnu")
	* End:
	*/