X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=isl_input.c;h=164a269f3b1d7283e8612a0f5c804e4745be5a06;hb=63fb8a7f484648c3caa25351c8c94ac2395ec563;hp=bf39f4436560cf954bd34e8b7937e576e773e5ee;hpb=187bc82742fb71a0b5bb8d3b39f4748f2c8f62b9;p=platform%2Fupstream%2Fisl.git

diff --git a/isl_input.c b/isl_input.c
index bf39f44..164a269 100644
--- a/isl_input.c
+++ b/isl_input.c
@@ -26,6 +26,7 @@
 #include <isl_mat_private.h>
 #include <isl_aff_private.h>
 #include <isl/list.h>
+#include <isl_val_private.h>
 
 struct variable {
 	char    	    	*name;
@@ -168,6 +169,86 @@ error:
 	return NULL;
 }
 
+/* Read an isl_val from "s".
+ *
+ * The following token sequences are recognized
+ *
+ *	"infty"		->	infty
+ *	"-" "infty"	->	-infty
+ *	"NaN"		->	NaN
+ *	n "/" d		->	n/d
+ *	v		->	v
+ *
+ * where n, d and v are integer constants.
+ */
+__isl_give isl_val *isl_stream_read_val(struct isl_stream *s)
+{
+	struct isl_token *tok = NULL;
+	struct isl_token *tok2 = NULL;
+	isl_val *val;
+
+	tok = next_token(s);
+	if (!tok) {
+		isl_stream_error(s, NULL, "unexpected EOF");
+		goto error;
+	}
+	if (tok->type == ISL_TOKEN_INFTY) {
+		isl_token_free(tok);
+		return isl_val_infty(s->ctx);
+	}
+	if (tok->type == '-' &&
+	    isl_stream_eat_if_available(s, ISL_TOKEN_INFTY)) {
+		isl_token_free(tok);
+		return isl_val_neginfty(s->ctx);
+	}
+	if (tok->type == ISL_TOKEN_NAN) {
+		isl_token_free(tok);
+		return isl_val_nan(s->ctx);
+	}
+	if (tok->type != ISL_TOKEN_VALUE) {
+		isl_stream_error(s, tok, "expecting value");
+		goto error;
+	}
+
+	if (isl_stream_eat_if_available(s, '/')) {
+		tok2 = next_token(s);
+		if (!tok2) {
+			isl_stream_error(s, NULL, "unexpected EOF");
+			goto error;
+		}
+		if (tok2->type != ISL_TOKEN_VALUE) {
+			isl_stream_error(s, tok2, "expecting value");
+			goto error;
+		}
+		val = isl_val_rat_from_isl_int(s->ctx, tok->u.v, tok2->u.v);
+		val = isl_val_normalize(val);
+	} else {
+		val = isl_val_int_from_isl_int(s->ctx, tok->u.v);
+	}
+
+	isl_token_free(tok);
+	isl_token_free(tok2);
+	return val;
+error:
+	isl_token_free(tok);
+	isl_token_free(tok2);
+	return NULL;
+}
+
+/* Read an isl_val from "str".
+ */
+struct isl_val *isl_val_read_from_str(struct isl_ctx *ctx,
+	const char *str)
+{
+	isl_val *val;
+	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	if (!s)
+		return NULL;
+	val = isl_stream_read_val(s);
+	isl_stream_free(s);
+	return val;
+}
+
 static int accept_cst_factor(struct isl_stream *s, isl_int *f)
 {
 	struct isl_token *tok;
@@ -343,6 +424,7 @@ static __isl_give isl_pw_aff *accept_affine_factor(struct isl_stream *s,
 		if (pos < 0)
 			goto error;
 		if (pos >= n) {
+			vars_drop(v, v->n - n);
 			isl_stream_error(s, tok, "unknown identifier");
 			goto error;
 		}
@@ -549,14 +631,14 @@ static int is_comparator(struct isl_token *tok)
 }
 
 static struct isl_map *read_disjuncts(struct isl_stream *s,
-	struct vars *v, __isl_take isl_map *map);
+	struct vars *v, __isl_take isl_map *map, int rational);
 static __isl_give isl_pw_aff *accept_extended_affine(struct isl_stream *s,
-	__isl_take isl_space *dim, struct vars *v);
+	__isl_take isl_space *dim, struct vars *v, int rational);
 
 /* Accept a ternary operator, given the first argument.
  */
 static __isl_give isl_pw_aff *accept_ternary(struct isl_stream *s,
-	__isl_take isl_map *cond, struct vars *v)
+	__isl_take isl_map *cond, struct vars *v, int rational)
 {
 	isl_space *dim;
 	isl_pw_aff *pwaff1 = NULL, *pwaff2 = NULL, *pa_cond;
@@ -568,7 +650,7 @@ static __isl_give isl_pw_aff *accept_ternary(struct isl_stream *s,
 		goto error;
 
 	dim = isl_space_wrap(isl_map_get_space(cond));
-	pwaff1 = accept_extended_affine(s, dim, v);
+	pwaff1 = accept_extended_affine(s, dim, v, rational);
 	if (!pwaff1)
 		goto error;
 
@@ -576,7 +658,7 @@ static __isl_give isl_pw_aff *accept_ternary(struct isl_stream *s,
 		goto error;
 
 	dim = isl_pw_aff_get_domain_space(pwaff1);
-	pwaff2 = accept_extended_affine(s, dim, v);
+	pwaff2 = accept_extended_affine(s, dim, v, rational);
 	if (!pwaff1)
 		goto error;
 
@@ -596,7 +678,7 @@ error:
  * argument of a ternary operator and try to parse that.
  */
 static __isl_give isl_pw_aff *accept_extended_affine(struct isl_stream *s,
-	__isl_take isl_space *dim, struct vars *v)
+	__isl_take isl_space *dim, struct vars *v, int rational)
 {
 	isl_space *space;
 	isl_map *cond;
@@ -613,6 +695,8 @@ static __isl_give isl_pw_aff *accept_extended_affine(struct isl_stream *s,
 	}
 
 	pwaff = accept_affine(s, dim, v);
+	if (rational)
+		pwaff = isl_pw_aff_set_rational(pwaff);
 	if (!pwaff)
 		return NULL;
 
@@ -636,13 +720,14 @@ static __isl_give isl_pw_aff *accept_extended_affine(struct isl_stream *s,
 
 	isl_stream_push_token(s, tok);
 
-	cond = read_disjuncts(s, v, cond);
+	cond = read_disjuncts(s, v, cond, rational);
 
-	return accept_ternary(s, cond, v);
+	return accept_ternary(s, cond, v, rational);
 }
 
 static __isl_give isl_map *read_var_def(struct isl_stream *s,
-	__isl_take isl_map *map, enum isl_dim_type type, struct vars *v)
+	__isl_take isl_map *map, enum isl_dim_type type, struct vars *v,
+	int rational)
 {
 	isl_pw_aff *def;
 	int pos;
@@ -658,7 +743,8 @@ static __isl_give isl_map *read_var_def(struct isl_stream *s,
 	}
 	--pos;
 
-	def = accept_extended_affine(s, isl_space_wrap(isl_map_get_space(map)), v);
+	def = accept_extended_affine(s, isl_space_wrap(isl_map_get_space(map)),
+					v, rational);
 	def_map = isl_map_from_pw_aff(def);
 	def_map = isl_map_equate(def_map, type, pos, isl_dim_out, 0);
 	def_map = isl_set_unwrap(isl_map_domain(def_map));
@@ -696,7 +782,7 @@ static __isl_give isl_pw_aff_list *accept_affine_list(struct isl_stream *s,
 		list = isl_pw_aff_list_concat(list,
 				isl_pw_aff_list_from_pw_aff(pwaff));
 		if (!list)
-			return NULL;
+			goto error;
 	}
 
 	isl_space_free(dim);
@@ -708,7 +794,7 @@ error:
 }
 
 static __isl_give isl_map *read_defined_var_list(struct isl_stream *s,
-	struct vars *v, __isl_take isl_map *map)
+	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	struct isl_token *tok;
 
@@ -733,7 +819,7 @@ static __isl_give isl_map *read_defined_var_list(struct isl_stream *s,
 		tok = isl_stream_next_token(s);
 		if (tok && tok->type == '=') {
 			isl_token_free(tok);
-			map = read_var_def(s, map, isl_dim_out, v);
+			map = read_var_def(s, map, isl_dim_out, v, rational);
 			tok = isl_stream_next_token(s);
 		}
 
@@ -892,13 +978,14 @@ static __isl_give isl_multi_pw_aff *tuple_set_dim_name(
  * to "tuple".
  */
 static __isl_give isl_multi_pw_aff *read_tuple_var_def(struct isl_stream *s,
-	__isl_take isl_multi_pw_aff *tuple, int pos, struct vars *v)
+	__isl_take isl_multi_pw_aff *tuple, int pos, struct vars *v,
+	int rational)
 {
 	isl_space *space;
 	isl_pw_aff *def;
 
 	space = isl_space_wrap(isl_space_alloc(s->ctx, 0, v->n, 0));
-	def = accept_extended_affine(s, space, v);
+	def = accept_extended_affine(s, space, v, rational);
 	space = isl_space_set_alloc(s->ctx, 0, v->n);
 	def = isl_pw_aff_reset_domain_space(def, space);
 	tuple = isl_multi_pw_aff_set_pw_aff(tuple, pos, def);
@@ -909,9 +996,10 @@ static __isl_give isl_multi_pw_aff *read_tuple_var_def(struct isl_stream *s,
 /* Read a list of variables and/or affine expressions and return the list
  * as an isl_multi_pw_aff.
  * The elements in the list are separated by either "," or "][".
+ * If "comma" is set then only "," is allowed.
  */
 static __isl_give isl_multi_pw_aff *read_tuple_var_list(struct isl_stream *s,
-	struct vars *v)
+	struct vars *v, int rational, int comma)
 {
 	int i = 0;
 	struct isl_token *tok;
@@ -935,21 +1023,26 @@ static __isl_give isl_multi_pw_aff *read_tuple_var_list(struct isl_stream *s,
 			new_name = p >= n;
 		}
 
-		if (new_name) {
+		if (tok->type == '*') {
+			if (vars_add_anon(v) < 0)
+				goto error;
+			isl_token_free(tok);
+		} else if (new_name) {
 			res = tuple_set_dim_name(res, i, v->v->name);
 			isl_token_free(tok);
 			if (isl_stream_eat_if_available(s, '='))
-				res = read_tuple_var_def(s, res, i, v);
+				res = read_tuple_var_def(s, res, i, v,
+							rational);
 		} else {
 			isl_stream_push_token(s, tok);
 			tok = NULL;
 			if (vars_add_anon(v) < 0)
 				goto error;
-			res = read_tuple_var_def(s, res, i, v);
+			res = read_tuple_var_def(s, res, i, v, rational);
 		}
 
 		tok = isl_stream_next_token(s);
-		if (tok && tok->type == ']' &&
+		if (!comma && tok && tok->type == ']' &&
 		    isl_stream_next_token_is(s, '[')) {
 			isl_token_free(tok);
 			tok = isl_stream_next_token(s);
@@ -971,7 +1064,7 @@ error:
 /* Read a tuple and represent it as an isl_multi_pw_aff.  See tuple_alloc.
  */
 static __isl_give isl_multi_pw_aff *read_tuple(struct isl_stream *s,
-	struct vars *v)
+	struct vars *v, int rational, int comma)
 {
 	struct isl_token *tok;
 	char *name = NULL;
@@ -992,15 +1085,15 @@ static __isl_give isl_multi_pw_aff *read_tuple(struct isl_stream *s,
 	if (next_is_tuple(s)) {
 		isl_multi_pw_aff *out;
 		int n;
-		res = read_tuple(s, v);
+		res = read_tuple(s, v, rational, comma);
 		if (isl_stream_eat(s, ISL_TOKEN_TO))
 			goto error;
-		out = read_tuple(s, v);
+		out = read_tuple(s, v, rational, comma);
 		n = isl_multi_pw_aff_dim(out, isl_dim_out);
 		res = isl_multi_pw_aff_add_dims(res, isl_dim_in, n);
 		res = isl_multi_pw_aff_range_product(res, out);
 	} else
-		res = read_tuple_var_list(s, v);
+		res = read_tuple_var_list(s, v, rational, comma);
 	if (isl_stream_eat(s, ']'))
 		goto error;
 
@@ -1023,18 +1116,21 @@ error:
  * however, so we first need to reset the space to that of "map".
  */
 static __isl_give isl_map *read_map_tuple(struct isl_stream *s,
-	__isl_take isl_map *map, enum isl_dim_type type, struct vars *v)
+	__isl_take isl_map *map, enum isl_dim_type type, struct vars *v,
+	int rational, int comma)
 {
 	int i, n;
 	isl_multi_pw_aff *tuple;
 	isl_space *space = NULL;
 
-	tuple = read_tuple(s, v);
+	tuple = read_tuple(s, v, rational, comma);
 	if (!tuple)
 		goto error;
 
 	n = isl_multi_pw_aff_dim(tuple, isl_dim_out);
 	space = isl_space_range(isl_multi_pw_aff_get_space(tuple));
+	if (!space)
+		goto error;
 
 	if (type == isl_dim_param) {
 		if (isl_space_has_tuple_name(space, isl_dim_set) ||
@@ -1057,12 +1153,16 @@ static __isl_give isl_map *read_map_tuple(struct isl_stream *s,
 		isl_set *set;
 
 		set = isl_set_universe(isl_space_copy(space));
+		if (rational)
+			set = isl_set_set_rational(set);
 		set = isl_set_intersect_params(set, isl_map_params(map));
 		map = isl_map_from_domain(set);
 	} else {
 		isl_set *set;
 
 		set = isl_set_universe(isl_space_copy(space));
+		if (rational)
+			set = isl_set_set_rational(set);
 		map = isl_map_from_domain_and_range(isl_map_domain(map), set);
 	}
 
@@ -1079,6 +1179,8 @@ static __isl_give isl_map *read_map_tuple(struct isl_stream *s,
 		aff = isl_aff_add_coefficient_si(aff,
 						isl_dim_in, v->n - n + i, -1);
 		pa = isl_pw_aff_add(pa, isl_pw_aff_from_aff(aff));
+		if (rational)
+			pa = isl_pw_aff_set_rational(pa);
 		set = isl_pw_aff_zero_set(pa);
 		map_i = isl_map_from_range(set);
 		map_i = isl_map_reset_space(map_i, isl_map_get_space(map));
@@ -1097,34 +1199,35 @@ error:
 
 static __isl_give isl_set *construct_constraints(
 	__isl_take isl_set *set, int type,
-	__isl_keep isl_pw_aff_list *left, __isl_keep isl_pw_aff_list *right)
+	__isl_keep isl_pw_aff_list *left, __isl_keep isl_pw_aff_list *right,
+	int rational)
 {
 	isl_set *cond;
 
+	left = isl_pw_aff_list_copy(left);
+	right = isl_pw_aff_list_copy(right);
+	if (rational) {
+		left = isl_pw_aff_list_set_rational(left);
+		right = isl_pw_aff_list_set_rational(right);
+	}
 	if (type == ISL_TOKEN_LE)
-		cond = isl_pw_aff_list_le_set(isl_pw_aff_list_copy(left),
-					      isl_pw_aff_list_copy(right));
+		cond = isl_pw_aff_list_le_set(left, right);
 	else if (type == ISL_TOKEN_GE)
-		cond = isl_pw_aff_list_ge_set(isl_pw_aff_list_copy(left),
-					      isl_pw_aff_list_copy(right));
+		cond = isl_pw_aff_list_ge_set(left, right);
 	else if (type == ISL_TOKEN_LT)
-		cond = isl_pw_aff_list_lt_set(isl_pw_aff_list_copy(left),
-					      isl_pw_aff_list_copy(right));
+		cond = isl_pw_aff_list_lt_set(left, right);
 	else if (type == ISL_TOKEN_GT)
-		cond = isl_pw_aff_list_gt_set(isl_pw_aff_list_copy(left),
-					      isl_pw_aff_list_copy(right));
+		cond = isl_pw_aff_list_gt_set(left, right);
 	else if (type == ISL_TOKEN_NE)
-		cond = isl_pw_aff_list_ne_set(isl_pw_aff_list_copy(left),
-					      isl_pw_aff_list_copy(right));
+		cond = isl_pw_aff_list_ne_set(left, right);
 	else
-		cond = isl_pw_aff_list_eq_set(isl_pw_aff_list_copy(left),
-					      isl_pw_aff_list_copy(right));
+		cond = isl_pw_aff_list_eq_set(left, right);
 
 	return isl_set_intersect(set, cond);
 }
 
 static __isl_give isl_map *add_constraint(struct isl_stream *s,
-	struct vars *v, __isl_take isl_map *map)
+	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	struct isl_token *tok = NULL;
 	isl_pw_aff_list *list1 = NULL, *list2 = NULL;
@@ -1147,7 +1250,8 @@ static __isl_give isl_map *add_constraint(struct isl_stream *s,
 		if (!list2)
 			goto error;
 
-		set = construct_constraints(set, tok->type, list1, list2);
+		set = construct_constraints(set, tok->type, list1, list2,
+						rational);
 		isl_token_free(tok);
 		isl_pw_aff_list_free(list1);
 		list1 = list2;
@@ -1172,18 +1276,18 @@ error:
 }
 
 static __isl_give isl_map *read_exists(struct isl_stream *s,
-	struct vars *v, __isl_take isl_map *map)
+	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	int n = v->n;
 	int seen_paren = isl_stream_eat_if_available(s, '(');
 
 	map = isl_map_from_domain(isl_map_wrap(map));
-	map = read_defined_var_list(s, v, map);
+	map = read_defined_var_list(s, v, map, rational);
 
 	if (isl_stream_eat(s, ':'))
 		goto error;
 
-	map = read_disjuncts(s, v, map);
+	map = read_disjuncts(s, v, map, rational);
 	map = isl_set_unwrap(isl_map_domain(map));
 
 	vars_drop(v, v->n - n);
@@ -1212,7 +1316,7 @@ error:
  * start of a condition and continue parsing.
  */
 static int resolve_paren_expr(struct isl_stream *s,
-	struct vars *v, __isl_take isl_map *map)
+	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	struct isl_token *tok, *tok2;
 	int line, col;
@@ -1223,7 +1327,7 @@ static int resolve_paren_expr(struct isl_stream *s,
 		goto error;
 
 	if (isl_stream_next_token_is(s, '('))
-		if (resolve_paren_expr(s, v, isl_map_copy(map)))
+		if (resolve_paren_expr(s, v, isl_map_copy(map), rational))
 			goto error;
 
 	if (isl_stream_next_token_is(s, ISL_TOKEN_EXISTS) ||
@@ -1231,7 +1335,7 @@ static int resolve_paren_expr(struct isl_stream *s,
 	    isl_stream_next_token_is(s, ISL_TOKEN_TRUE) ||
 	    isl_stream_next_token_is(s, ISL_TOKEN_FALSE) ||
 	    isl_stream_next_token_is(s, ISL_TOKEN_MAP)) {
-		map = read_disjuncts(s, v, map);
+		map = read_disjuncts(s, v, map, rational);
 		if (isl_stream_eat(s, ')'))
 			goto error;
 		tok->type = ISL_TOKEN_MAP;
@@ -1266,7 +1370,7 @@ static int resolve_paren_expr(struct isl_stream *s,
 
 	isl_stream_push_token(s, tok2);
 
-	map = read_disjuncts(s, v, map);
+	map = read_disjuncts(s, v, map, rational);
 	if (isl_stream_eat(s, ')'))
 		goto error;
 
@@ -1284,10 +1388,10 @@ error:
 }
 
 static __isl_give isl_map *read_conjunct(struct isl_stream *s,
-	struct vars *v, __isl_take isl_map *map)
+	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	if (isl_stream_next_token_is(s, '('))
-		if (resolve_paren_expr(s, v, isl_map_copy(map)))
+		if (resolve_paren_expr(s, v, isl_map_copy(map), rational))
 			goto error;
 
 	if (isl_stream_next_token_is(s, ISL_TOKEN_MAP)) {
@@ -1302,7 +1406,7 @@ static __isl_give isl_map *read_conjunct(struct isl_stream *s,
 	}
 
 	if (isl_stream_eat_if_available(s, ISL_TOKEN_EXISTS))
-		return read_exists(s, v, map);
+		return read_exists(s, v, map, rational);
 
 	if (isl_stream_eat_if_available(s, ISL_TOKEN_TRUE))
 		return map;
@@ -1313,28 +1417,28 @@ static __isl_give isl_map *read_conjunct(struct isl_stream *s,
 		return isl_map_empty(dim);
 	}
 		
-	return add_constraint(s, v, map);
+	return add_constraint(s, v, map, rational);
 error:
 	isl_map_free(map);
 	return NULL;
 }
 
 static __isl_give isl_map *read_conjuncts(struct isl_stream *s,
-	struct vars *v, __isl_take isl_map *map)
+	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	isl_map *res;
 	int negate;
 
 	negate = isl_stream_eat_if_available(s, ISL_TOKEN_NOT);
-	res = read_conjunct(s, v, isl_map_copy(map));
+	res = read_conjunct(s, v, isl_map_copy(map), rational);
 	if (negate)
 		res = isl_map_subtract(isl_map_copy(map), res);
 
-	while (isl_stream_eat_if_available(s, ISL_TOKEN_AND)) {
+	while (res && isl_stream_eat_if_available(s, ISL_TOKEN_AND)) {
 		isl_map *res_i;
 
 		negate = isl_stream_eat_if_available(s, ISL_TOKEN_NOT);
-		res_i = read_conjunct(s, v, isl_map_copy(map));
+		res_i = read_conjunct(s, v, isl_map_copy(map), rational);
 		if (negate)
 			res = isl_map_subtract(res, res_i);
 		else
@@ -1346,7 +1450,7 @@ static __isl_give isl_map *read_conjuncts(struct isl_stream *s,
 }
 
 static struct isl_map *read_disjuncts(struct isl_stream *s,
-	struct vars *v, __isl_take isl_map *map)
+	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	isl_map *res;
 
@@ -1356,11 +1460,11 @@ static struct isl_map *read_disjuncts(struct isl_stream *s,
 		return isl_map_universe(dim);
 	}
 
-	res = read_conjuncts(s, v, isl_map_copy(map));
+	res = read_conjuncts(s, v, isl_map_copy(map), rational);
 	while (isl_stream_eat_if_available(s, ISL_TOKEN_OR)) {
 		isl_map *res_i;
 
-		res_i = read_conjuncts(s, v, isl_map_copy(map));
+		res_i = read_conjuncts(s, v, isl_map_copy(map), rational);
 		res = isl_map_union(res, res_i);
 	}
 
@@ -1667,8 +1771,9 @@ static __isl_give isl_pw_qpolynomial *read_factor(struct isl_stream *s,
 		pwqp = isl_pw_qpolynomial_pow(pwqp, pow);
 	} else if (tok->type == ISL_TOKEN_VALUE) {
 		struct isl_token *tok2;
-		tok2 = isl_stream_next_token(s);
 		isl_qpolynomial *qp;
+
+		tok2 = isl_stream_next_token(s);
 		if (tok2 && tok2->type == '/') {
 			isl_token_free(tok2);
 			tok2 = next_token(s);
@@ -1792,7 +1897,7 @@ static __isl_give isl_pw_qpolynomial *read_term(struct isl_stream *s,
 }
 
 static __isl_give isl_map *read_optional_disjuncts(struct isl_stream *s,
-	__isl_take isl_map *map, struct vars *v)
+	__isl_take isl_map *map, struct vars *v, int rational)
 {
 	struct isl_token *tok;
 
@@ -1804,7 +1909,7 @@ static __isl_give isl_map *read_optional_disjuncts(struct isl_stream *s,
 	if (tok->type == ':' ||
 	    (tok->type == ISL_TOKEN_OR && !strcmp(tok->u.s, "|"))) {
 		isl_token_free(tok);
-		map = read_disjuncts(s, v, map);
+		map = read_disjuncts(s, v, map, rational);
 	} else
 		isl_stream_push_token(s, tok);
 
@@ -1822,7 +1927,7 @@ static struct isl_obj obj_read_poly(struct isl_stream *s,
 	struct isl_set *set;
 
 	pwqp = read_term(s, map, v);
-	map = read_optional_disjuncts(s, map, v);
+	map = read_optional_disjuncts(s, map, v, 0);
 	set = isl_map_range(map);
 
 	pwqp = isl_pw_qpolynomial_intersect_domain(pwqp, set);
@@ -1860,7 +1965,7 @@ static struct isl_obj obj_read_poly_or_fold(struct isl_stream *s,
 	if (isl_stream_eat(s, ')'))
 		goto error;
 
-	set = read_optional_disjuncts(s, set, v);
+	set = read_optional_disjuncts(s, set, v, 0);
 	pwf = isl_pw_qpolynomial_fold_intersect_domain(pwf, set);
 
 	vars_drop(v, v->n - n);
@@ -1898,20 +2003,22 @@ static struct isl_obj obj_read_body(struct isl_stream *s,
 	struct isl_token *tok;
 	struct isl_obj obj = { isl_obj_set, NULL };
 	int n = v->n;
+	int rational;
 
-	if (is_rational(s))
+	rational = is_rational(s);
+	if (rational)
 		map = isl_map_set_rational(map);
 
 	if (isl_stream_next_token_is(s, ':')) {
 		obj.type = isl_obj_set;
-		obj.v = read_optional_disjuncts(s, map, v);
+		obj.v = read_optional_disjuncts(s, map, v, rational);
 		return obj;
 	}
 
 	if (!next_is_tuple(s))
 		return obj_read_poly_or_fold(s, map, v, n);
 
-	map = read_map_tuple(s, map, isl_dim_in, v);
+	map = read_map_tuple(s, map, isl_dim_in, v, rational, 0);
 	if (!map)
 		goto error;
 	tok = isl_stream_next_token(s);
@@ -1924,7 +2031,7 @@ static struct isl_obj obj_read_body(struct isl_stream *s,
 			isl_set *set = isl_map_domain(map);
 			return obj_read_poly_or_fold(s, set, v, n);
 		}
-		map = read_map_tuple(s, map, isl_dim_out, v);
+		map = read_map_tuple(s, map, isl_dim_out, v, rational, 0);
 		if (!map)
 			goto error;
 	} else {
@@ -1932,7 +2039,7 @@ static struct isl_obj obj_read_body(struct isl_stream *s,
 		isl_stream_push_token(s, tok);
 	}
 
-	map = read_optional_disjuncts(s, map, v);
+	map = read_optional_disjuncts(s, map, v, rational);
 
 	vars_drop(v, v->n - n);
 
@@ -2066,7 +2173,7 @@ static struct isl_obj obj_read(struct isl_stream *s)
 	map = isl_map_universe(isl_space_params_alloc(s->ctx, 0));
 	if (tok->type == '[') {
 		isl_stream_push_token(s, tok);
-		map = read_map_tuple(s, map, isl_dim_param, v);
+		map = read_map_tuple(s, map, isl_dim_param, v, 0, 0);
 		if (!map)
 			goto error;
 		tok = isl_stream_next_token(s);
@@ -2094,7 +2201,7 @@ static struct isl_obj obj_read(struct isl_stream *s)
 		isl_token_free(tok);
 		if (isl_stream_eat(s, '='))
 			goto error;
-		map = read_map_tuple(s, map, isl_dim_param, v);
+		map = read_map_tuple(s, map, isl_dim_param, v, 0, 1);
 		if (!map)
 			goto error;
 	} else if (tok->type == '}') {
@@ -2511,57 +2618,6 @@ __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_read_from_file(isl_ctx *ctx,
 	return pwqp;
 }
 
-/* Read an affine expression from "s" with domain (space) "dom".
- * We call accept_affine to parse a possibly piecewise affine expression
- * and then check that the result is a single affine expression on
- * a universe domain.
- */
-static __isl_give isl_aff *read_aff_with_dom(struct isl_stream *s,
-	__isl_take isl_set *dom, struct vars *v)
-{
-	isl_aff *aff = NULL;
-	isl_pw_aff *pwaff = NULL;
-
-	if (!isl_set_plain_is_universe(dom))
-		isl_die(s->ctx, isl_error_invalid,
-			"expecting universe domain", goto error);
-
-	if (!isl_set_is_params(dom) && isl_stream_eat(s, ISL_TOKEN_TO))
-		goto error;
-
-	if (isl_stream_eat(s, '['))
-		goto error;
-
-	pwaff = accept_affine(s, isl_set_get_space(dom), v);
-
-	if (isl_stream_eat(s, ']'))
-		goto error;
-	if (isl_stream_eat(s, '}'))
-		goto error;
-
-	if (!pwaff)
-		goto error;
-
-	if (pwaff->n != 1)
-		isl_die(s->ctx, isl_error_invalid,
-			"expecting single affine expression", goto error);
-	if (!isl_set_plain_is_universe(pwaff->p[0].set))
-		isl_die(s->ctx, isl_error_invalid,
-			"expecting universe domain", goto error);
-
-	aff = isl_aff_copy(pwaff->p[0].aff);
-
-	vars_free(v);
-	isl_pw_aff_free(pwaff);
-	isl_set_free(dom);
-	return aff;
-error:
-	vars_free(v);
-	isl_pw_aff_free(pwaff);
-	isl_set_free(dom);
-	return NULL;
-}
-
 /* Is the next token an identifer not in "v"?
  */
 static int next_is_fresh_ident(struct isl_stream *s, struct vars *v)
@@ -2599,7 +2655,7 @@ static __isl_give isl_set *read_aff_domain(struct isl_stream *s,
 	tok = isl_stream_next_token(s);
 	if (tok && (tok->type == ISL_TOKEN_IDENT || tok->is_keyword)) {
 		isl_stream_push_token(s, tok);
-		return read_map_tuple(s, dom, isl_dim_set, v);
+		return read_map_tuple(s, dom, isl_dim_set, v, 1, 0);
 	}
 	if (!tok || tok->type != '[') {
 		isl_stream_error(s, tok, "expecting '['");
@@ -2607,7 +2663,7 @@ static __isl_give isl_set *read_aff_domain(struct isl_stream *s,
 	}
 	if (next_is_tuple(s) || next_is_fresh_ident(s, v)) {
 		isl_stream_push_token(s, tok);
-		dom = read_map_tuple(s, dom, isl_dim_set, v);
+		dom = read_map_tuple(s, dom, isl_dim_set, v, 1, 0);
 	} else
 		isl_stream_push_token(s, tok);
 
@@ -2615,38 +2671,30 @@ static __isl_give isl_set *read_aff_domain(struct isl_stream *s,
 error:
 	if (tok)
 		isl_stream_push_token(s, tok);
-	vars_free(v);
 	isl_set_free(dom);
 	return NULL;
 }
 
 /* Read an affine expression from "s".
- * We first read the domain of the affine expression, which may be
- * a parameter space or a set, and then call read_aff_with_dom.
  */
 __isl_give isl_aff *isl_stream_read_aff(struct isl_stream *s)
 {
-	struct vars *v;
-	isl_set *dom = NULL;
+	isl_aff *aff;
+	isl_multi_aff *ma;
 
-	v = vars_new(s->ctx);
-	if (!v)
+	ma = isl_stream_read_multi_aff(s);
+	if (!ma)
 		return NULL;
+	if (isl_multi_aff_dim(ma, isl_dim_out) != 1)
+		isl_die(s->ctx, isl_error_invalid,
+			"expecting single affine expression",
+			goto error);
 
-	dom = isl_set_universe(isl_space_params_alloc(s->ctx, 0));
-	if (next_is_tuple(s)) {
-		dom = read_map_tuple(s, dom, isl_dim_param, v);
-		if (isl_stream_eat(s, ISL_TOKEN_TO))
-			goto error;
-	}
-	if (isl_stream_eat(s, '{'))
-		goto error;
-
-	dom = read_aff_domain(s, dom, v);
-	return read_aff_with_dom(s, dom, v);
+	aff = isl_multi_aff_get_aff(ma, 0);
+	isl_multi_aff_free(ma);
+	return aff;
 error:
-	vars_free(v);
-	isl_set_free(dom);
+	isl_multi_aff_free(ma);
 	return NULL;
 }
 
@@ -2668,7 +2716,7 @@ static __isl_give isl_pw_aff *read_pw_aff_with_dom(struct isl_stream *s,
 	if (isl_stream_eat(s, ']'))
 		goto error;
 
-	dom = read_optional_disjuncts(s, dom, v);
+	dom = read_optional_disjuncts(s, dom, v, 0);
 	pwaff = isl_pw_aff_intersect_domain(pwaff, dom);
 
 	return pwaff;
@@ -2692,7 +2740,7 @@ __isl_give isl_pw_aff *isl_stream_read_pw_aff(struct isl_stream *s)
 
 	dom = isl_set_universe(isl_space_params_alloc(s->ctx, 0));
 	if (next_is_tuple(s)) {
-		dom = read_map_tuple(s, dom, isl_dim_param, v);
+		dom = read_map_tuple(s, dom, isl_dim_param, v, 1, 0);
 		if (isl_stream_eat(s, ISL_TOKEN_TO))
 			goto error;
 	}
@@ -2786,6 +2834,47 @@ __isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(isl_ctx *ctx,
 	return pma;
 }
 
+/* Read an isl_union_pw_multi_aff from "s".
+ * We currently read a generic object and if it turns out to be a set or
+ * a map, we convert that to an isl_union_pw_multi_aff.
+ * It would be more efficient if we were to construct
+ * the isl_union_pw_multi_aff directly.
+ */
+__isl_give isl_union_pw_multi_aff *isl_stream_read_union_pw_multi_aff(
+	struct isl_stream *s)
+{
+	struct isl_obj obj;
+
+	obj = obj_read(s);
+	if (!obj.v)
+		return NULL;
+
+	if (obj.type == isl_obj_map || obj.type == isl_obj_set)
+		obj = to_union(s->ctx, obj);
+	if (obj.type == isl_obj_union_map)
+		return isl_union_pw_multi_aff_from_union_map(obj.v);
+	if (obj.type == isl_obj_union_set)
+		return isl_union_pw_multi_aff_from_union_set(obj.v);
+
+	obj.type->free(obj.v);
+	isl_die(s->ctx, isl_error_invalid, "unexpected object type",
+		return NULL);
+}
+
+/* Read an isl_union_pw_multi_aff from "str".
+ */
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_read_from_str(
+	isl_ctx *ctx, const char *str)
+{
+	isl_union_pw_multi_aff *upma;
+	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	if (!s)
+		return NULL;
+	upma = isl_stream_read_union_pw_multi_aff(s);
+	isl_stream_free(s);
+	return upma;
+}
+
 /* Assuming "pa" represents a single affine expression defined on a universe
  * domain, extract this affine expression.
  */
@@ -2835,7 +2924,7 @@ __isl_give isl_multi_aff *isl_stream_read_multi_aff(struct isl_stream *s)
 
 	dom = isl_set_universe(isl_space_params_alloc(s->ctx, 0));
 	if (next_is_tuple(s)) {
-		dom = read_map_tuple(s, dom, isl_dim_param, v);
+		dom = read_map_tuple(s, dom, isl_dim_param, v, 1, 0);
 		if (isl_stream_eat(s, ISL_TOKEN_TO))
 			goto error;
 	}
@@ -2845,7 +2934,7 @@ __isl_give isl_multi_aff *isl_stream_read_multi_aff(struct isl_stream *s)
 	if (isl_stream_eat(s, '{'))
 		goto error;
 
-	tuple = read_tuple(s, v);
+	tuple = read_tuple(s, v, 0, 0);
 	if (!tuple)
 		goto error;
 	if (isl_stream_eat_if_available(s, ISL_TOKEN_TO)) {
@@ -2863,7 +2952,7 @@ __isl_give isl_multi_aff *isl_stream_read_multi_aff(struct isl_stream *s)
 		set = isl_set_universe(space);
 		dom = isl_set_intersect_params(set, dom);
 		isl_multi_pw_aff_free(tuple);
-		tuple = read_tuple(s, v);
+		tuple = read_tuple(s, v, 0, 0);
 		if (!tuple)
 			goto error;
 	}