-tarval *tarval_F_from_str (const char *s, size_t len);
-tarval *tarval_D_from_str (const char *s, size_t len);
-tarval *tarval_int_from_str (const char *s, size_t len, int base, ir_mode *m);
-tarval *tarval_from_long (ir_mode *m, long val);
-
-tarval *tarval_P_from_str (const char *xname);
-/* The tarval represents the address of the entity. As the address must
- be constant the entity must have as owner the global type. */
-tarval *tarval_P_from_entity (entity *ent);
-
-tarval *tarval_convert_to (tarval *src, ir_mode *m);
-
-/* Building an irm_C, irm_s, irm_S or irm_B target value step by step. */
-void tarval_start (void);
-void tarval_append (const char *p, size_t n);
-void tarval_append1 (char ch);
-tarval *tarval_finish_as (ir_mode *m);
-tarval *tarval_cancel (void); /* returns tarval_bad */
-
-/* The flags for projecting a comparison result */
-typedef enum {
- irpn_False=0, /* 0000 false */
- irpn_Eq, /* 0001 equal */
- irpn_Lt, /* 0010 less */
- irpn_Le, /* 0011 less or equal */
- irpn_Gt, /* 0100 greater */
- irpn_Ge, /* 0101 greater of equal */
- irpn_Lg, /* 0110 less or greater */
- irpn_Leg, /* 0111 less, equal or greater = ordered */
- irpn_Uo, /* 1000 unordered */
- irpn_Ue, /* 1001 unordered or equal */
- irpn_Ul, /* 1010 unordered or less */
- irpn_Ule, /* 1011 unordered, less or equal */
- irpn_Ug, /* 1100 unordered or greater */
- irpn_Uge, /* 1101 unordered, greater or equal */
- irpn_Ne, /* 1110 unordered, less or greater = not equal */
- irpn_True /* 1111 true */
- /*irpn_notmask = irpn_Leg @@@ removed for JNI builder */
-} ir_pncmp;
-#define irpn_notmask irpn_Leg
+
+/**
+ * Constructor function for new tarvals.
+ *
+ * @param str The string representing the target value
+ * @param len The length of the string
+ * @param mode The mode requested for the result tarval
+ *
+ * This function creates a new tarval representing the value represented
+ * by a CString, aka char array. If a tarval representing this value already
+ * exists, this tarval is returned instead of a new one. So tarvals are
+ * directly comparable since their representation is unique.
+ *
+ * This function accepts the following strings:
+ *
+ * if mode is int_number:
+ * - 0(x|X)[0-9a-fA-F]+ (hexadecimal representation)
+ * - 0[0-7]* (octal representation)
+ * - (+|-)?[1-9][0-9]* (decimal representation)
+ *
+ * if mode if float_number:
+ * - (+|-)?(decimal int) (. (decimal int))? ((e|E)(+|-)?(decimal int))?
+ *
+ * if mode is boolean: true, True, TRUE ... False... 0, 1,
+ *
+ * if mode is reference: hexadecimal of decimal number as int
+ *
+ * if mode is character: hex or dec
+ *
+ * Leading and/or trailing spaces are ignored
+ *
+ * @return
+ * A tarval of proper type representing the requested value is returned.
+ * Tarvals are unique, so for any value/mode pair at most one tarval will
+ * exist, which will be returned upon further requests with an identical
+ * value/mode pair.
+ *
+ * @note
+ * If the string is not representable in the given mode an assertion is
+ * thrown in assert build.
+ *
+ * @sa
+ * irmode.h for predefined modes
+ * new_tarval_from_long()
+ * new_tarval_from_double()
+ */
+tarval *new_tarval_from_str(const char *str, size_t len, ir_mode *mode);
+
+/**
+ * Constructor function for new tarvals
+ *
+ * @param l The long representing the value
+ * @param mode The mode requested for the result tarval
+ *
+ * This function creates a new tarval representing the value represented
+ * by a long integer. If a tarval representing this value already exists,
+ * this tarval is returned instead of a new one. So tarvals are directly
+ * comparable since their representation is unique.
+ *
+ * @return
+ * A tarval of proper type representing the requested value is returned.
+ * Tarvals are unique, so for any value/mode pair at most one tarval will
+ * exist, which will be returned upon further requests with an identical
+ * value/mode pair.
+ *
+ * @note
+ * If the long is not representable in the given mode an assertion is
+ * thrown in assert build.
+ *
+ * @sa
+ * irmode.h for predefined modes
+ * new_tarval_from_str()
+ * new_tarval_from_double()
+ *
+ */
+tarval *new_tarval_from_long(long l, ir_mode *mode);
+
+/**
+ * This returns a long int with the value represented value, or
+ * gibberish, depending on the size of long int and the size of the
+ * stored value. It works for e.g. 1 as mode_Ls, but might not work for
+ * get_mode_max(mode_Ls).
+ * This will overflow silently, so use only if you know what
+ * you are doing! (better check with tarval_is_long()...)
+ */
+long tarval_to_long(tarval *tv);
+
+/**
+ * This validates if tarval_to_long() will return a satisfying
+ * result. I.e. if tv is an int_number and between min, max
+ * of long int (signed!)
+ */
+int tarval_is_long(tarval *tv);
+
+/**
+ * Constructor function for new tarvals.
+ *
+ * @param d The long double representing the value
+ * @param mode The mode requested for the result tarval
+ *
+ * This function creates a new tarval representing the value represented
+ * by a long double. If a tarval representing this value already exists,
+ * this tarval is returned instead of a new one. So tarvals are directly
+ * comparable since their representation is unique.
+ * Only modes of sort float_number can be constructed this way.
+ *
+ * @return
+ * A tarval of proper type representing the requested value is returned.
+ * Tarvals are unique, so for any value/mode pair at most one tarval will
+ * exist, which will be returned upon further requests with an identical
+ * value/mode pair.
+ *
+ * @note
+ * If the long double is not representable in the given mode an assertion
+ * is thrown. This will happen for any mode not of sort float_number.
+ *
+ * @sa
+ * irmode.h for predefined values
+ * new_tarval_from_str()
+ * new_tarval_from_long()
+ */
+tarval *new_tarval_from_double(long double d, ir_mode *mode);
+
+/**
+ * This returns a double with the value represented value, or
+ * gibberish, depending on the size of double and the size of the
+ * stored value.
+ * This will overflow silently, so use only if you know what
+ * you are doing! (better check with tarval_is_long...)
+ */
+long double tarval_to_double(tarval *tv);
+
+/**
+ * This validates if tarval_to_double() will return a satisfying
+ * result. I.e. if tv is an float_number and between min, max
+ * of double
+ */
+int tarval_is_double(tarval *tv);
+
+/**
+ * Construct a tarval that represents the address of the entity.
+ *
+ * The address must be constant, the entity must have as owner the global type.
+ */
+tarval *new_tarval_from_entity (entity *ent, ir_mode *mode);
+
+/**
+ * Returns the associated entity of a tarval.
+ */
+entity *tarval_to_entity(tarval *tv);
+
+/**
+ * Returns non-zero if a the given tarval represents an entity.
+ */
+int tarval_is_entity(tarval *tv);
+
+/** ********** Access routines for tarval fields ********** **/
+
+/*
+ * NAME
+ * get_tarval_mode
+ * get_tarval_ ...
+ *
+ * SYNOPSIS
+ * ir_mode *get_tarval_mode(tarval *tv)
+ * ...
+ *
+ * DESCRIPTION
+ * These are access function for tarval struct members. It is encouraged
+ * to use them instead of direct access to the struct fields.
+ *
+ * PARAMETERS
+ * tv - The tarval to access fields of
+ *
+ * RESULT
+ * get_tv_mode: The mode of the tarval
+ *
+ * SEE ALSO
+ * the struct tarval
+ */
+
+/** Returns the mode of the tarval. */
+#ifdef TARVAL_ACCESS_DEFINES
+# include "tv_t.h"
+# define get_tarval_mode(tv) (tv)->mode
+#else
+ir_mode *get_tarval_mode (tarval *tv);
+#endif
+
+/* Testing properties of the represented values */
+
+/** Returns 0 if tv is positive, else > 0.
+ *
+ * @todo
+ * not tested!
+ */
+int tarval_is_negative(tarval *a);
+
+/** The 'bad' tarval. */
+extern tarval *tarval_bad;
+/** Returns the 'bad tarval. */
+tarval *get_tarval_bad(void);
+
+/** The 'undefined' tarval. */
+extern tarval *tarval_undefined;
+/** Returns the 'undefined' tarval. */
+tarval *get_tarval_undefined(void);
+
+/** The mode_b tarval 'false'. */
+extern tarval *tarval_b_false;
+/** Returns the mode_b tarval 'false'. */
+tarval *get_tarval_b_false(void);
+
+/** The mode_b tarval 'true'. */
+extern tarval *tarval_b_true;
+/** Returns the mode_b tarval 'true'. */
+tarval *get_tarval_b_true(void);
+
+/** The 'void' pointer tarval. */
+extern tarval *tarval_P_void;
+/** Returns the 'void' pointer tarval. */
+tarval *get_tarval_P_void(void);
+
+/* These functions calculate and return a tarval representing the requested
+ * value.
+ * The functions get_mode_{Max,Min,...} return tarvals retrieved from these
+ * functions, but these are stored on initialization of the irmode module and
+ * therefore the irmode functions should be prefered to the functions below. */
+
+/** Returns the maximum value of a given mode. */
+tarval *get_tarval_max(ir_mode *mode);
+
+/** Returns the minimum value of a given mode. */
+tarval *get_tarval_min(ir_mode *mode);
+
+/** Returns the 0 value (additive neutral) of a given mode. */
+tarval *get_tarval_null(ir_mode *mode);
+
+/** Returns the 1 value (multiplicative neutral) of a given mode. */
+tarval *get_tarval_one(ir_mode *mode);
+
+/** Return quite nan for float_number modes. */
+tarval *get_tarval_nan(ir_mode *mode);
+
+/** Return +inf for float_number modes. */
+tarval *get_tarval_inf(ir_mode *mode);