r5967 - in trunk/eda/fped: . test

werner at docs.openmoko.org werner at docs.openmoko.org
Sat May 29 23:13:49 CEST 2010


Author: werner
Date: 2010-05-29 23:13:48 +0200 (Sat, 29 May 2010)
New Revision: 5967

Added:
   trunk/eda/fped/bitset.c
   trunk/eda/fped/bitset.h
   trunk/eda/fped/test/dbg_meas
   trunk/eda/fped/test/meas_qual
Modified:
   trunk/eda/fped/Makefile
   trunk/eda/fped/README
   trunk/eda/fped/delete.c
   trunk/eda/fped/dump.c
   trunk/eda/fped/error.c
   trunk/eda/fped/error.h
   trunk/eda/fped/fpd.l
   trunk/eda/fped/fpd.y
   trunk/eda/fped/gui_meas.c
   trunk/eda/fped/inst.c
   trunk/eda/fped/inst.h
   trunk/eda/fped/meas.c
   trunk/eda/fped/meas.h
   trunk/eda/fped/obj.c
   trunk/eda/fped/obj.h
   trunk/eda/fped/test/Common
   trunk/eda/fped/test/del_frame
   trunk/eda/fped/test/del_vec
   trunk/eda/fped/test/structure
Log:
The mechanism for selecting points for measurements reaches its limits when
using frames to encapsulate building blocks, e.g., like macros or functions in
a programming language. Since measurements only know about the frame containing
a vector but not the frames containing that frame, invocations of this frame
from different places can only be distinguished within the min/next/max scheme.
(See the example in README.)

To eliminate this limitation, one needs a way to tell fped to consider a point
only if it has been instantiated through a certain path, e.g., by requiring
some other frames to be visited in its instantiation. This increases the number
of distinct points available for measurements.

The mechanism chosen is to qualify a measurement point with frames that lead to
it. This list of outer frames does not have to include all frames. Without
qualifying, the old behaviour results.

Note that this doesn't cover all possible ways in which a point can appear in
different roles. Multiple frame references can also result from repeating the
same frame reference in the same parent frame. The current qualification
mechanism does not allow such paths to be distinguished. However, one can 
always introduce intermediate frames for this purpose.

Furthermore, repetitions create multiple instances of a point, although in what
should be considered the same role.

- fpd.l: make scanner support free-format a little better by switching back to
  keyword mode after frame braces. This way, one can write a simple frame in a
  single line, which is useful for regression tests.
- fpd.l, fpd.y, README, test/dbg_meas: added %meas directive to print the 
  result of a measurement
- fpd.y, README: measurements can now be labeled. Note that, due to limitations
  of the grammar, the first measurement cannot be labeled.
- error.h, error.c (yywarn): new function for non-fatal diagnostics that always
  get reported to standard error
- bitset.h, bitset.c: functions to manipulate variable-size bit sets
- meas.h, fpd.y, README, test/meas_qual: added the means to specify qualifiers
  for points used in measurements
- dump.c (print_meas_base, print_meas): dump qualifiers
- delete.c (delete_references, test/del_frame): delete measurements that
  reference a frame being deleted in their qualifiers
- obj.h, obj.c (enumerate_frames, instantiate): enumerate all frames so that we
  have an index into the bit vector of visited frames
- meas.h, meas.c (reset_samples, meas_post), obj.c (generate_vecs,
  generate_frame, instantiate): record the set of frames visited for each
  sample
- meas.c (meas_post): only treat two instances of a point as equivalent if the
  set of frames visited of one of them is a superset of set of the other. In
  this case, keep the union of the two sets.
- meas.h, meas.c (meas_find_min, meas_find_next, meas_find_max),
  test/meas_qual: instantiate_meas_pkg only select points for which all frames
  in the qualification have been visited
- gui_meas.c (is_min, is_next, is_max, is_a_next): updated for above change
- inst.h, inst.c (curr_frame, propagate_bbox, add_inst, inst_begin_frame,
  inst_end_frame, inst_start): renamed curr_frame to frame_instantiating to
  avoid clash with curr_frame in fpd.y
- inst.h, inst.c (find_meas_hint): make global
- test/structure, test/del_vec, test/del_frame: fped now warns if a measurement
  is in an unlinked frame. Changed regressions tests to avoid this warning.
- test/Common: new function expect_grep to compare only part of the output



Modified: trunk/eda/fped/Makefile
===================================================================
--- trunk/eda/fped/Makefile	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/Makefile	2010-05-29 21:13:48 UTC (rev 5967)
@@ -16,7 +16,7 @@
 
 OBJS = fped.o expr.o coord.o obj.o delete.o inst.o util.o error.o \
        unparse.o file.o dump.o kicad.o postscript.o meas.o \
-       layer.o overlap.o hole.o tsort.o \
+       layer.o overlap.o hole.o tsort.o bitset.o \
        cpp.o lex.yy.o y.tab.o \
        gui.o gui_util.o gui_style.o gui_inst.o gui_status.o gui_canvas.o \
        gui_tool.o gui_over.o gui_meas.o gui_frame.o gui_frame_drag.o

Modified: trunk/eda/fped/README
===================================================================
--- trunk/eda/fped/README	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/README	2010-05-29 21:13:48 UTC (rev 5967)
@@ -582,6 +582,60 @@
 would print "width = 1mm"
 
 
+Additional qualifiers
+- - - - - - - - - - -
+
+When using frames as reusable building blocks, similar to functions or
+macros in many programming languages, one may need finer control over
+the points that are selected for measurements.
+
+For example, let us consider a frame "square" that draws a square
+centered at the frame's origin and with a side length given by the
+variable "size". This variable be set in the frame referencing
+"square".
+
+    frame square {
+	a: vec @(-size/2, -size/2)
+	b: vec @(size/2, size/2)
+	rect a b
+    }
+
+    frame small {
+	set size = 2mm
+	frame square @
+    }
+
+    frame big {
+	set size = 5mm
+	frame square @
+    }
+
+    frame small @
+    vec @(5mm, 0mm)
+    frame big .
+
+If we want to measure the size of each square, we could use
+
+measx square.a -> square.b
+
+Unfortunately, this only measures the small square. To reach the
+big frame, we need to tell fped to use only those points in "square"
+that have been placed when "square" was invoked from the big frame.
+
+This is accomplished by prefixing the points in question with the
+name(s) of the frames that need to be visited. The frame names are
+separated by slashes (/).
+
+measx big/square.a -> square.b
+
+For clarity, it's better to qualify both points, e.g.,
+
+measx big/square.a -> big/square.b
+
+If multiple frame names are given, they must be in the order in
+which they are invoked.
+
+
 Experimental: debugging directives
 ----------------------------------
 
@@ -592,6 +646,7 @@
 %move <identifier> [<number>] <identifier>
 %frame <identifier> <qualified-base>
 %print <expression>
+%meas <identifier>
 %dump
 %exit
 %tsort { -<id> | +<id> | <id-before> <id-after> [<number>] ... }
@@ -622,6 +677,10 @@
 %dump writes the footprint definition in the fped language to standard
 output. %exit immediately exits fped, without invoking the GUI.
 
+%print evaluates the expression and prints the result to standard output.
+%meas performs an instantiation and prints the value of the labeled
+measurement.
+
 %tsort is used to test-drive the topological sort algorithm. The items
 in the curly braces are declarations of nodes with (-<id>) or without
 (+<id>) decay or edges in the partial order. The optional number is

Added: trunk/eda/fped/bitset.c
===================================================================
--- trunk/eda/fped/bitset.c	                        (rev 0)
+++ trunk/eda/fped/bitset.c	2010-05-29 21:13:48 UTC (rev 5967)
@@ -0,0 +1,133 @@
+/*
+ * bitset.c - Arbitrary-length bit sets
+ *
+ * Written 2010 by Werner Almesberger
+ * Copyright 2010 by Werner Almesberger
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <sys/types.h>
+
+#include "util.h"
+#include "bitset.h"
+
+
+struct bitset {
+	int v_n;
+	unsigned *v;
+};
+
+#define BITS	(sizeof(unsigned)*8)
+
+
+struct bitset *bitset_new(int n)
+{
+	struct bitset *new;
+
+	new = alloc_type(struct bitset);
+	new->v_n = (n+BITS-1) & ~(BITS-1);
+	new->v = zalloc_size(sizeof(unsigned)*new->v_n);
+	return new;
+}
+
+
+struct bitset *bitset_clone(const struct bitset *old)
+{
+	struct bitset *new;
+	size_t bytes;
+
+	new = alloc_type(struct bitset);
+	bytes = sizeof(unsigned)*old->v_n;
+	new->v_n = old->v_n;
+	new->v = alloc_size(bytes);
+	memcpy(new->v, old->v, bytes);
+	return new;
+}
+
+
+void bitset_free(struct bitset *set)
+{
+	free(set->v);
+	free(set);
+}
+
+
+void bitset_set(struct bitset *set, int n)
+{
+	assert(n < set->v_n*BITS);
+	set->v[n/BITS] |= 1U << (n % BITS);
+}
+
+
+void bitset_clear(struct bitset *set, int n)
+{
+	assert(n < set->v_n*BITS);
+	set->v[n/BITS] &= ~(1U << (n % BITS));
+}
+
+
+int bitset_pick(const struct bitset *set, int n)
+{
+	assert(n < set->v_n*BITS);
+	return !!(set->v[n/BITS] & (1U << (n % BITS)));
+}
+
+
+int bitset_is_empty(const struct bitset *set)
+{
+	int i;
+
+	for (i = 0; i != set->v_n; i++)
+		if (set->v[i])
+			return 0;
+	return 1;
+}
+
+
+void bitset_zero(struct bitset *a)
+{
+	int i;
+
+	for (i = 0; i != a->v_n; i++)
+		a->v[i] = 0;
+}
+
+
+void bitset_and(struct bitset *a, const struct bitset *b)
+{
+	int i;
+
+	assert(a->v_n == b->v_n);
+	for (i = 0; i != a->v_n; i++)
+		a->v[i] &= b->v[i];
+}
+
+
+void bitset_or(struct bitset *a, const struct bitset *b)
+{
+	int i;
+
+	assert(a->v_n == b->v_n);
+	for (i = 0; i != a->v_n; i++)
+		a->v[i] |= b->v[i];
+}
+
+
+int bitset_ge(const struct bitset *a, const struct bitset *b)
+{
+	int i;
+
+	assert(a->v_n == b->v_n);
+	for (i = 0; i != a->v_n; i++)
+		if (~a->v[i] & b->v[i])
+			return 0;
+	return 1;
+}

Added: trunk/eda/fped/bitset.h
===================================================================
--- trunk/eda/fped/bitset.h	                        (rev 0)
+++ trunk/eda/fped/bitset.h	2010-05-29 21:13:48 UTC (rev 5967)
@@ -0,0 +1,34 @@
+/*
+ * bitset.h - Arbitrary-length bit sets
+ *
+ * Written 2010 by Werner Almesberger
+ * Copyright 2010 by Werner Almesberger
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef BITSET_H
+#define BITSET_H
+
+struct bitset;
+
+struct bitset *bitset_new(int n);
+struct bitset *bitset_clone(const struct bitset *old);
+void bitset_free(struct bitset *set);
+
+void bitset_set(struct bitset *set, int n);
+void bitset_clear(struct bitset *set, int n);
+int bitset_pick(const struct bitset *set, int n);
+
+int bitset_is_empty(const struct bitset *set);
+void bitset_zero(struct bitset *a);
+
+void bitset_and(struct bitset *a, const struct bitset *b);
+void bitset_or(struct bitset *a, const struct bitset *b);
+
+int bitset_ge(const struct bitset *a, const struct bitset *b);
+
+#endif /* !BITSET_H */

Modified: trunk/eda/fped/delete.c
===================================================================
--- trunk/eda/fped/delete.c	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/delete.c	2010-05-29 21:13:48 UTC (rev 5967)
@@ -521,6 +521,17 @@
 }
 
 
+static int qual_ref(const struct frame_qual *qual, const struct frame *ref)
+{
+	while (qual) {
+		if (qual->frame == ref)
+			return 1;
+		qual = qual->next;
+	}
+	return 0;
+}
+
+
 static void delete_references(const struct frame *ref)
 {
 	struct frame *frame;
@@ -535,7 +546,9 @@
 				break;
 			case ot_meas:
 				if (obj->base->frame == ref ||
-				    obj->u.meas.high->frame == ref)
+				    obj->u.meas.high->frame == ref ||
+				    qual_ref(obj->u.meas.low_qual, ref) ||
+				    qual_ref(obj->u.meas.high_qual, ref))
 					do_delete_obj(obj);
 				break;
 			default:

Modified: trunk/eda/fped/dump.c
===================================================================
--- trunk/eda/fped/dump.c	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/dump.c	2010-05-29 21:13:48 UTC (rev 5967)
@@ -13,6 +13,8 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
 
 #include "util.h"
 #include "unparse.h"
@@ -389,14 +391,35 @@
 
 
 
-static char *print_meas_base(struct vec *base)
+static char *print_meas_base(struct vec *base, const struct frame_qual *qual)
 {
 	const char *name;
+	size_t n;
+	const struct frame_qual *walk;
+	char *s, *p;
 
 	name = base_name(base, NULL);
-	if (base->frame == frames)
-		return stralloc(name);
-	return stralloc_printf("%s.%s", base->frame->name, name);
+	n = strlen(name)+1; /* vec\0 */
+	for (walk = qual; walk; walk = walk->next)
+		n += strlen(walk->frame->name)+1; /* frame/ */
+	if (base->frame != frames)
+		n += strlen(base->frame->name)+1; /* frame. */
+
+	s = p = alloc_size(n);
+	for (walk = qual; walk; walk = walk->next) {
+		n = strlen(walk->frame->name);
+		memcpy(p, walk->frame->name, n);
+		p[n] = '/';
+		p += n+1;
+	}
+	if (base->frame != frames) {
+		n = strlen(base->frame->name);
+		memcpy(p, base->frame->name, n);
+		p[n] = '.';
+		p += n+1;
+	}
+	strcpy(p, name);
+	return s;
 }
 
 
@@ -413,11 +436,11 @@
 		free(s);
 		s = t;
 	}
-	s1 = print_meas_base(obj->base);
+	s1 = print_meas_base(obj->base, obj->u.meas.low_qual);
 	s2 = stralloc_printf(" %s ",
 		    obj->u.meas.type < 3 ? obj->u.meas.inverted ? "<-" : "->" :
 		    obj->u.meas.inverted ? "<<" : ">>");
-	s3 = print_meas_base(obj->u.meas.high);
+	s3 = print_meas_base(obj->u.meas.high, obj->u.meas.high_qual);
 	t = stralloc_printf("%s%s%s%s", s, s1, s2, s3);
 	free(s);
 	free(s1);

Modified: trunk/eda/fped/error.c
===================================================================
--- trunk/eda/fped/error.c	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/error.c	2010-05-29 21:13:48 UTC (rev 5967)
@@ -1,8 +1,8 @@
 /*
  * error.c - Error reporting
  *
- * Written 2009 by Werner Almesberger
- * Copyright 2009 by Werner Almesberger
+ * Written 2009, 2010 by Werner Almesberger
+ * Copyright 2009, 2010 by Werner Almesberger
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -25,6 +25,13 @@
 void (*reporter)(const char *s) = report_to_stderr;
 
 
+void yywarn(const char *s)
+{
+	/* we use yywarn only when starting */
+	fprintf(stderr, "%d: warning: %s near \"%s\"\n", lineno, s, yytext);
+}
+
+
 void yyerrorf(const char *fmt, ...)
 {
 	va_list ap;

Modified: trunk/eda/fped/error.h
===================================================================
--- trunk/eda/fped/error.h	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/error.h	2010-05-29 21:13:48 UTC (rev 5967)
@@ -1,8 +1,8 @@
 /*
  * error.h - Error reporting
  *
- * Written 2009 by Werner Almesberger
- * Copyright 2009 by Werner Almesberger
+ * Written 2009, 2010 by Werner Almesberger
+ * Copyright 2009, 2010 by Werner Almesberger
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,6 +20,8 @@
 extern void (*reporter)(const char *s);
 
 
+void yywarn(const char *s);
+
 void yyerrorf(const char *fmt, ...)
     __attribute__((format(printf, 1, 2)));
 void yyerror(const char *s);

Modified: trunk/eda/fped/fpd.l
===================================================================
--- trunk/eda/fped/fpd.l	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/fpd.l	2010-05-29 21:13:48 UTC (rev 5967)
@@ -131,6 +131,8 @@
 				  return TOK_DBG_FRAME; }
 <INITIAL>"%print"		{ BEGIN(NOKEYWORD);
 				  return TOK_DBG_PRINT; }
+<INITIAL>"%meas"		{ BEGIN(NOKEYWORD);
+				  return TOK_DBG_MEAS; }
 <INITIAL>"%dump"		{ BEGIN(NOKEYWORD);
 				  return TOK_DBG_DUMP; }
 <INITIAL>"%exit"		{ BEGIN(NOKEYWORD);
@@ -173,10 +175,12 @@
 
 ;				BEGIN(INITIAL);
 
-"{"				{ BEGIN(NOKEYWORD);
-				  disable_keywords = is_table;
+"{"				{ disable_keywords = is_table;
+				  BEGIN(disable_keywords ?
+				    NOKEYWORD : INITIAL);
 				  return '{'; }
 "}"				{ disable_keywords = 0;
+				  BEGIN(INITIAL);
 				  return '}'; }
 
 ^#\ [0-9]+\ \"[^"]*\"(\ [0-9]+)*\n {

Modified: trunk/eda/fped/fpd.y
===================================================================
--- trunk/eda/fped/fpd.y	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/fpd.y	2010-05-29 21:13:48 UTC (rev 5967)
@@ -17,15 +17,19 @@
 
 #include "util.h"
 #include "error.h"
+#include "coord.h"
 #include "expr.h"
 #include "obj.h"
 #include "meas.h"
 #include "gui_status.h"
+#include "gui_inst.h" /* for %meas */
 #include "dump.h"
 #include "tsort.h"
 #include "fpd.h"
 
+#include "y.tab.h"
 
+
 struct expr *expr_result;
 const char *var_id;
 struct value *var_value_list;
@@ -49,6 +53,9 @@
 static struct tsort *tsort;
 
 
+/* ----- lookup functions -------------------------------------------------- */
+
+
 static struct frame *find_frame(const char *name)
 {
 	struct frame *f;
@@ -109,6 +116,9 @@
 }
 
 
+/* ----- item creation ----------------------------------------------------- */
+
+
 static void set_frame(struct frame *frame)
 {
 	curr_frame = frame;
@@ -177,6 +187,65 @@
 }
 
 
+/* ---- frame qualifiers --------------------------------------------------- */
+
+
+static int duplicate_qualifier(const struct frame_qual *a,
+    const struct frame_qual *b)
+{
+	if (!b)
+		return 0;
+	if (a != b && a->frame == b->frame) {
+		yyerrorf("duplicate qualifier \"%s\"", a->frame->name);
+		return 1;
+	}
+	if (b && duplicate_qualifier(a, b->next))
+		return 1;
+	return duplicate_qualifier(a->next, a->next);
+}
+
+
+static int can_reach(const struct frame *curr, const struct frame_qual *qual,
+    const struct frame *end)
+{
+	const struct obj *obj;
+
+	if (curr == end)
+		return !qual;
+
+	/*
+	 * Don't recurse for removing the qualifier alone. We require a frame
+	 * reference step as well, so that things like foo.foo.foo.bar.vec
+	 * aren't allowed.
+	 *
+	 * Since a duplicate qualifier can never work, we test for this error
+	 * explicitly in "duplicate_qualifier".
+	 */
+	if (qual && curr == qual->frame)
+		qual = qual->next;
+
+	for (obj = curr->objs; obj; obj = obj->next)
+		if (obj->type == ot_frame)
+			if (can_reach(obj->u.frame.ref, qual, end))
+				return 1;
+	return 0;
+}
+
+
+static int check_qbase(struct qbase *qbase)
+{
+	if (duplicate_qualifier(qbase->qualifiers, qbase->qualifiers))
+		return 0;
+
+	if (!can_reach(frames, qbase->qualifiers, qbase->vec->frame))
+		yywarn("not all qualifiers can be reached");
+	return 1;
+}
+
+
+/* ----- debugging directives ---------------------------------------------- */
+
+
 static int dbg_delete(const char *frame_name, const char *name)
 {
 	struct vec *vec;
@@ -314,6 +383,43 @@
 }
 
 
+static int dbg_meas(const char *name)
+{
+	const struct obj *obj;
+	const struct inst *inst;
+	struct coord a1, b1;
+	char *s;
+
+	obj = find_obj(frames, name);
+	if (!obj) {
+		yyerrorf("unknown object \"%s\"", name);
+		return 0;
+	}
+
+	/* from fped.c:main */
+
+	if (!pkg_name)
+                pkg_name = stralloc("_");
+        reporter = report_to_stderr;
+	if (!instantiate())
+		return 0;
+
+	inst = find_meas_hint(obj);
+	if (!inst) {
+		yyerrorf("measurement \"%s\" was not instantiated", name);
+		return 0;
+	}
+
+	project_meas(inst, &a1, &b1);
+	s = format_len(obj->u.meas.label ? obj->u.meas.label : "",
+	    dist_point(a1, b1), curr_unit);
+	printf("%s\n", s);
+	free(s);
+
+	return 1;
+}
+
+
 %}
 
 
@@ -339,6 +445,10 @@
 		struct frame *frame;
 		struct vec *vec;
 	} qvec;
+	struct qbase {
+		struct vec *vec;
+		struct frame_qual *qualifiers;
+	} qbase;
 };
 
 
@@ -348,7 +458,7 @@
 %token		TOK_MEAS TOK_MEASX TOK_MEASY TOK_UNIT
 %token		TOK_NEXT TOK_NEXT_INVERTED TOK_MAX TOK_MAX_INVERTED
 %token		TOK_DBG_DEL TOK_DBG_MOVE TOK_DBG_FRAME TOK_DBG_PRINT
-%token		TOK_DBG_DUMP TOK_DBG_EXIT TOK_DBG_TSORT
+%token		TOK_DBG_DUMP TOK_DBG_EXIT TOK_DBG_TSORT TOK_DBG_MEAS
 
 %token	<num>	NUMBER
 %token	<str>	STRING
@@ -358,8 +468,8 @@
 %type	<var>	vars var
 %type	<row>	rows
 %type	<value>	row value opt_value_list
-%type	<vec>	vec base qbase
-%type	<obj>	object obj meas
+%type	<vec>	vec base
+%type	<obj>	object obj meas unlabeled_meas
 %type	<expr>	expr opt_expr add_expr mult_expr unary_expr primary_expr
 %type	<num>	opt_num
 %type	<frame>	frame_qualifier
@@ -368,6 +478,7 @@
 %type	<mt>	meas_type
 %type	<mo>	meas_op
 %type	<qvec>	qualified_base
+%type	<qbase>	qbase qbase_unchecked
 
 %%
 
@@ -538,6 +649,11 @@
 			if (!dbg_print($2))
 				YYABORT;
 		}
+	| TOK_DBG_MEAS ID
+		{
+			if (!dbg_meas($2))
+				YYABORT;
+		}
 	| TOK_DBG_DUMP
 		{
 			if (!dump(stdout)) {
@@ -867,7 +983,7 @@
 	;
 
 measurements:
-	meas
+	unlabeled_meas	/* @@@ hack */
 		{
 			*next_obj = $1;
 			next_obj = &$1->next;
@@ -881,6 +997,22 @@
 	;
 
 meas:
+	unlabeled_meas
+		{
+			$$ = $1;
+		}
+	| LABEL unlabeled_meas
+		{
+			$$ = $2;
+			if (find_label(curr_frame, $1)) {
+				yyerrorf("duplicate label \"%s\"", $1);
+				YYABORT;
+			}
+			$$->name = $1;
+		}
+	;
+
+unlabeled_meas:
 	meas_type opt_string qbase meas_op qbase opt_expr
 		{
 			struct meas *meas;
@@ -889,34 +1021,64 @@
 			meas = &$$->u.meas;
 			meas->type = $4.max ? $1+3 : $1;
 			meas->label = $2;
-			$$->base = $3;
+			$$->base = $3.vec;
+			meas->low_qual = $3.qualifiers;
 			meas->inverted = $4.inverted;
-			meas->high = $5;
+			meas->high = $5.vec;
+			meas->high_qual = $5.qualifiers;
 			meas->offset = $6;
 			$$->next = NULL;
 		}
 	;
 
 qbase:
+	qbase_unchecked
+		{
+			$$ = $1;
+			if (!check_qbase(&$$))
+				YYABORT;
+		}
+	;
+
+qbase_unchecked:
 	ID
 		{
-			$$ = find_vec(frames, $1);
-			if (!$$) {
+			$$.vec = find_vec(frames, $1);
+			if (!$$.vec) {
 				yyerrorf("unknown vector \"%s\"", $1);
 				YYABORT;
 			}
+			$$.qualifiers = NULL;
 		}
 	| ID '.' ID
 		{
 			const struct frame *frame;
 
 			frame = find_frame($1);
-			$$ = frame ? find_vec(frame, $3) : NULL;
-			if (!$$) {
+			$$.vec = frame ? find_vec(frame, $3) : NULL;
+			if (!$$.vec) {
 				yyerrorf("unknown vector \"%s.%s\"", $1, $3);
 				YYABORT;
 			}
+			$$.qualifiers = NULL;
 		}
+	| ID '/' qbase
+		{
+			const struct frame *frame;
+			struct frame_qual *qual;
+
+			$$ = $3;
+			frame = find_frame($1);
+			if (!frame) {
+				yyerrorf("unknown frame \"%s\"", $1);
+				YYABORT;
+			} else {
+				qual = alloc_type(struct frame_qual);
+				qual->frame = frame;
+				qual->next = $$.qualifiers;
+				$$.qualifiers = qual;
+			}
+		}
 	;
 
 meas_type:

Modified: trunk/eda/fped/gui_meas.c
===================================================================
--- trunk/eda/fped/gui_meas.c	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/gui_meas.c	2010-05-29 21:13:48 UTC (rev 5967)
@@ -1,8 +1,8 @@
 /*
  * gui_meas.c - GUI, measurements
  *
- * Written 2009 by Werner Almesberger
- * Copyright 2009 by Werner Almesberger
+ * Written 2009, 2010 by Werner Almesberger
+* Copyright 2009, 2010 by Werner Almesberger
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -61,43 +61,43 @@
 
 static int is_min(lt_op_type lt, const struct inst *inst)
 {
-	struct coord min;
+	const struct sample *min;
 
-	min = meas_find_min(lt, active_pkg->samples[inst->vec->n]);
-	return coord_eq(inst->u.vec.end, min);
+	min = meas_find_min(lt, active_pkg->samples[inst->vec->n], NULL);
+	return coord_eq(inst->u.vec.end, min->pos);
 }
 
 
 static int is_next(lt_op_type lt,
     const struct inst *inst, const struct inst *ref)
 {
-	struct coord next;
+	const struct sample *next;
 
 	next = meas_find_next(lt, active_pkg->samples[inst->vec->n],
-	    ref->u.vec.end);
-	return coord_eq(inst->u.vec.end, next);
+	    ref->u.vec.end, NULL);
+	return coord_eq(inst->u.vec.end, next->pos);
 }
 
 
 static int is_max(lt_op_type lt, const struct inst *inst)
 {
-	struct coord max;
+	const struct sample *max;
 
-	max = meas_find_max(lt, active_pkg->samples[inst->vec->n]);
-	return coord_eq(inst->u.vec.end, max);
+	max = meas_find_max(lt, active_pkg->samples[inst->vec->n], NULL);
+	return coord_eq(inst->u.vec.end, max->pos);
 }
 
 
 static int is_a_next(lt_op_type lt, struct inst *inst)
 {
 	struct inst *a;
-	struct coord min, next;
+	const struct sample *min, *next;
 
 	for (a = insts_ip_vec(); a; a = a->next) {
-		min = meas_find_min(lt, active_pkg->samples[a->vec->n]);
+		min = meas_find_min(lt, active_pkg->samples[a->vec->n], NULL);
 		next = meas_find_next(lt, active_pkg->samples[inst->vec->n],
-		    min);
-		if (coord_eq(next, inst->u.vec.end))
+		    min->pos, NULL);
+		if (coord_eq(next->pos, inst->u.vec.end))
 			return 1;
 	}
 	return 0;
@@ -309,6 +309,9 @@
 	    (mode == min_to_next_or_max);
 	meas->offset = NULL;
 	meas_dsc = NULL;
+	/* we don't support qualifiers through the GUI yet */
+	meas->low_qual = NULL;
+	meas->high_qual = NULL;
 	return 1;
 }
 

Modified: trunk/eda/fped/inst.c
===================================================================
--- trunk/eda/fped/inst.c	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/inst.c	2010-05-29 21:13:48 UTC (rev 5967)
@@ -35,7 +35,7 @@
 struct inst *selected_inst = NULL;
 struct bbox active_frame_bbox;
 struct pkg *pkgs, *active_pkg, *curr_pkg;
-struct inst *curr_frame = NULL;
+struct inst *frame_instantiating = NULL;
 
 static struct pkg *prev_pkgs;
 
@@ -574,8 +574,8 @@
 
 static void propagate_bbox(const struct inst *inst)
 {
-	struct inst *frame =
-	    curr_frame ? curr_frame : curr_pkg->insts[ip_frame];
+	struct inst *frame = frame_instantiating ?
+	    frame_instantiating : curr_pkg->insts[ip_frame];
 
 	update_bbox(&frame->bbox, inst->bbox.min);
 	update_bbox(&frame->bbox, inst->bbox.max);
@@ -602,7 +602,7 @@
 	inst->vec = NULL;
 	inst->obj = NULL;
 	inst->base = inst->bbox.min = inst->bbox.max = base;
-	inst->outer = curr_frame;
+	inst->outer = frame_instantiating;
 	inst->active = IS_ACTIVE;
 	inst->next = NULL;
 	*curr_pkg->next_inst[prio] = inst;
@@ -1030,7 +1030,7 @@
 };
 
 
-static struct inst *find_meas_hint(const struct obj *obj)
+struct inst *find_meas_hint(const struct obj *obj)
 {
 	struct inst *inst;
 
@@ -1151,16 +1151,16 @@
 	inst->u.frame.active = is_active_frame;
 	inst->active = active;
 	find_inst(inst);
-	curr_frame = inst;
+	frame_instantiating = inst;
 }
 
 
 void inst_end_frame(const struct frame *frame)
 {
-	struct inst *inst = curr_frame;
+	struct inst *inst = frame_instantiating;
 
-	curr_frame = curr_frame->outer;
-	if (curr_frame)
+	frame_instantiating = frame_instantiating->outer;
+	if (frame_instantiating)
 		propagate_bbox(inst);
 	if (inst->u.frame.active && frame == active_frame)
 		active_frame_bbox = inst->bbox;
@@ -1245,7 +1245,7 @@
 	pkgs = NULL;
 	inst_select_pkg(NULL);
 	curr_pkg = pkgs;
-	curr_frame = NULL;
+	frame_instantiating = NULL;
 }
 
 

Modified: trunk/eda/fped/inst.h
===================================================================
--- trunk/eda/fped/inst.h	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/inst.h	2010-05-29 21:13:48 UTC (rev 5967)
@@ -137,9 +137,9 @@
 
 /*
  * frame being instantiated - we need to export this one for meas.c, so that
- * measurement scan update the root frame's bounding box.
+ * measurements can update the root frame's bounding box.
  */
-extern struct inst *curr_frame;
+extern struct inst *frame_instantiating;
 
 /*
  * @@@ Note that we over-generalize a bit here: the only item that ever ends up
@@ -183,6 +183,7 @@
 int inst_hole(struct obj *obj, struct coord a, struct coord b);
 int inst_arc(struct obj *obj, struct coord center, struct coord start,
     struct coord stop, unit_type width);
+struct inst *find_meas_hint(const struct obj *obj);
 int inst_meas(struct obj *obj, struct coord from, struct coord to);
 void inst_meas_hint(struct obj *obj, unit_type offset);
 

Modified: trunk/eda/fped/meas.c
===================================================================
--- trunk/eda/fped/meas.c	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/meas.c	2010-05-29 21:13:48 UTC (rev 5967)
@@ -1,8 +1,8 @@
 /*
  * meas.c - Measurements
  *
- * Written 2009 by Werner Almesberger
- * Copyright 2009 by Werner Almesberger
+ * Written 2009, 2010 by Werner Almesberger
+ * Copyright 2009, 2010 by Werner Almesberger
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -35,6 +35,7 @@
 	for (i = 0; i != n; i++)
 		while (samples[i]) {
 			next = samples[i]->next;
+			bitset_free(samples[i]->frame_set);
 			free(samples[i]);
 			samples[i] = next;
 		}
@@ -53,7 +54,8 @@
 }
 
 
-void meas_post(const struct vec *vec, struct coord pos)
+void meas_post(const struct vec *vec, struct coord pos,
+    const struct bitset *frame_set)
 {
 	struct sample **walk, *new;
 
@@ -64,11 +66,18 @@
 			continue;
 		if (pos.x < (*walk)->pos.x)
 			break;
-		if (pos.x == (*walk)->pos.x)
+		if (pos.x != (*walk)->pos.x)
+			continue;
+		if (bitset_ge((*walk)->frame_set, frame_set))
 			return;
+		if (bitset_ge(frame_set, (*walk)->frame_set)) {
+			bitset_or((*walk)->frame_set, frame_set);
+			return;
+		}
 	}
 	new = alloc_type(struct sample);
 	new->pos = pos;
+	new->frame_set = bitset_clone(frame_set);
 	new->next = *walk;
 	*walk = new;
 }
@@ -177,45 +186,47 @@
  * else if (*a == a0 && *a <xy a0) use *a
  */
 
-struct coord meas_find_min(lt_op_type lt, const struct sample *s)
+const struct sample *meas_find_min(lt_op_type lt, const struct sample *s,
+    const struct bitset *qual)
 {
-	struct coord min;
+	const struct sample *min = NULL;
 
-	min = s->pos;
 	while (s) {
-		if (lt(s->pos, min) ||
-		    (!lt(min, s->pos) && lt_xy(s->pos, min)))
-			min = s->pos;
+		if (!qual || bitset_ge(s->frame_set, qual))
+			if (!min || lt(s->pos, min->pos) ||
+			    (!lt(min->pos, s->pos) && lt_xy(s->pos, min->pos)))
+				min = s;
 		s = s->next;
 	}
 	return min;
 }
 
 
-struct coord meas_find_next(lt_op_type lt, const struct sample *s,
-    struct coord ref)
+const struct sample *meas_find_next(lt_op_type lt, const struct sample *s,
+    struct coord ref, const struct bitset *qual)
 {
-	struct coord next;
+	const struct sample *next = NULL;
 
-	next = s->pos;
 	while (s) {
-		if (better_next(lt, ref, next, s->pos))
-			next = s->pos;
+		if (!qual || bitset_ge(s->frame_set, qual))
+			if (!next || better_next(lt, ref, next->pos, s->pos))
+				next = s;
 		s = s->next;
 	}
 	return next;
 }
 
 
-struct coord meas_find_max(lt_op_type lt, const struct sample *s)
+const struct sample *meas_find_max(lt_op_type lt, const struct sample *s,
+    const struct bitset *qual)
 {
-	struct coord max;
+	const struct sample *max = NULL;
 
-	max = s->pos;
 	while (s) {
-		if (lt(max, s->pos) ||
-		    (!lt(s->pos, max) && lt_xy(max, s->pos)))
-			max = s->pos;
+		if (!qual || bitset_ge(s->frame_set, qual))
+			if (!max || lt(max->pos, s->pos) ||
+			    (!lt(s->pos, max->pos) && lt_xy(max->pos, s->pos)))
+				max = s;
 		s = s->next;
 	}
 	return max;
@@ -225,46 +236,73 @@
 /* ----- instantiation ----------------------------------------------------- */
 
 
-static int instantiate_meas_pkg(void)
+static struct bitset *make_frame_set(struct frame_qual *qual, int n_frames)
 {
+	struct bitset *set;
+
+	set = bitset_new(n_frames);
+	while (qual) {
+		bitset_set(set, qual->frame->n);
+		qual = qual->next;
+	}
+	return set;
+}
+
+
+static int instantiate_meas_pkg(int n_frames)
+{
 	struct obj *obj;
 	const struct meas *meas;
-	struct coord a0, b0;
+	struct bitset *set;
+	const struct sample *a0, *b0;
 	lt_op_type lt;
 
 	for (obj = frames->objs; obj; obj = obj->next) {
 		if (obj->type != ot_meas)
 			continue;
 		meas = &obj->u.meas;
+
+		/* optimization. not really needed anymore. */
 		if (!curr_pkg->samples[obj->base->n] ||
 		    !curr_pkg->samples[meas->high->n])
 			continue;
 
 		lt = lt_op[meas->type];
-		a0 = meas_find_min(lt, curr_pkg->samples[obj->base->n]);
+
+		set = make_frame_set(meas->low_qual, n_frames);
+		a0 = meas_find_min(lt, curr_pkg->samples[obj->base->n], set);
+		bitset_free(set);
+		if (!a0)
+			continue;
+
+		set = make_frame_set(meas->high_qual, n_frames);
 		if (is_next[meas->type])
 			b0 = meas_find_next(lt,
-			    curr_pkg->samples[meas->high->n], a0);
+			    curr_pkg->samples[meas->high->n], a0->pos, set);
 		else
 			b0 = meas_find_max(lt,
-			    curr_pkg->samples[meas->high->n]);
+			    curr_pkg->samples[meas->high->n], set);
+		bitset_free(set);
+		if (!b0)
+			continue;
 
 		inst_meas(obj,
-		    meas->inverted ? b0 : a0, meas->inverted ? a0 : b0);
+		    meas->inverted ? b0->pos : a0->pos,
+		    meas->inverted ? a0->pos : b0->pos);
 	}
 	return 1;
 }
 
 
-int instantiate_meas(void)
+int instantiate_meas(int n_frames)
 {
 	struct pkg *pkg;
 
-	curr_frame = pkgs->insts[ip_frame];
+	frame_instantiating = pkgs->insts[ip_frame];
 	for (pkg = pkgs; pkg; pkg = pkg->next)
 		if (pkg->name) {
 			inst_select_pkg(pkg->name);
-			if (!instantiate_meas_pkg())
+			if (!instantiate_meas_pkg(n_frames))
 				return 0;
 		}
 	return 1;

Modified: trunk/eda/fped/meas.h
===================================================================
--- trunk/eda/fped/meas.h	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/meas.h	2010-05-29 21:13:48 UTC (rev 5967)
@@ -1,8 +1,8 @@
 /*
  * meas.h - Measurements
  *
- * Written 2009 by Werner Almesberger
- * Copyright 2009 by Werner Almesberger
+ * Written 2009, 2010 by Werner Almesberger
+ * Copyright 2009, 2010 by Werner Almesberger
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,6 +17,7 @@
 
 #include "coord.h"
 #include "expr.h"
+#include "bitset.h"
 
 
 typedef int (*lt_op_type)(struct coord a, struct coord b);
@@ -24,6 +25,11 @@
 struct vec;
 struct obj;
 
+struct frame_qual {
+	const struct frame *frame;
+	struct frame_qual *next;
+};
+
 struct meas {
 	enum meas_type {
 		mt_xy_next,
@@ -39,10 +45,15 @@
 	/* low is obj->base */
 	struct vec *high;
 	struct expr *offset;
+		
+	/* frame qualifiers */
+	struct frame_qual *low_qual;
+	struct frame_qual *high_qual;
 };
 
 struct sample {
 	struct coord pos;
+	struct bitset *frame_set;
 	struct sample *next;
 };
 
@@ -54,15 +65,18 @@
 int lt_y(struct coord a, struct coord b);
 int lt_xy(struct coord a, struct coord b);
 
-struct coord meas_find_min(lt_op_type lt, const struct sample *s);
-struct coord meas_find_next(lt_op_type lt, const struct sample *s,
-    struct coord ref);
-struct coord meas_find_max(lt_op_type lt, const struct sample *s);
+const struct sample *meas_find_min(lt_op_type lt, const struct sample *s,
+    const struct bitset *qual);
+const struct sample *meas_find_next(lt_op_type lt, const struct sample *s,
+    struct coord ref, const struct bitset *qual);
+const struct sample *meas_find_max(lt_op_type lt, const struct sample *s,
+    const struct bitset *qual);
 
 
 void reset_samples(struct sample **samples, int n);
 void meas_start(void);
-void meas_post(const struct vec *vec, struct coord pos);
-int instantiate_meas(void);
+void meas_post(const struct vec *vec, struct coord pos,
+    const struct bitset *frame_set);
+int instantiate_meas(int n_frames);
 
 #endif /* !MEAS_H */

Modified: trunk/eda/fped/obj.c
===================================================================
--- trunk/eda/fped/obj.c	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/obj.c	2010-05-29 21:13:48 UTC (rev 5967)
@@ -18,6 +18,7 @@
 #include "util.h"
 #include "error.h"
 #include "expr.h"
+#include "bitset.h"
 #include "meas.h"
 #include "inst.h"
 #include "hole.h"
@@ -38,6 +39,9 @@
 void *instantiation_error = NULL;
 
 
+static struct bitset *frame_set; /* frames visited in "call chain" */
+
+
 /* ----- Searching --------------------------------------------------------- */
 
 
@@ -181,7 +185,7 @@
 		vec->pos.y += y.n;
 		if (!inst_vec(vec, vec_base))
 			goto error;
-		meas_post(vec, vec->pos);
+		meas_post(vec, vec->pos, frame_set);
 	}
 	return 1;
 
@@ -399,9 +403,11 @@
 	inst_begin_frame(frame_ref, frame, base,
 	    active && parent == active_frame,
 	    active && frame == active_frame);
+	bitset_set(frame_set, frame->n);
 	frame->curr_parent = parent;
 	ok = iterate_tables(frame, frame->tables, base, active);
 	inst_end_frame(frame);
+	bitset_clear(frame_set, frame->n);
 	frame->curr_parent = NULL;
 	return ok;
 }
@@ -458,13 +464,27 @@
 }
 
 
+static int enumerate_frames(void)
+{
+	struct frame *frame;
+	int n = 0;
+
+	for (frame = frames; frame; frame = frame->next)
+		frame->n = n++;
+	return n;
+}
+
+
 int instantiate(void)
 {
 	struct coord zero = { 0, 0 };
+	int n_frames;
 	int ok;
 
 	meas_start();
 	inst_start();
+	n_frames = enumerate_frames();
+	frame_set = bitset_new(n_frames);
 	instantiation_error = NULL;
 	reset_all_loops();
 	reset_found();
@@ -480,11 +500,12 @@
 	if (ok)
 		ok = refine_layers();
 	if (ok)
-		ok = instantiate_meas();
+		ok = instantiate_meas(n_frames);
 	if (ok)
 		inst_commit();
 	else
 		inst_revert();
+	bitset_free(frame_set);
 	return ok;
 }
 

Modified: trunk/eda/fped/obj.h
===================================================================
--- trunk/eda/fped/obj.h	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/obj.h	2010-05-29 21:13:48 UTC (rev 5967)
@@ -163,9 +163,12 @@
 	/* generating and editing */
 	struct obj *active_ref;
 
-	/* For searching */
+	/* for searching */
 	struct obj *found_ref;	/* NULL if not found yet */
 
+	/* index into bit vector in samples */
+	int n;
+
 	/* for dumping */
 	int dumped;
 

Modified: trunk/eda/fped/test/Common
===================================================================
--- trunk/eda/fped/test/Common	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/test/Common	2010-05-29 21:13:48 UTC (rev 5967)
@@ -62,6 +62,15 @@
 }
 
 
+expect_grep()
+{
+	grep "$1" <_out >_tmp || exit 1
+	mv _tmp _out
+	shift
+	expect "$@"
+}
+
+
 if [ ! -z "$CWD_PREFIX" -a ! -z "$FPED" -a "$FPED" = "${FPED#/}" ]; then
     FPED="$CWD_PREFIX/$FPED"
 fi

Added: trunk/eda/fped/test/dbg_meas
===================================================================
--- trunk/eda/fped/test/dbg_meas	                        (rev 0)
+++ trunk/eda/fped/test/dbg_meas	2010-05-29 21:13:48 UTC (rev 5967)
@@ -0,0 +1,54 @@
+#!/bin/sh
+. ./Common
+
+###############################################################################
+
+fped "%meas: print mm (default)" <<EOF
+a: vec @(0mm, 0mm)
+b: vec @(3mm, 4mm)
+meas a >> b	/* work-around to simplify grammar */
+m: meas a >> b
+%meas m
+EOF
+expect <<EOF
+5
+EOF
+
+#------------------------------------------------------------------------------
+
+fped "%meas: print mil" <<EOF
+unit mil
+a: vec @(0mm, 0mm)
+b: vec @(2.54mm, 0mm)
+meas a >> b	/* work-around to simplify grammar */
+m: meas a >> b
+%meas m
+EOF
+expect <<EOF
+100
+EOF
+
+#------------------------------------------------------------------------------
+
+fped_fail "%meas: invalid ID" <<EOF
+%meas m
+EOF
+expect <<EOF
+1: unknown object "m" near "m"
+EOF
+
+#------------------------------------------------------------------------------
+
+fped_fail "%meas: measurement not instantiated" <<EOF
+a: vec @(0mm, 0mm)
+loop i = 1, 0
+b: vec @(i*1mm, 0mm)
+meas a >> b	/* work-around to simplify grammar */
+m: meas a >> b
+%meas m
+EOF
+expect <<EOF
+measurement "m" was not instantiated
+EOF
+
+###############################################################################


Property changes on: trunk/eda/fped/test/dbg_meas
___________________________________________________________________
Name: svn:executable
   + *

Modified: trunk/eda/fped/test/del_frame
===================================================================
--- trunk/eda/fped/test/del_frame	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/test/del_frame	2010-05-29 21:13:48 UTC (rev 5967)
@@ -53,6 +53,7 @@
 	v: vec @(0mm, 0mm)
 }
 
+frame f @
 meas f.v -> f.v
 
 %del f
@@ -64,4 +65,29 @@
 unit mm
 EOF
 
+#------------------------------------------------------------------------------
+
+fped_dump "delete frame: measurements with qualifiers disappear" <<EOF
+frame f {
+	v: vec @(0mm, 0mm)
+}
+
+frame g { frame f @ }
+
+frame g @
+meas g/f.v -> f.v
+
+%del g
+EOF
+expect <<EOF
+/* MACHINE-GENERATED ! */
+
+frame f {
+	v: vec @(0mm, 0mm)
+}
+
+package "_"
+unit mm
+EOF
+
 ###############################################################################

Modified: trunk/eda/fped/test/del_vec
===================================================================
--- trunk/eda/fped/test/del_vec	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/test/del_vec	2010-05-29 21:13:48 UTC (rev 5967)
@@ -48,6 +48,7 @@
 frame f {
 	v: vec @(0mm, 0mm)
 }
+frame f @
 meas f.v -> f.v
 %del f.v
 EOF
@@ -59,6 +60,7 @@
 
 package "_"
 unit mm
+frame f @
 EOF
 
 ###############################################################################

Added: trunk/eda/fped/test/meas_qual
===================================================================
--- trunk/eda/fped/test/meas_qual	                        (rev 0)
+++ trunk/eda/fped/test/meas_qual	2010-05-29 21:13:48 UTC (rev 5967)
@@ -0,0 +1,231 @@
+#!/bin/sh
+. ./Common
+
+###############################################################################
+
+fped_dump "qualified measurements: no qualifier" <<EOF
+frame c { v: vec @(0mm, 0mm) }
+frame b { frame c @ }
+frame a { frame b @ }
+frame a @
+meas c.v >> c.v
+EOF
+expect <<EOF
+/* MACHINE-GENERATED ! */
+
+frame c {
+	v: vec @(0mm, 0mm)
+}
+
+frame b {
+	frame c @
+}
+
+frame a {
+	frame b @
+}
+
+package "_"
+unit mm
+frame a @
+meas c.v >> c.v
+EOF
+
+#------------------------------------------------------------------------------
+
+fped_dump "qualified measurements: fully qualified" <<EOF
+frame c { v: vec @(0mm, 0mm) }
+frame b { frame c @ }
+frame a { frame b @ }
+frame a @
+meas a/b/c.v >> c.v
+EOF
+expect_grep '^meas' <<EOF
+meas a/b/c.v >> c.v
+EOF
+
+#------------------------------------------------------------------------------
+
+fped_dump "qualified measurements: partially qualified" <<EOF
+frame c { v: vec @(0mm, 0mm) }
+frame b { frame c @ }
+frame a { frame b @ }
+frame a @
+meas a/c.v >> c.v
+EOF
+expect_grep '^meas' <<EOF
+meas a/c.v >> c.v
+EOF
+
+#------------------------------------------------------------------------------
+
+fped_dump "qualified measurements: wrong order" <<EOF
+frame c { v: vec @(0mm, 0mm) }
+frame b { frame c @ }
+frame a { frame b @ }
+frame a @
+meas b/a/c.v >> c.v
+EOF
+expect_grep 'warning' <<EOF
+5: warning: not all qualifiers can be reached near "v"
+EOF
+
+#------------------------------------------------------------------------------
+
+fped_dump "qualified measurements: unlinked frame" <<EOF
+frame c { v: vec @(0mm, 0mm) }
+frame b { frame c @ }
+frame a { frame b @ }
+frame x {}
+frame a @
+frame x @
+meas a/c.v >> x/c.v
+EOF
+expect_grep 'warning' <<EOF
+7: warning: not all qualifiers can be reached near "v"
+EOF
+
+#------------------------------------------------------------------------------
+
+fped_fail "qualified measurements: duplicate qualifier" <<EOF
+frame c { v: vec @(0mm, 0mm) }
+frame b { frame c @ }
+frame a { frame b @ }
+frame a @
+meas b/b/c.v >> c.v
+EOF
+expect <<EOF
+5: duplicate qualifier "b" near "v"
+EOF
+
+#------------------------------------------------------------------------------
+
+fped "qualified measurements: \"macro\" unqualified" <<EOF
+frame x {
+	a: vec @(0mm, 0mm)
+	b: vec .(d, 0mm)
+}
+frame a {
+	set d = 2mm
+	frame x @
+}
+frame b {
+	set d = 3mm
+	frame x @
+}
+frame a @
+vec @(1mm, 0mm)
+frame b .
+meas x.a >> x.b /* dummy */
+m: meas x.a >> x.b
+%meas m
+EOF
+expect <<EOF
+4
+EOF
+
+#------------------------------------------------------------------------------
+
+fped "qualified measurements: \"macro\" qualified (a)" <<EOF
+frame x {
+	a: vec @(0mm, 0mm)
+	b: vec .(d, 0mm)
+}
+frame a {
+	set d = 2mm
+	frame x @
+}
+frame b {
+	set d = 3mm
+	frame x @
+}
+frame a @
+vec @(1mm, 0mm)
+frame b .
+meas x.a >> x.b /* dummy */
+m: meas a/x.a >> a/x.b
+%meas m
+EOF
+expect <<EOF
+2
+EOF
+
+#------------------------------------------------------------------------------
+
+fped "qualified measurements: \"macro\" qualified (b)" <<EOF
+frame x {
+	a: vec @(0mm, 0mm)
+	b: vec .(d, 0mm)
+}
+frame a {
+	set d = 2mm
+	frame x @
+}
+frame b {
+	set d = 3mm
+	frame x @
+}
+frame a @
+vec @(1mm, 0mm)
+frame b .
+meas x.a >> x.b /* dummy */
+m: meas b/x.a >> b/x.b
+%meas m
+EOF
+expect <<EOF
+3
+EOF
+
+#------------------------------------------------------------------------------
+
+fped "qualified measurements: \"macro\" qualified (a/b)" <<EOF
+frame x {
+	a: vec @(0mm, 0mm)
+	b: vec .(d, 0mm)
+}
+frame a {
+	set d = 2mm
+	frame x @
+}
+frame b {
+	set d = 3mm
+	frame x @
+}
+frame a @
+vec @(1mm, 0mm)
+frame b .
+meas x.a >> x.b /* dummy */
+m: meas a/x.a >> b/x.b
+%meas m
+EOF
+expect <<EOF
+4
+EOF
+
+#------------------------------------------------------------------------------
+
+fped "qualified measurements: \"macro\" qualified (b/a)" <<EOF
+frame x {
+	a: vec @(0mm, 0mm)
+	b: vec .(d, 0mm)
+}
+frame a {
+	set d = 2mm
+	frame x @
+}
+frame b {
+	set d = 3mm
+	frame x @
+}
+frame a @
+vec @(1mm, 0mm)
+frame b .
+meas x.a >> x.b /* dummy */
+m: meas b/x.a >> a/x.b
+%meas m
+EOF
+expect <<EOF
+1
+EOF
+
+###############################################################################


Property changes on: trunk/eda/fped/test/meas_qual
___________________________________________________________________
Name: svn:executable
   + *

Modified: trunk/eda/fped/test/structure
===================================================================
--- trunk/eda/fped/test/structure	2010-05-24 18:02:57 UTC (rev 5966)
+++ trunk/eda/fped/test/structure	2010-05-29 21:13:48 UTC (rev 5967)
@@ -72,6 +72,7 @@
 	a: vec @(0mm, 0mm)
 	b: vec @(1mm, 1mm)
 }
+frame f @
 meas f.a -> f.b
 EOF
 expect <<EOF
@@ -84,6 +85,7 @@
 
 package "_"
 unit mm
+frame f @
 meas f.a -> f.b
 EOF
 




More information about the commitlog mailing list