erl_format(3erl) [linux man page]

erl_format(3erl)						C Library Functions						  erl_format(3erl)

NAME

       erl_format - Create and Match Erlang Terms

DESCRIPTION

       This module contains two routines - one general function for creating Erlang terms and one for pattern matching Erlang terms.

EXPORTS

       ETERM * erl_format(FormatStr, ... )

	      Types  char *FormatStr;

	      This  is a general function for creating Erlang terms using a format specifier and a corresponding set of arguments, much in the way
	      printf() works.

	      FormatStr is a format specification string. The set of valid format specifiers is as follows:

		* ~i - Integer

		* ~f - Floating point

		* ~a - Atom

		* ~s - String

		* ~w - Arbitrary Erlang term

	      For each format specifier that appears in FormatStr , there must be a corresponding argument following FormatStr . An Erlang term is
	      built  according	to  the  FormatStr  with values and Erlang terms substituted from the corresponding arguments and according to the
	      individual format specifiers. For example:

	      erl_format("[{name,~a},{age,~i},{data,~w}]",
			 "madonna",
			 21,
			 erl_format("[{adr,~s,~i}]","E-street",42));

	      This will create an (ETERM *) structure corresponding to the Erlang term: [{name,madonna},{age,21},{data,[{adr,"E-street",42}]}]

	      The function returns an Erlang term, or NULL if FormatStr does not describe a valid Erlang term.

       int erl_match(Pattern, Term)

	      Types  ETERM *Pattern,*Term;

	      This function is used to perform pattern matching similar to that done in Erlang. Refer to an Erlang manual for matching	rules  and
	      more examples.

	      Pattern is an Erlang term, possibly containing unbound variables.

	      Term is an Erlang term that we wish to match against Pattern .

	      Term and Pattern are compared, and any unbound variables in Pattern are bound to corresponding values in Term .

	      If  Term and Pattern can be matched, the function returns a non-zero value and binds any unbound variables in Pattern . If Term Pat-
	      tern do not match, the function returns 0. For example:

	      ETERM *term, *pattern, *pattern2;
	      term1    = erl_format("{14,21}");
	      term2    = erl_format("{19,19}");
	      pattern1 = erl_format("{A,B}");
	      pattern2 = erl_format("{F,F}");
	      if (erl_match(pattern1, term1)) {
		/* match succeeds:
		 * A gets bound to 14,
		 * B gets bound to 21
		 */
		...
	      }
	      if (erl_match(pattern2, term1)) {
		/* match fails because F cannot be
		 * bound to two separate values, 14 and 21
		 */
		...
	      }
	      if (erl_match(pattern2, term2)) {
		/* match succeeds and F gets bound to 19 */
		...
	      }

	      erl_var_content() can be used to retrieve the content of any variables bound as a result of a call to erl_match() .

Ericsson AB							erl_interface 3.7.3						  erl_format(3erl)

erl_global(3erl)						C Library Functions						  erl_global(3erl)

NAME

       erl_global - Access globally registered names

DESCRIPTION

       This module provides support for registering, looking up and unregistering names in the Erlang Global module. For more information, see the
       description of Global in the reference manual.

       Note that the functions below perform an RPC using an open file descriptor provided by the caller. This file descriptor must  not  be  used
       for other traffic during the global operation or the function may receive unexpected data and fail.

EXPORTS

       char ** erl_global_names(fd,count)

	      Types  int fd;
		     int *count;

	      Retrieve a list of all known global names.

	      fd is an open descriptor to an Erlang connection.

	      count is the address of an integer, or NULL. If count is not NULL, it will be set by the function to the number of names found.

	      On  success,  the  function  returns  an array of strings, each containing a single registered name, and sets count to the number of
	      names found. The array is terminated by a single NULL pointer. On failure, the function returns NULL and count is not modified.

   Note:
       It is the caller's responsibility to free the array afterwards. It has been allocated by the function with a single call to malloc() , so a
       single free() is all that is necessary.

       int erl_global_register(fd,name,pid)

	      Types  int fd;
		     const char *name;
		     ETERM *pid;

	      This function registers a name in Global.

	      fd is an open descriptor to an Erlang connection.

	      name is the name to register in Global.

	      pid  is  the pid that should be associated with name . This is the value that Global will return when processes request the location
	      of name .

	      The function returns 0 on success, or -1 on failure.

       int erl_global_unregister(fd,name)

	      Types  int fd;
		     const char *name;

	      This function unregisters a name from Global.

	      fd is an open descriptor to an Erlang connection.

	      name is the name to unregister from Global.

	      The function returns 0 on success, or -1 on failure.

       ETERM * erl_global_whereis(fd,name,node)

	      Types  int fd;
		     const char *name;
		     char *node;

	      fd is an open descriptor to an Erlang connection.

	      name is the name that is to be looked up in Global.

	      If node is not NULL, it is a pointer to a buffer where the function can fill in the name of the node where name is found.  node  can
	      be passed directly to erl_connect() if necessary.

	      On  success,  the function returns an Erlang Pid containing the address of the given name, and node will be initialized to the node-
	      name where name is found. On failure NULL will be returned and node will not be modified.

Ericsson AB							erl_interface 3.7.3						  erl_global(3erl)