First step towards generalizing NSC_TYPEID to arbitrary dictionaries.

(nsc_cat) New category NSC_ID.
(nstr_comp): Resolve identifiers instead of relying on nstr_comp_val()
and nstr_coerce_val().
(valstr, nstr_coerce_val): Remove valstr member val_as_type.
(nstr_parse_val, nstr_match_ca, nstr_match_val, nstr_resolve_id)
(nstr_resolve_sel, nstr_mkselval): New.
(nstr_comp_val): Rewrite using the above.

include/nsc.h

@@ -77,7 +77,8 @@ typedef char packed_nsc_type;
 typedef enum {
     NSC_NOCAT,
     NSC_VAL,			/* evaluated value */
-    NSC_OFF			/* symbolic value: at offset in object */
+    NSC_OFF,			/* symbolic value: at offset in object */
+    NSC_ID			/* unresolved identifier (internal use) */
 } nsc_cat;
 typedef char packed_nsc_cat;
 
@@ -95,13 +96,10 @@ typedef unsigned char nsc_flags;
  * value.
  * If category is NSC_VAL, the value is in val_as, and the type is a
  * promoted type.
- * Some values can also be interpreted as an object type.  The value's
- * consumer chooses how to interpret it, depending on context.
  */
 struct valstr {
     packed_nsc_type val_type;	/* type of value */
     packed_nsc_cat val_cat;	/* category of value */
-    signed char val_as_type;	/* value interpreted as object type */
     union {
 	struct {		/* cat NSC_OFF */
 	    ptrdiff_t off;
@@ -109,7 +107,7 @@ struct valstr {
 	    int idx;
 	} sym;
 	double dbl;		/* cat NSC_VAL, type NSC_DOUBLE */
-	struct {		/* cat NSC_VAL, type NSC_STRING */
+	struct {		/* cat NSC_VAL, type NSC_STRING, cat NSC_ID */
 	    char *base;
 	    size_t maxsz;
 	} str;

src/lib/commands/xdump.c

@@ -286,7 +286,6 @@ xdeval(struct valstr *val, nsc_type type, void *ptr, ptrdiff_t off, int idx)
 {
     val->val_type = type;
     val->val_cat = NSC_OFF;
-    val->val_as_type = -1;
     val->val_as.sym.off = off;
     val->val_as.sym.idx = idx;
     nstr_exec_val(val, player->cnum, ptr, NSC_NOTYPE);
@@ -457,7 +456,6 @@ xdchr(int chridx)
     for (p = cm->chr; ; p += cm->size) {
 	val.val_type = cm->ca[0].ca_type;
 	val.val_cat = NSC_OFF;
-	val.val_as_type = -1;
 	val.val_as.sym.off = cm->ca[0].ca_off;
 	val.val_as.sym.idx = 0;
 	nstr_exec_val(&val, player->cnum, p, NSC_STRING);

src/lib/subs/nstr.c

@@ -40,7 +40,14 @@
 #include "nsc.h"
 #include "prototypes.h"
 
-static int nstr_promote(int valtype);
+static char *nstr_parse_val(char *, struct valstr *);
+static int nstr_match_ca(struct valstr *, struct castr *);
+static int nstr_match_val(struct valstr *, int, struct castr *, int);
+static struct valstr *nstr_resolve_sel(struct valstr *, struct castr *);
+static struct valstr *nstr_mkselval(struct valstr *, int, struct castr *);
+static struct valstr *nstr_resolve_id(struct valstr *, struct castr *, int);
+static int nstr_promote(int);
+
 
 /*
  * Compile conditions into array NP[LEN].
@@ -53,10 +60,13 @@ static int nstr_promote(int valtype);
 int
 nstr_comp(struct nscstr *np, int len, int type, char *str)
 {
+    struct castr *ca = ef_cadef(type);
     char *cond;
     char *tail;
     int i;
     struct nscstr dummy;
+    int lft_caidx, rgt_caidx;
+    int lft_val, rgt_val;
     int lft_type, rgt_type;
 
     cond = str;
@@ -65,9 +75,8 @@ nstr_comp(struct nscstr *np, int len, int type, char *str)
 	    np = &dummy;
 
 	/* left operand */
-	tail = nstr_comp_val(cond, &np->lft, type);
+	tail = nstr_parse_val(cond, &np->lft);
-	if (!tail)
+	lft_caidx = nstr_match_ca(&np->lft, ca);
-	    return -1;
 
 	/* operator */
 	if (*tail != '<' && *tail != '=' && *tail != '>' && *tail != '#') {
@@ -81,9 +90,47 @@ nstr_comp(struct nscstr *np, int len, int type, char *str)
 	++tail;
 
 	/* right operand */
-	tail = nstr_comp_val(tail, &np->rgt, type);
+	tail = nstr_parse_val(tail, &np->rgt);
-	if (!tail)
+	rgt_caidx = nstr_match_ca(&np->rgt, ca);
+
+	/*
+	 * Resolve identifiers
+	 *
+	 * An identifier can name a selector or, if the other operand
+	 * is a selector, a value for that.  The condition is
+	 * ambiguous if both selector x value and value x selector are
+	 * possible.  Example: n<n for sectors could mean newdes<n or
+	 * n<newdes.
+	 */
+	lft_val = nstr_match_val(&np->lft, type, ca, rgt_caidx);
+	rgt_val = nstr_match_val(&np->rgt, type, ca, lft_caidx);
+	/*
+	 * if lft_val >= 0, then rhs names a selector and lhs names
+	 * one of its values.  Likewise for rgt_val.
+	 */
+	if (lft_val >= 0 && rgt_val >= 0) {
+	    pr("%.*s -- condition ambiguous\n", tail-cond, cond);
 	    return -1;
+	} else if (rgt_val >= 0) {
+	    /* selector x value */
+	    if (!nstr_resolve_sel(&np->lft, &ca[lft_caidx]))
+		return -1;
+	    nstr_mkselval(&np->rgt, rgt_val, &ca[lft_caidx]);
+	} else if (lft_val >= 0) {
+	    /* value x selector */
+	    nstr_mkselval(&np->lft, lft_val, &ca[rgt_caidx]);
+	    if (!nstr_resolve_sel(&np->rgt, &ca[rgt_caidx]))
+		return -1;
+	} else {
+	    /*
+	     * Neither side works as selector value; any identifiers
+	     * must name selectors.
+	     */
+	    if (!nstr_resolve_id(&np->lft, ca, lft_caidx))
+		return -1;
+	    if (!nstr_resolve_id(&np->rgt, ca, rgt_caidx))
+		return -1;
+	}
 
 	/* find operator type, coerce operands */
 	lft_type = nstr_promote(np->lft.val_type);
@@ -134,6 +181,7 @@ nstr_comp(struct nscstr *np, int len, int type, char *str)
     return i + 1;
 }
 
+/* Like strcmp(S1, S2), but limit length of S1 to SZ1 and of S2 to SZ2.  */
 static int
 strnncmp(char *s1, size_t sz1, char *s2, size_t sz2)
 {
@@ -198,89 +246,30 @@ nstr_exec(struct nscstr *np, int ncond, void *ptr)
 }
 
 /*
- * Compile a value in STR into VAL.
+ * Parse a value in STR into VAL.
- * Return a pointer to the first character after the value on success,
+ * Return a pointer to the first character after the value.
- * NULL on error.
+ * Value is either evaluated (but not NSC_TYPEID) or an identifier.
- * TYPE is the context type, a file type.
- * If STR names an array, VAL simply refers to the element with index
- * zero.
  */
-char *
+static char *
-nstr_comp_val(char *str, struct valstr*val, int type)
+nstr_parse_val(char *str, struct valstr *val)
 {
-    char id[32];
     long l;
     double d;
     char *tail, *tail2;
-    struct castr *cap;
-    unsigned i;
-    int j;
 
-    val->val_type = NSC_NOTYPE;
+    /* string */
-    val->val_cat = NSC_NOCAT;
+    if (str[0] == '\'') {
-    val->val_as_type = -1;
+	for (tail = str + 1; *tail && *tail != '\''; ++tail) ;
-
+	/* FIXME implement \ quoting */
-    if (isalpha(str[0])) {
+	val->val_type = NSC_STRING;
-	/* identifier */
-	for (i = 0; isalnum(str[i]) || str[i] == '_'; ++i) {
-	    if (i < sizeof(id) - 1)
-		id[i] = str[i];
-	}
-	tail = str + i;
-	if (i < sizeof(id)) {
-	    id[i] = 0;
-
-	    val->val_as_type = typematch(id, type);
-
-	    cap = ef_cadef(type);
-	    if (cap) {
-		j = stmtch(id, cap, offsetof(struct castr, ca_name),
-			   sizeof(struct castr));
-		if (j >= 0
-		    && (!(cap[j].ca_flags & NSC_DEITY) || player->god)) {
-		    if (cap[j].ca_type == NSC_TYPEID && val->val_as_type >= 0)
-			/*
-			 * Got two matches of type NSC_TYPEID, need to
-			 * choose.  Prefer typematch(), because ?des=n
-			 * would be interpreted as ?des=newdes
-			 * otherwise
-			 */
-			;
-		    else {
-			val->val_type = cap[j].ca_type;
-			val->val_cat = NSC_OFF;
-			val->val_as.sym.off = cap[j].ca_off;
-			val->val_as.sym.len = cap[j].ca_len;
-			val->val_as.sym.idx = 0;
-		    }
-		}
-	    } else
-		j = M_NOTFOUND;
-	} else
-	    j = M_NOTFOUND;
-
-	if (val->val_type == NSC_NOTYPE) {
-	    if (val->val_as_type >= 0) {
-		val->val_type = NSC_TYPEID;
 	val->val_cat = NSC_VAL;
-		val->val_as.lng = val->val_as_type;
+	val->val_as.str.base = str + 1;
-	    } else if (j >= 0)
+	val->val_as.str.maxsz = tail - (str + 1);
-		pr("%s -- selector access denied\n", id);
+	if (*tail) ++tail;
-	    else if (j == M_NOTUNIQUE)
+	return tail;
-		pr("%s -- ambiguous selector name\n", id);
-	    else
-		pr("%s -- unknown selector name\n", id);
     }
 
-	return val->val_type == NSC_NOTYPE ? NULL : tail;
+    /* number */
-    }
-
-    /* single character type */
-    id[0] = str[0];
-    id[1] = 0;
-    val->val_as_type = typematch(id, type);
-
-    /* literals */
     l = strtol(str, &tail, 0);
     d = strtod(str, &tail2);
     if (tail2 > tail) {
@@ -295,20 +284,165 @@ nstr_comp_val(char *str, struct valstr*val, int type)
 	val->val_as.lng = l;
 	return tail;
     }
-    /* FIXME implement NSC_STRING literals */
 
-    CANT_HAPPEN(val->val_type != NSC_NOTYPE);
+    /* identifier */
-    if (val->val_as_type >= 0) {
+    for (tail = str; isalnum(*tail) || *tail == '_'; ++tail) ;
-	val->val_type = NSC_TYPEID;
+    if (tail == str) ++tail;
-	val->val_cat = NSC_VAL;
+    val->val_type = NSC_NOTYPE;
-	val->val_as.lng = val->val_as_type;
+    val->val_cat = NSC_ID;
-	return str + 1;
+    val->val_as.str.base = str;
+    val->val_as.str.maxsz = tail - str;
+    return tail;
 }
 
-    pr("%s -- invalid value for condition\n", str);
+/*
+ * Match VAL in table of selector descriptors CA, return index.
+ * Return M_NOTFOUND if there are no matches, M_NOTUNIQUE if there are
+ * several.
+ * A VAL that is not an identifier doesn't match anything.  A null CA
+ * is considered empty.
+ */
+static int
+nstr_match_ca(struct valstr *val, struct castr *ca)
+{
+    char id[32];
+
+    if (val->val_cat != NSC_ID || val->val_as.str.maxsz >= sizeof(id))
+	return M_NOTFOUND;
+
+    if (!ca)
+	return M_NOTFOUND;
+
+    memcpy(id, val->val_as.str.base, val->val_as.str.maxsz);
+    id[val->val_as.str.maxsz] = 0;
+
+    return stmtch(id, ca, offsetof(struct castr, ca_name),
+		  sizeof(struct castr));
+}
+
+/*
+ * Match VAL in a selector's values, return its (non-negative) value.
+ * TYPE is the context type, a file type.
+ * CA is ef_cadef(TYPE).
+ * Match values of selector descriptor CA[IDX], provided CA is not
+ * null and IDX is not negative.
+ * Return M_NOTFOUND if there are no matches, M_NOTUNIQUE if there are
+ * several.
+ * TODO: This is just a stub and works only for NSC_TYPEID.
+ * Generalize: give struct castr enough info to find values, remove
+ * parameter `type'.
+ */
+static int
+nstr_match_val(struct valstr *val, int type, struct castr *ca, int idx)
+{
+    char id[32];
+
+    if (val->val_cat != NSC_ID || val->val_as.str.maxsz >= sizeof(id))
+	return M_NOTFOUND;
+
+    if (idx < 0 || ca[idx].ca_type != NSC_TYPEID)
+	return M_NOTFOUND;
+
+    memcpy(id, val->val_as.str.base, val->val_as.str.maxsz);
+    id[val->val_as.str.maxsz] = 0;
+
+    return typematch(id, type);
+}
+
+/*
+ * Change VAL to resolve identifier to selector or string.
+ * Return VAL on success, NULL on error.
+ * No change if VAL is not an identifier.
+ * Else error if IDX == M_NOTUNIQUE, string if IDX == M_NOTFOUND, and
+ * selector CA[IDX] otherwise.
+ */
+static struct valstr *
+nstr_resolve_id(struct valstr *val, struct castr *ca, int idx)
+{
+    if (val->val_cat != NSC_ID)
+	return val;
+
+    if (idx == M_NOTUNIQUE) {
+	pr("%.*s -- ambiguous name\n",
+	   val->val_as.str.maxsz, val->val_as.str.base);
+	val->val_cat = NSC_NOCAT;
 	return NULL;
     }
 
+    if (idx == M_NOTFOUND) {
+	/* interpret unbound identifier as string */
+	val->val_type = NSC_STRING;
+	val->val_cat = NSC_VAL;
+	return val;
+    }
+
+    return nstr_resolve_sel(val, &ca[idx]);
+}
+
+/*
+ * Change VAL to resolve identifier to selector CA.
+ * Return VAL on success, NULL if the player is denied access to the
+ * selector.
+ * VAL must be an identifier.
+ */
+static struct valstr *
+nstr_resolve_sel(struct valstr *val, struct castr *ca)
+{
+    if (CANT_HAPPEN(val->val_cat != NSC_ID)) {
+	val->val_cat = NSC_NOCAT;
+	return val;
+    }
+
+    if ((ca->ca_flags & NSC_DEITY) && !player->god) {
+	pr("%.*s -- not accessible to mortals\n",
+	   val->val_as.str.maxsz, val->val_as.str.base);
+	val->val_cat = NSC_NOCAT;
+	return NULL;
+    }
+
+    val->val_type = ca->ca_type;
+    val->val_cat = NSC_OFF;
+    val->val_as.sym.off = ca->ca_off;
+    val->val_as.sym.len = ca->ca_len;
+    val->val_as.sym.idx = 0;
+    return val;
+}
+
+/*
+ * Initialize VAL to value SELVAL for selector CA, return VAL.
+ */
+static struct valstr *
+nstr_mkselval(struct valstr *val, int selval, struct castr *ca)
+{
+    if (CANT_HAPPEN(ca->ca_type != NSC_TYPEID)) {
+	val->val_type = NSC_NOTYPE;
+	val->val_cat = NSC_NOCAT;
+	return val;
+    }
+
+    val->val_type = ca->ca_type;
+    val->val_cat = NSC_VAL;
+    val->val_as.lng = selval;
+    return val;
+}
+
+/*
+ * Compile a value in STR into VAL.
+ * Return a pointer to the first character after the value on success,
+ * NULL on error.
+ * TYPE is the context type, a file type.
+ * If STR names an array, VAL simply refers to the element with index
+ * zero.
+ */
+char *
+nstr_comp_val(char *str, struct valstr *val, int type)
+{
+    struct castr *ca = ef_cadef(type);
+    char *tail = nstr_parse_val(str, val);
+    return nstr_resolve_id(val, ca, nstr_match_ca(val, ca)) ? tail : NULL;
+}
+
+
 /*
  * Promote VALTYPE.
  * If VALTYPE is an integer type, return NSC_LONG.
@@ -376,12 +510,7 @@ nstr_coerce_val(struct valstr *val, nsc_type to, char *str)
     if (from != to) {
 	switch (to) {
 	case NSC_TYPEID:
-	    if (val->val_as_type >= 0) {
-		val->val_cat = NSC_VAL;
-		val->val_as.lng = val->val_as_type;
-	    } else
 	    return cond_type_mismatch(str);
-	    break;
 	case NSC_STRING:
 	    return cond_type_mismatch(str); /* FIXME implement */
 	case NSC_DOUBLE: