diff --git a/alliance/src/druc/src/drucompi_l.l b/alliance/src/druc/src/drucompi_l.l
index b65bbac5..7f1a4136 100644
--- a/alliance/src/druc/src/drucompi_l.l
+++ b/alliance/src/druc/src/drucompi_l.l
@@ -1,4 +1,3 @@
-
 %option noinput
 %option nounput
 
@@ -39,6 +38,15 @@ int yylineno;
                            : yytchar)
 #endif
 
+void DrucEcho ( char *text )
+{
+  if ( DrucStructStat.FLAG_VIEW_RULE_MODE == DRUC_VERBOSE )
+  {
+    DrucViewString ( text );
+  }
+}
+
+
 %}
 
 %p 3000
@@ -61,137 +69,217 @@ comment [#]({lettre}*{dec}*{esp}*{pct}*)*{rc}
 %%
 
 
-{blanc}                 { DrucEcho ( yytext );
-                          }
-layer                   { DrucEcho ( yytext );
-                           return(DRUC_LAYER);}
-regle                   { DrucEcho ( yytext );
-                           return(DRUC_REGLE);}
-regles                  { DrucEcho ( yytext );
-                           return(DRUC_REGLES);}
-fin                     { DrucEcho ( yytext );
-                           return(DRUC_FIN);}
-
-define                  { DrucEcho ( yytext );
-                           return(DRUC_DEFINE);}
-undefine                { DrucEcho ( yytext );
-                           return(DRUC_UNDEFINE);}
-caracterise             { DrucEcho ( yytext );
-                           return(DRUC_CARACTERISE);}
-relation                { DrucEcho ( yytext );
-                           return(DRUC_RELATION);}
-
-resize                  { DrucEcho ( yytext );
-                           return(DRUC_RESIZE);}
-exclusion               { DrucEcho ( yytext );
-                           return(DRUC_EXCLUSION);}
-union                   { DrucEcho ( yytext );
-                           return(DRUC_UNION);}
-enveloppe               { DrucEcho ( yytext );
-                           return(DRUC_ENVELOPPE);}
-marge                   { DrucEcho ( yytext );
-                           return(DRUC_MARGE);}
-croix                   { DrucEcho ( yytext );
-                           return(DRUC_CROIX);}
-intersection            { DrucEcho ( yytext );
-                           return(DRUC_INTERSECT);}
-extension               { DrucEcho ( yytext );
-                           return(DRUC_EXTENSION);}
-inclusion               { DrucEcho ( yytext );
-                           return(DRUC_INCLUSION);}
-distance                { DrucEcho ( yytext );
-                           return(DRUC_DISTANCE);}
-
-surface_inter           { DrucEcho ( yytext );
-                           return(DRUC_SURFACE_INTER);}
-longueur_inter          { DrucEcho ( yytext );
-                           return(DRUC_LONG_INTER);}
-largeur_inter           { DrucEcho ( yytext );
-                           return(DRUC_LARGE_INTER);}
-penetre_inter           { DrucEcho ( yytext );
-                           return(DRUC_PENET_INTER);}
-parallele_inter         { DrucEcho ( yytext );
-                           return(DRUC_PARAL_INTER);}
-perpendiculaire_inter   { DrucEcho ( yytext );
-                           return(DRUC_PERPEN_INTER);}
-
-axiale                  { DrucEcho ( yytext );
-                           return(DRUC_AXIALE);}
-geodesique	             { DrucEcho ( yytext );
-                           return(DRUC_GEODESIQUE);}
-frontale  	             { DrucEcho ( yytext );
-                           return(DRUC_FRONTALE);}
-laterale_min            { DrucEcho ( yytext );
-                           return(DRUC_LATERALE_MIN);}
-laterale_max            { DrucEcho ( yytext );
-                           return(DRUC_LATERALE_MAX);}
-
-longueur_min            { DrucEcho ( yytext );
-                           return(DRUC_LONGUEUR_MIN);}
-longueur_max            { DrucEcho ( yytext );
-                           return(DRUC_LONGUEUR_MAX);}
-largeur_min             { DrucEcho ( yytext );
-                           return(DRUC_LARGEUR_MIN);}
-largeur_max             { DrucEcho ( yytext );
-                           return(DRUC_LARGEUR_MAX);}
-superieure              { DrucEcho ( yytext );
-                           return(DRUC_SUP);}
-inferieure              { DrucEcho ( yytext );
-                           return(DRUC_INF);}
-
-surface                 { DrucEcho ( yytext );
-                           return(DRUC_SURFACE);}
-longueur                { DrucEcho ( yytext );
-                           return(DRUC_LONGUEUR);}
-largeur                 { DrucEcho ( yytext );
-                           return(DRUC_LARGEUR);}
-
-notch       	        { DrucEcho ( yytext );
-                           return(DRUC_NOTCH);}
-min         	        { DrucEcho ( yytext );
-                           return(DRUC_MIN);}
-max         	        { DrucEcho ( yytext );
-                           return(DRUC_MAX);}
-"<="		        { DrucEcho ( yytext );
-                           return(DRUC_INFEQ);}
-">="		        { DrucEcho ( yytext );
-                           return(DRUC_SUPEQ);}
-
-"->"		        { DrucEcho ( yytext );
-                           return(DRUC_DESTINATION);}
-
-{decimal}               { DrucEcho ( yytext );
-                           sscanf(yytext,"%d",&DrucInputEntier);
-		  	             return(DRUC_ENTIER);
-                        }
-{reel}                  { DrucEcho ( yytext );
-                           sscanf(  yytext,"%f",& DrucInputFloat);
-		  	             return(DRUC_FLOAT);
-                        }
-{negat}                 { DrucEcho ( yytext );
-                           sscanf(  yytext,"%f",& DrucInputFloat);
-		  	             return(DRUC_NEG_FLOAT);
-                        }
-{ident}                 { DrucEcho ( yytext );
-                           sscanf(yytext,"%s",DrucInputChaine);
-		 	             return(DRUC_NOM);
-                        }
-{comment}               { DrucEcho ( yytext );
-                          }
-.                       { DrucEcho ( yytext );
-                           return (*yytext);}
+{blanc}                                          {
+                                                   DrucEcho ( yytext );
+                                                 }
+layer                                            {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_LAYER;
+                                                 }
+regle|rule                                       {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_REGLE;
+                                                 }
+regles|rules                                     {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_REGLES;
+                                                 }
+fin|end                                          {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_FIN;
+                                                 }
+define                                           {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_DEFINE;
+                                                 }
+undefine                                         {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_UNDEFINE;
+                                                 }
+caracterise|characterize                         {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_CARACTERISE;
+                                                 }
+relation                                         {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_RELATION;
+                                                 }
+                                                 
+resize                                           {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_RESIZE;
+                                                 }
+exclusion                                        {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_EXCLUSION;
+                                                 }
+union                                            {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_UNION;
+                                                 }
+enveloppe|envelope                               {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_ENVELOPPE;
+                                                 }
+marge|margin                                     {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_MARGE;
+                                                 }
+croix|cross                                      {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_CROIX;
+                                                 }
+intersection                                     {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_INTERSECT;
+                                                 }
+extension                                        {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_EXTENSION;
+                                                 }
+inclusion                                        {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_INCLUSION;
+                                                 }
+distance|spacing                                 {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_DISTANCE;
+                                                 }
+surface_inter|intersection_area                  {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_SURFACE_INTER;
+                                                 }
+longueur_inter|intersection_length               {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_LONG_INTER;
+                                                 }
+largeur_inter|intersection_width                 {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_LARGE_INTER;
+                                                 }
+penetre_inter|inclusion_intersection             {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_PENET_INTER;
+                                                 }
+parallele_inter|parallel_intersection            {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_PARAL_INTER;
+                                                 }
+perpendiculaire_inter|perpendicular_intersection {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_PERPEN_INTER;
+                                                 }
+axiale|axial                                     {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_AXIALE;
+                                                 }
+geodesique|geodetic                              {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_GEODESIQUE;
+                                                 }
+frontale                                         {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_FRONTALE;
+                                                 }
+laterale_min|min_sideways                        {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_LATERALE_MIN;
+                                                 }
+laterale_max|max_sideways                        {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_LATERALE_MAX;
+                                                 }
+longueur_min|min_length                          {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_LONGUEUR_MIN;
+                                                 }
+longueur_max|max_length                          {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_LONGUEUR_MAX;
+                                                 }
+largeur_min|min_width                            {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_LARGEUR_MIN;
+                                                 }
+largeur_max|max_width                            {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_LARGEUR_MAX;
+                                                 }
+superieure|superior                              {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_SUP;
+                                                 }
+inferieure|inferior                              {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_INF;
+                                                 }
+surface|area                                     {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_SURFACE;
+                                                 }
+longueur|length                                  {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_LONGUEUR;
+                                                 }
+largeur|width                                    {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_LARGEUR;
+                                                 }
+notch                                            {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_NOTCH;
+                                                 }
+min|">\:"                                        {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_MIN;
+                                                 }
+max|"<\:"                                        {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_MAX;
+                                                 }
+"<="                                             {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_INFEQ;
+                                                 }
+">="                                             {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_SUPEQ;
+                                                 }
+"->"                                             {
+                                                   DrucEcho ( yytext );
+                                                   return DRUC_DESTINATION;
+                                                 }
+{decimal}                                        {
+                                                   DrucEcho ( yytext );
+                                                   sscanf( yytext,"%d", &DrucInputEntier );
+                                                   return DRUC_ENTIER;
+                                                 }
+{reel}                                           {
+                                                   DrucEcho ( yytext );
+                                                   sscanf( yytext,"%f", &DrucInputFloat );
+                                                   return DRUC_FLOAT;
+                                                 }
+{negat}                                          {
+                                                   DrucEcho ( yytext );
+                                                   sscanf( yytext,"%f", &DrucInputFloat );
+                                                   return DRUC_NEG_FLOAT;
+                                                 }
+{ident}                                          {
+                                                   DrucEcho ( yytext );
+                                                   sscanf( yytext,"%s",DrucInputChaine );
+                                                   return DRUC_NOM;
+                                                 }
+{comment}                                        {
+                                                   DrucEcho ( yytext );
+                                                 }
+.                                                {
+                                                   DrucEcho ( yytext );
+                                                   return *yytext;
+                                                 }
 
 %%
 
-void DrucEcho ( text )
+int yywrap( void )
 {
-  if ( DrucStructStat.FLAG_VIEW_RULE_MODE == DRUC_VERBOSE
-     )
-  {
-    DrucViewString ( text );
-  }
+  return 1;
 }
-
-
-int yywrap()
-{ return(1) ; }
diff --git a/alliance/src/druc/src/drucompi_y.y b/alliance/src/druc/src/drucompi_y.y
index 4b6dc2eb..41fa7eb5 100644
--- a/alliance/src/druc/src/drucompi_y.y
+++ b/alliance/src/druc/src/drucompi_y.y
@@ -27,12 +27,13 @@
 \------------------------------------------------------------*/
 extern int   yylineno;
 extern FILE *yyin;
-       int   DrucIndexMesure;
-       int   DrucInputEntier;
-       int   DrucNegatif;
-       float DrucInputFloat;
-       char  DrucInputChaine[DRUC_MAX_STRING_BUFFER + 1];
 extern int   yylex ();
+
+int   DrucIndexMesure;
+int   DrucInputEntier;
+int   DrucNegatif;
+float DrucInputFloat;
+char  DrucInputChaine[DRUC_MAX_STRING_BUFFER + 1];
 %}
 
 /*------------------------------------------------------------\
@@ -40,6 +41,10 @@ extern int   yylex ();
 |                  Druc Types LEX/YACC                        |
 |                                                             |
 \------------------------------------------------------------*/
+%union {
+   unsigned int uint;
+}
+
 /*------------------------------------------------------------\
 |                                                             |
 |                  Druc Terminaux                             |
@@ -54,29 +59,25 @@ extern int   yylex ();
 
             DRUC_UNION         DRUC_EXCLUSION     DRUC_RESIZE
 
-            DRUC_ENVELOPPE     DRUC_MARGE         DRUC_CROIX
-            DRUC_INTERSECT     DRUC_EXTENSION     DRUC_INCLUSION
-            DRUC_DISTANCE
-
-            DRUC_SURFACE_INTER DRUC_LONG_INTER    DRUC_LARGE_INTER
-            DRUC_PENET_INTER   DRUC_PARAL_INTER   DRUC_PERPEN_INTER
-
-            DRUC_FRONTALE      DRUC_LATERALE_MIN  DRUC_LATERALE_MAX
-            DRUC_LARGEUR_MIN   DRUC_LARGEUR_MAX
-            DRUC_LONGUEUR_MIN  DRUC_LONGUEUR_MAX
-            DRUC_SUP           DRUC_INF
-            DRUC_AXIALE        DRUC_GEODESIQUE
-
-            DRUC_SURFACE       DRUC_LONGUEUR      DRUC_LARGEUR
-
-            DRUC_MIN           DRUC_MAX
-            DRUC_INFEQ         DRUC_SUPEQ
-            DRUC_DIFF          DRUC_NOTCH
-
             DRUC_DESTINATION
 
             DRUC_ENTIER        DRUC_FLOAT         DRUC_NEG_FLOAT
 
+%type  <uint> config
+%token <uint> DRUC_DISTANCE DRUC_INTERSECT DRUC_EXTENSION
+              DRUC_INCLUSION DRUC_ENVELOPPE DRUC_MARGE DRUC_CROIX
+%type  <uint> mesure_rel
+%token <uint> DRUC_SURFACE_INTER DRUC_LONG_INTER DRUC_LARGE_INTER
+              DRUC_PENET_INTER DRUC_PARAL_INTER DRUC_PERPEN_INTER
+              DRUC_LONGUEUR_MIN DRUC_LONGUEUR_MAX DRUC_LARGEUR_MIN
+              DRUC_LARGEUR_MAX DRUC_FRONTALE DRUC_LATERALE_MIN
+              DRUC_LATERALE_MAX DRUC_SUP DRUC_INF DRUC_AXIALE
+              DRUC_GEODESIQUE
+%type  <uint> mesure
+%token <uint> DRUC_SURFACE DRUC_LONGUEUR DRUC_LARGEUR DRUC_NOTCH
+%type  <uint> compar
+%token <uint> DRUC_MIN DRUC_MAX DRUC_INFEQ DRUC_SUPEQ '<' '>'
+              '=' DRUC_DIFF
 /*------------------------------------------------------------\
 |                                                             |
 |                  Druc Racine                                |
@@ -93,11 +94,11 @@ extern int   yylex ();
 
 drc       :                  { DrucNombreInstructions = 0;
                                DrucInitCompiler () ;}
-	    list_layer
+            list_layer
             DRUC_REGLES
             list_bloc
             DRUC_FIN
-	    DRUC_REGLES      { return 0;}
+            DRUC_REGLES      { return 0;}
           ;
 
 list_layer: list_layer layer
@@ -105,66 +106,66 @@ list_layer: list_layer layer
           ;
 
 layer     : DRUC_LAYER
-	    DRUC_NOM         { DrucInitRdsLayerName ( DrucInputChaine ) ;}
-	    DRUC_FLOAT       { DrucInitRdsLayerDef ( RprTranslateParam ( DrucInputFloat ) );}
+            DRUC_NOM         { DrucInitRdsLayerName ( DrucInputChaine ) ;}
+            DRUC_FLOAT       { DrucInitRdsLayerDef ( RprTranslateParam ( DrucInputFloat ) );}
             ';'
           ;
 
 list_bloc : list_bloc
             bloc
-	  | bloc
+          | bloc
           ;
 
 bloc      : define           { DrucLoadInstructionDefine () ;}
-	  | undefine         { DrucLoadInstructionUndefine () ;}
+          | undefine         { DrucLoadInstructionUndefine () ;}
           | caracter         { DrucLoadInstructionRegle () ;}
           | relation         { DrucLoadInstructionRegle () ;}
           ;
 
 define    : DRUC_DEFINE
-	    DRUC_NOM         { DrucInitDefineLayerA ( DrucInputChaine ) ;}
+            DRUC_NOM         { DrucInitDefineLayerA ( DrucInputChaine ) ;}
             ','
-	    resiz
+            resiz
             DRUC_DESTINATION
-	    DRUC_NOM         { DrucInitDefineLayerDest ( DrucInputChaine ) ;}
-            ';'              
-	  ;
+            DRUC_NOM         { DrucInitDefineLayerDest ( DrucInputChaine ) ;}
+            ';'
+          ;
 
 resiz     : valresiz
             defmodif
             defoper
-          | DRUC_NOM         { DrucInitDefineLayerB ( DrucInputChaine ) ;} 
+          | DRUC_NOM         { DrucInitDefineLayerB ( DrucInputChaine ) ;}
             compose
           ;
 
-valresiz  :  DRUC_FLOAT      { DrucInitDefineValeur ( RprTranslateParam ( DrucInputFloat)) ;} 
-          | DRUC_NEG_FLOAT   { long i ; 
-                               i =  RprTranslateParam ( DrucInputFloat ); 
+valresiz  :  DRUC_FLOAT      { DrucInitDefineValeur ( RprTranslateParam ( DrucInputFloat)) ;}
+          | DRUC_NEG_FLOAT   { long i ;
+                               i =  RprTranslateParam ( DrucInputFloat );
                                DrucInitDefineValeur ( i );}
           ;
 
 defoper   : ','              { DrucInitOpUnaire   ( ) ;}
-            DRUC_NOM         { DrucInitDefineLayerB ( DrucInputChaine ) ;} 
+            DRUC_NOM         { DrucInitDefineLayerB ( DrucInputChaine ) ;}
             compose
-          | 
+          |
           ;
 
 compose   : DRUC_UNION       { DrucStructDefineOpCompose( DRUC_COMPOSE_UNION );}
-	  | DRUC_INTERSECT   { DrucStructDefineOpCompose( DRUC_COMPOSE_INTERSECT );}
-	  | DRUC_EXCLUSION   { DrucStructDefineOpCompose( DRUC_COMPOSE_EXCLUSION );}
-	  | DRUC_INCLUSION   { DrucStructDefineOpCompose( DRUC_COMPOSE_INCLUSION );}
+          | DRUC_INTERSECT   { DrucStructDefineOpCompose( DRUC_COMPOSE_INTERSECT );}
+          | DRUC_EXCLUSION   { DrucStructDefineOpCompose( DRUC_COMPOSE_EXCLUSION );}
+          | DRUC_INCLUSION   { DrucStructDefineOpCompose( DRUC_COMPOSE_INCLUSION );}
           ;
 
 defmodif  : DRUC_RESIZE      { DrucStructDefineOpCompose( DRUC_COMPOSE_RESIZE    );}
           ;
 
 undefine  : DRUC_UNDEFINE
-	    DRUC_NOM         { DrucInitUndefineUserLayer ( DrucInputChaine ) ;}
+            DRUC_NOM         { DrucInitUndefineUserLayer ( DrucInputChaine ) ;}
             ';'
           ;
 
 caracter  : DRUC_CARACTERISE
-	    DRUC_NOM         { DrucInitRegleLayerA ( DrucInputChaine ) ;
+            DRUC_NOM         { DrucInitRegleLayerA ( DrucInputChaine ) ;
                                DrucInitRegleInstruction ( DRUC_INSTR_CARACTERISE ) ;
                                DrucIndexMesure = -1 ;}
             '('
@@ -179,20 +180,22 @@ lst_rgl_1 : lst_rgl_1
           ;
 
 regle_1   : DRUC_REGLE       { DrucIndexMesure ++ ;}
-	    DRUC_ENTIER      { DrucInitRegleNumero ( DrucInputEntier,
+            DRUC_ENTIER      { DrucInitRegleNumero ( DrucInputEntier,
                                                      DrucIndexMesure) ;}
             ':'
-            mesure
-            compar
-	    DRUC_FLOAT       { DrucInitRegleValeur ( RprTranslateParam ( DrucInputFloat ),
+            mesure           { DrucInitRegleMesure( $6,
+                                                    DrucIndexMesure );}
+            compar           { DrucInitRegleOpCompare ( $8,
+                                                        DrucIndexMesure );}
+            DRUC_FLOAT       { DrucInitRegleValeur ( RprTranslateParam ( DrucInputFloat ),
                                                      DrucIndexMesure );}
             ';'
           ;
 
 relation  : DRUC_RELATION    { DrucInitRegleInstruction ( DRUC_INSTR_RELATION ) ;}
-	    DRUC_NOM         { DrucInitRegleLayerA ( DrucInputChaine ) ;}
+            DRUC_NOM         { DrucInitRegleLayerA ( DrucInputChaine ) ;}
             ','
-	    DRUC_NOM         { DrucInitRegleLayerB ( DrucInputChaine ) ;
+            DRUC_NOM         { DrucInitRegleLayerB ( DrucInputChaine ) ;
                                DrucIndexMesure = -1 ; }
             '('
             lst_rgl_2
@@ -205,103 +208,66 @@ lst_rgl_2 : lst_rgl_2
           | regle_2
           ;
 
-regle_2   : DRUC_REGLE       { DrucIndexMesure ++ ;}
-	    DRUC_ENTIER      { DrucInitRegleNumero ( DrucInputEntier,
-                                                     DrucIndexMesure ) ;}
+regle_2   : DRUC_REGLE         { DrucIndexMesure++ ;}
+            DRUC_ENTIER        { DrucInitRegleNumero ( DrucInputEntier,
+                                                       DrucIndexMesure ) ;}
             ':'
-            config
-            mesure_rel
-            compar
-	    DRUC_FLOAT       { DrucInitRegleValeur ( RprTranslateParam ( DrucInputFloat ),
-                                                     DrucIndexMesure );}
+            config             { DrucInitRegleRelation( $6,
+                                                          DrucIndexMesure );}
+            mesure_rel         { DrucInitRegleMesure( $8,
+                                                      DrucIndexMesure );}
+            compar             { DrucInitRegleOpCompare ( $10,
+                                                          DrucIndexMesure );}
+            DRUC_FLOAT         { DrucInitRegleValeur ( RprTranslateParam ( DrucInputFloat ),
+                                                       DrucIndexMesure );}
             ';'
           ;
 
-config    : DRUC_DISTANCE    { DrucInitRegleRelation( DRUC_RELATION_DISTANCE,
-                                                      DrucIndexMesure );}
-	  | DRUC_INTERSECT   { DrucInitRegleRelation( DRUC_RELATION_INTERSECTION,
-                                                      DrucIndexMesure );}
-	  | DRUC_EXTENSION   { DrucInitRegleRelation( DRUC_RELATION_EXTENSION,
-                                                      DrucIndexMesure );}
-	  | DRUC_INCLUSION   { DrucInitRegleRelation( DRUC_RELATION_INCLUSION,
-                                                      DrucIndexMesure );}
-	  | DRUC_ENVELOPPE   { DrucInitRegleRelation( DRUC_RELATION_ENVELOPPE,
-                                                      DrucIndexMesure );}
-	  | DRUC_MARGE       { DrucInitRegleRelation( DRUC_RELATION_MARGE,
-                                                      DrucIndexMesure );}
-	  | DRUC_CROIX       { DrucInitRegleRelation( DRUC_RELATION_CROIX,
-                                                      DrucIndexMesure );}
+config    : DRUC_DISTANCE      { $$ = DRUC_RELATION_DISTANCE;}
+          | DRUC_INTERSECT     { $$ = DRUC_RELATION_INTERSECTION;}
+          | DRUC_EXTENSION     { $$ = DRUC_RELATION_EXTENSION;}
+          | DRUC_INCLUSION     { $$ = DRUC_RELATION_INCLUSION;}
+          | DRUC_ENVELOPPE     { $$ = DRUC_RELATION_ENVELOPPE;}
+          | DRUC_MARGE         { $$ = DRUC_RELATION_MARGE;}
+          | DRUC_CROIX         { $$ = DRUC_RELATION_CROIX;}
           ;
 
-mesure_rel: DRUC_SURFACE_INTER{ DrucInitRegleMesure( DRUC_MESURE_SURFACE_INTER,
-                                                    DrucIndexMesure );}
-          | DRUC_LONG_INTER  { DrucInitRegleMesure( DRUC_MESURE_LONGUEUR_INTER,
-                                                    DrucIndexMesure );}
-	  | DRUC_LARGE_INTER { DrucInitRegleMesure( DRUC_MESURE_LARGEUR_INTER,
-                                                    DrucIndexMesure );}
-	  | DRUC_PENET_INTER { DrucInitRegleMesure( DRUC_MESURE_PENETRE_INTER,
-                                                    DrucIndexMesure );}
-          | DRUC_PARAL_INTER { DrucInitRegleMesure( DRUC_MESURE_PARALEL_INTER,
-                                                    DrucIndexMesure );}
-          | DRUC_PERPEN_INTER{ DrucInitRegleMesure( DRUC_MESURE_PERPEND_INTER,
-                                                    DrucIndexMesure );}
-	  | DRUC_LONGUEUR_MIN{ DrucInitRegleMesure( DRUC_MESURE_LONGUEUR_MIN,
-                                                    DrucIndexMesure );}
-	  | DRUC_LONGUEUR_MAX{ DrucInitRegleMesure( DRUC_MESURE_LONGUEUR_MAX,
-                                                    DrucIndexMesure );}
-	  | DRUC_LARGEUR_MIN { DrucInitRegleMesure( DRUC_MESURE_LARGEUR_MIN,
-                                                    DrucIndexMesure );}
-	  | DRUC_LARGEUR_MAX { DrucInitRegleMesure( DRUC_MESURE_LARGEUR_MAX,
-                                                    DrucIndexMesure );}
-	  | DRUC_FRONTALE    { DrucInitRegleMesure( DRUC_MESURE_FRONTALE,
-                                                    DrucIndexMesure );}
-	  | DRUC_LATERALE_MIN{ DrucInitRegleMesure( DRUC_MESURE_LATERALE_MIN,
-                                                    DrucIndexMesure );}
-	  | DRUC_LATERALE_MAX{ DrucInitRegleMesure( DRUC_MESURE_LATERALE_MAX,
-                                                    DrucIndexMesure );}
-	  | DRUC_SUP         { DrucInitRegleMesure( DRUC_MESURE_SUP,
-                                                    DrucIndexMesure );}
-	  | DRUC_INF         { DrucInitRegleMesure( DRUC_MESURE_INF,
-                                                    DrucIndexMesure );}
-	  | DRUC_AXIALE      { DrucInitRegleMesure( DRUC_MESURE_AXIALE,
-                                                    DrucIndexMesure );}
-	  | DRUC_GEODESIQUE  { DrucInitRegleMesure( DRUC_MESURE_GEODESIQUE,
-                                                    DrucIndexMesure );}
+mesure_rel: DRUC_SURFACE_INTER { $$ = DRUC_MESURE_SURFACE_INTER;}
+          | DRUC_LONG_INTER    { $$ = DRUC_MESURE_LONGUEUR_INTER;}
+          | DRUC_LARGE_INTER   { $$ = DRUC_MESURE_LARGEUR_INTER;}
+          | DRUC_PENET_INTER   { $$ = DRUC_MESURE_PENETRE_INTER;}
+          | DRUC_PARAL_INTER   { $$ = DRUC_MESURE_PARALEL_INTER;}
+          | DRUC_PERPEN_INTER  { $$ = DRUC_MESURE_PERPEND_INTER;}
+          | DRUC_LONGUEUR_MIN  { $$ = DRUC_MESURE_LONGUEUR_MIN;}
+          | DRUC_LONGUEUR_MAX  { $$ = DRUC_MESURE_LONGUEUR_MAX;}
+          | DRUC_LARGEUR_MIN   { $$ = DRUC_MESURE_LARGEUR_MIN;}
+          | DRUC_LARGEUR_MAX   { $$ = DRUC_MESURE_LARGEUR_MAX;}
+          | DRUC_FRONTALE      { $$ = DRUC_MESURE_FRONTALE;}
+          | DRUC_LATERALE_MIN  { $$ = DRUC_MESURE_LATERALE_MIN;}
+          | DRUC_LATERALE_MAX  { $$ = DRUC_MESURE_LATERALE_MAX;}
+          | DRUC_SUP           { $$ = DRUC_MESURE_SUP;}
+          | DRUC_INF           { $$ = DRUC_MESURE_INF;}
+          | DRUC_AXIALE        { $$ = DRUC_MESURE_AXIALE;}
+          | DRUC_GEODESIQUE    { $$ = DRUC_MESURE_GEODESIQUE;}
           ;
 
-mesure    : DRUC_SURFACE     { DrucInitRegleMesure( DRUC_MESURE_SURFACE,
-                                                    DrucIndexMesure );}
-	  | DRUC_LONGUEUR    { DrucInitRegleMesure( DRUC_MESURE_LONGUEUR,
-                                                    DrucIndexMesure );}
-	  | DRUC_LARGEUR     { DrucInitRegleMesure( DRUC_MESURE_LARGEUR,
-                                                    DrucIndexMesure );}
-	  | DRUC_NOTCH       { DrucInitRegleMesure( DRUC_MESURE_NOTCH,
-                                                    DrucIndexMesure );}
-          | DRUC_SURFACE_INTER { DrucInitRegleMesure( DRUC_MESURE_SURFACE_INTER,
-                                                    DrucIndexMesure );}
-          | DRUC_LONG_INTER  { DrucInitRegleMesure( DRUC_MESURE_LONGUEUR_INTER,
-                                                    DrucIndexMesure );}
-          | DRUC_LARGE_INTER { DrucInitRegleMesure( DRUC_MESURE_LARGEUR_INTER,
-                                                    DrucIndexMesure );}
+mesure    : DRUC_SURFACE       { $$ = DRUC_MESURE_SURFACE;}
+          | DRUC_LONGUEUR      { $$ = DRUC_MESURE_LONGUEUR;}
+          | DRUC_LARGEUR       { $$ = DRUC_MESURE_LARGEUR;}
+          | DRUC_NOTCH         { $$ = DRUC_MESURE_NOTCH;}
+          | DRUC_SURFACE_INTER { $$ = DRUC_MESURE_SURFACE_INTER;}
+          | DRUC_LONG_INTER    { $$ = DRUC_MESURE_LONGUEUR_INTER;}
+          | DRUC_LARGE_INTER   { $$ = DRUC_MESURE_LARGEUR_INTER;}
           ;
 
-compar    : DRUC_MIN         { DrucInitRegleOpCompare ( DRUC_OPERATION_MIN,
-                                                        DrucIndexMesure );}
-	  | DRUC_MAX         { DrucInitRegleOpCompare ( DRUC_OPERATION_MAX,
-                                                        DrucIndexMesure );}
-	  | DRUC_INFEQ       { DrucInitRegleOpCompare ( DRUC_OPERATION_INFEQ,
-                                                        DrucIndexMesure );}
-	  | DRUC_SUPEQ       { DrucInitRegleOpCompare ( DRUC_OPERATION_SUPEQ,
-                                                        DrucIndexMesure );}
-	  | '<'              { DrucInitRegleOpCompare ( DRUC_OPERATION_INF,
-                                                        DrucIndexMesure );}
-	  | '>'              { DrucInitRegleOpCompare ( DRUC_OPERATION_SUP,
-                                                        DrucIndexMesure );}
-          | '='              { DrucInitRegleOpCompare ( DRUC_OPERATION_EQUAL,
-                                                        DrucIndexMesure );}
-          | DRUC_DIFF        { DrucInitRegleOpCompare ( DRUC_OPERATION_DIFF,
-                                                        DrucIndexMesure );}
+compar    : DRUC_MIN           { $$ = DRUC_OPERATION_MIN;}
+          | DRUC_MAX           { $$ = DRUC_OPERATION_MAX;}
+          | DRUC_INFEQ         { $$ = DRUC_OPERATION_INFEQ;}
+          | DRUC_SUPEQ         { $$ = DRUC_OPERATION_SUPEQ;}
+          | '<'                { $$ = DRUC_OPERATION_INF;}
+          | '>'                { $$ = DRUC_OPERATION_SUP;}
+          | '='                { $$ = DRUC_OPERATION_EQUAL;}
+          | DRUC_DIFF          { $$ = DRUC_OPERATION_DIFF;}
           ;
- 
 
 %%
diff --git a/alliance/src/druc/src/drucutil.c b/alliance/src/druc/src/drucutil.c
index bd51c130..271fec28 100644
--- a/alliance/src/druc/src/drucutil.c
+++ b/alliance/src/druc/src/drucutil.c
@@ -89,9 +89,9 @@ void DrucViewString ( String
   if ( DrucStructStat.FLAG_VERBOSE_MODE == DRUC_VERBOSE
      )
   {
-    fprintf ( stdout, 
-              "%s", 
-              String 
+    fprintf ( stdout,
+              "%s",
+              String
             );
     fflush  ( stdout
             );
@@ -113,9 +113,9 @@ void DrucViewNumber ( Number
   if ( DrucStructStat.FLAG_VERBOSE_MODE == DRUC_VERBOSE
      )
   {
-    fprintf ( stdout, 
-              "%3ld", 
-              Number 
+    fprintf ( stdout,
+              "%3ld",
+              Number
             );
   }
 }
@@ -127,7 +127,7 @@ void DrucViewNumber ( Number
 | Calcule et met a jour le checksumm des instructions         |
 | assembleur ecrites dans le fichier  DRUC_OUTPUT_NAME;       |
 
-void DrucComputeCheckSumm ( Value 
+void DrucComputeCheckSumm ( Value
                           )
      int Value;
 
@@ -148,7 +148,7 @@ unsigned int TmpCheckSumm;
 |                                                             |
 \------------------------------------------------------------*/
 
-char *DrucGetRuleComment ( Rule 
+char *DrucGetRuleComment ( Rule
                          )
      long Rule;
 
@@ -158,13 +158,13 @@ DrucTypeStructRuleComment *Scan;
 
   for ( Scan  = DrucRuleCommentList;
         Scan != (DrucTypeStructRuleComment *)NULL;
-        Scan  = Scan->NEXT 
+        Scan  = Scan->NEXT
       )
   {
-    if ( Scan->RULE == Rule 
+    if ( Scan->RULE == Rule
        )
     {
-      return ( Scan->COMMENT 
+      return ( Scan->COMMENT
              );
     }
   }
@@ -187,7 +187,7 @@ DrucTypeStructRuleComment *Scan;
 
   for ( Scan  = DrucRuleCommentList;
         Scan != (DrucTypeStructRuleComment *)NULL;
-        Scan  = Scan->NEXT 
+        Scan  = Scan->NEXT
       )
   {
     DrucViewNumber ( Scan->RULE
@@ -217,7 +217,8 @@ void DrucStatInit ( Flatten,
                     FileType
                   )
      boolean        Flatten;
-     boolean        Verbose;	
+     boolean        Verbose;
+     boolean        View_Rules;
      boolean        FileType;
 
  {
diff --git a/alliance/src/rds/etc/Makefile.am b/alliance/src/rds/etc/Makefile.am
index d5cca76d..3ebdc7d7 100644
--- a/alliance/src/rds/etc/Makefile.am
+++ b/alliance/src/rds/etc/Makefile.am
@@ -1,7 +1,7 @@
 
 etcdir=$(prefix)/etc
 
-etc_DATA=cmos.rds scn6m_deep_09.rds
+etc_DATA=symbolic.rds cmos.rds scn6m_deep_09.rds
 
 EXTRA_DIST=$(etc_DATA)
 
diff --git a/alliance/src/rds/etc/symbolic.rds b/alliance/src/rds/etc/symbolic.rds
new file mode 100644
index 00000000..f79e0daa
--- /dev/null
+++ b/alliance/src/rds/etc/symbolic.rds
@@ -0,0 +1,942 @@
+#=====================================================================
+#
+#                         ALLIANCE VLSI CAD                  
+#              (R)eal (D)ata (S)tructure parameter file
+#          (c) copyright 1992 Laboratory UPMC/MASI/CAO-VLSI   
+#                        all rights reserved                 
+#                   e-mail : cao-vlsi@masi.ibp.fr            
+#
+#                file : symbolic.rds, derived from cmos.rds
+#                             version : 12
+#                     last modif : Mar 19, 2019
+#
+##-------------------------------------------------------------------
+# Symbolic to micron on a 'one lambda equals one micron' basis
+##-------------------------------------------------------------------
+# Refer to the documentation for more precise information.
+#=====================================================================
+# 01/11/09 ALU5/6 pitch 10
+#
+# 99/11/3 ALU5/6 rules
+# . theses rules are preliminary rules, we hope that they wil change
+#   in future. For now, ALU5/6 are dedicated to supplies an clock.
+# 
+# 99/3/22 new symbolics rules
+# . ALU1 width remains 1, ALU2/3/4 is 2
+# . ALU1/2/3/4 spacing (edge to edge) is now 3 for all
+# . GATE to GATE spacing is 3 but POLY wire to POLY wire remains 2
+# . All via stacking are allowed
+#
+# 98/12/1 drc rules were updated
+# spacing VIA to POLY or gate is one rather 2
+# VIA2 and ALU3 appeared
+# . ALU3 width is 3
+# . ALU2/VIA2/ALU3 is resp. 3/1/3
+# . ALU3 edge spacing is 2
+# . stacked VIA/VIA2 is allowed
+# . if they are not stacked they must distant of 2
+# . CONT/VIA2 is free
+# note
+# . stacked CONT/VIA is always not allowed
+# NWELL is automatically drawn with the DIFN and NTIE layers
+#=====================================================================
+
+##-------------------------------------------------------------------
+# PHYSICAL_GRID :
+##-------------------------------------------------------------------
+
+DEFINE  PHYSICAL_GRID  .5
+
+##-------------------------------------------------------------------
+# LAMBDA : 
+##-------------------------------------------------------------------
+
+DEFINE  LAMBDA         1
+
+##-------------------------------------------------------------------
+# TABLE MBK_TO_RDS_SEGMENT :
+#
+# MBK      RDS layer 1                 RDS layer 2         
+# name     name TRANS DLR DWR OFFSET   name TRANS DLR DWR OFFSET  ...
+##-------------------------------------------------------------------
+
+TABLE MBK_TO_RDS_SEGMENT
+
+  PWELL    RDS_PWELL  VW  0.0  0.0  0.0  EXT
+  NWELL    RDS_NWELL  VW  0.0  0.0  0.0  ALL
+  NDIF     RDS_NDIF   VW  0.5  0.0  0.0  ALL
+  PDIF     RDS_PDIF   VW  0.5  0.0  0.0  ALL \
+           RDS_NWELL  VW  1.0  1.0  0.0  ALL
+  NTIE     RDS_NTIE   VW  0.5  0.0  0.0  ALL \
+           RDS_NWELL  VW  1.0  1.0  0.0  ALL
+  PTIE     RDS_PTIE   VW  0.5  0.0  0.0  ALL
+  NTRANS   RDS_POLY   VW  0.0  0.0  0.0  ALL \
+           RDS_NDIF  LCW -1.5  2.0  0.0  EXT \
+           RDS_NDIF  RCW -1.5  2.0  0.0  EXT \
+           RDS_NDIF   VW -1.5  4.0  0.0  DRC \
+           RDS_ACTIV  VW -1.5  5.0  0.0  ALL \
+	   RDS_PWELL  VW -1.5  0.0  0.0  EXT
+  PTRANS   RDS_POLY   VW  0.0  0.0  0.0  ALL \
+           RDS_PDIF  LCW -1.5  2.0  0.0  EXT \
+           RDS_PDIF  RCW -1.5  2.0  0.0  EXT \
+           RDS_PDIF   VW -1.5  4.0  0.0  DRC \
+           RDS_ACTIV  VW -1.5  5.0  0.0  ALL \
+           RDS_NWELL  VW -1.0  5.0  0.0  ALL 
+  POLY     RDS_POLY   VW  0.5  0.0  0.0  ALL
+  POLY2    RDS_POLY2  VW  0.5  0.0  0.0  ALL
+  ALU1     RDS_ALU1   VW  0.5  0.0  0.0  ALL
+  ALU2     RDS_ALU2   VW  1.0  0.0  0.0  ALL
+  ALU3     RDS_ALU3   VW  1.0  0.0  0.0  ALL
+  ALU4     RDS_ALU4   VW  1.0  0.0  0.0  ALL
+  ALU5     RDS_ALU5   VW  1.0  0.0  0.0  ALL 
+  ALU6     RDS_ALU6   VW  1.0  0.0  0.0  ALL 
+  CALU1    RDS_ALU1   VW  1.0  0.0  0.0  ALL
+  CALU2    RDS_ALU2   VW  1.0  0.0  0.0  ALL
+  CALU3    RDS_ALU3   VW  1.0  0.0  0.0  ALL
+  CALU4    RDS_ALU4   VW  1.0  0.0  0.0  ALL
+  CALU5    RDS_ALU5   VW  1.0  0.0  0.0  ALL 
+  CALU6    RDS_ALU6   VW  1.0  0.0  0.0  ALL 
+  TPOLY    RDS_TPOLY  VW  0.5  0.0  0.0  ALL
+  TALU1    RDS_TALU1  VW  0.5  0.0  0.0  ALL
+  TALU2    RDS_TALU2  VW  1.0  0.0  0.0  ALL
+  TALU3    RDS_TALU3  VW  1.0  0.0  0.0  ALL
+  TALU4    RDS_TALU4  VW  1.0  0.0  0.0  ALL
+  TALU5    RDS_TALU5  VW  1.0  0.0  0.0  ALL
+  TALU6    RDS_TALU6  VW  1.0  0.0  0.0  ALL
+
+END
+
+##-------------------------------------------------------------------
+# TABLE MBK_TO_RDS_CONNECTOR :
+#
+# MBK      RDS layer 
+# name     name     DER DWR 
+##-------------------------------------------------------------------
+
+TABLE MBK_TO_RDS_CONNECTOR
+
+  POLY    RDS_POLY  .5  0  
+  POLY2   RDS_POLY2 .5  0  
+  ALU1    RDS_ALU1  .5  0  
+  ALU2    RDS_ALU2 1.0  0  
+  ALU3    RDS_ALU3 1.0  0  
+  ALU4    RDS_ALU4 1.0  0  
+  ALU5    RDS_ALU5 1.0  0  
+  ALU6    RDS_ALU6 1.0  0  
+
+END
+
+##-------------------------------------------------------------------
+# TABLE MBK_TO_RDS_REFERENCE :
+#
+# MBK ref    RDS layer 
+# name       name       width
+##-------------------------------------------------------------------
+
+TABLE MBK_TO_RDS_REFERENCE
+
+  REF_REF    RDS_REF    1
+  REF_CON    RDS_VALU1  2  RDS_TVIA1 1  RDS_TALU2  2
+
+END
+
+##-------------------------------------------------------------------
+# TABLE MBK_TO_RDS_VIA1 :
+#
+# MBK via      RDS layer 1  RDS  layer 2  RDS  layer 3  RDS layer 4      
+# name         name  width  name   width  name   width  name  width  
+##-------------------------------------------------------------------
+
+TABLE MBK_TO_RDS_VIA
+
+  CONT_BODY_P  RDS_ALU1 2 ALL  RDS_CONT 1 ALL  RDS_PTIE 3 ALL  
+  CONT_BODY_N  RDS_ALU1 2 ALL  RDS_CONT 1 ALL  RDS_NTIE 3 ALL  RDS_NWELL 4 ALL
+  CONT_DIF_N   RDS_ALU1 2 ALL  RDS_CONT 1 ALL  RDS_NDIF 3 ALL
+  CONT_DIF_P   RDS_ALU1 2 ALL  RDS_CONT 1 ALL  RDS_PDIF 3 ALL  RDS_NWELL 4 ALL
+  CONT_POLY    RDS_ALU1 2 ALL  RDS_CONT 1 ALL  RDS_POLY 3 ALL
+  CONT_POLY2   RDS_ALU1 2 ALL  RDS_CONT 1 ALL  RDS_POLY2 3 ALL
+  CONT_VIA     RDS_ALU1 2 ALL  RDS_VIA1 1 ALL  RDS_ALU2 2 ALL
+  CONT_VIA2    RDS_ALU2 2 ALL  RDS_VIA2 1 ALL  RDS_ALU3 2 ALL
+  CONT_VIA3    RDS_ALU3 2 ALL  RDS_VIA3 1 ALL  RDS_ALU4 2 ALL
+  CONT_VIA4    RDS_ALU4 2 ALL  RDS_VIA4 1 ALL  RDS_ALU5 2 ALL
+  CONT_VIA5    RDS_ALU5 2 ALL  RDS_VIA5 1 ALL  RDS_ALU6 2 ALL
+  C_X_N        RDS_POLY 1 ALL  RDS_NDIF 5 ALL  RDS_ACTIV 6 ALL
+  C_X_P        RDS_POLY 1 ALL  RDS_PDIF 5 ALL  RDS_NWELL 6 ALL  RDS_ACTIV 6 ALL
+
+END
+
+##-------------------------------------------------------------------
+# TABLE MBK_TO_RDS_BIGVIA_HOLE :
+#
+# MBK via      RDS Hole        
+# name         name  side step mode
+##-------------------------------------------------------------------
+
+TABLE MBK_TO_RDS_BIGVIA_HOLE
+
+CONT_VIA   RDS_VIA1 1 4 ALL
+CONT_VIA2  RDS_VIA2 1 4 ALL
+CONT_VIA3  RDS_VIA3 1 4 ALL
+CONT_VIA4  RDS_VIA4 1 4 ALL   # should be more than 4 
+CONT_VIA5  RDS_VIA5 1 4 ALL   # should be more than 4 
+
+END
+
+##-------------------------------------------------------------------
+# TABLE MBK_TO_RDS_BIGVIA_METAL :
+#
+# MBK via      RDS layer 1                      ...
+# name         name  delta-width overlap mode
+##-------------------------------------------------------------------
+
+TABLE MBK_TO_RDS_BIGVIA_METAL
+
+CONT_VIA  RDS_ALU1 0.0 0.5 ALL RDS_ALU2 0.0 0.5 ALL
+CONT_VIA2 RDS_ALU2 0.0 0.5 ALL RDS_ALU3 0.0 0.5 ALL
+CONT_VIA3 RDS_ALU3 0.0 0.5 ALL RDS_ALU4 0.0 0.5 ALL
+CONT_VIA4 RDS_ALU4 0.0 0.5 ALL RDS_ALU5 0.0 0.5 ALL
+CONT_VIA5 RDS_ALU5 0.0 0.5 ALL RDS_ALU6 0.0 0.5 ALL
+
+END 
+
+##-------------------------------------------------------------------
+# TABLE MBK_TO_RDS_TURNVIA :
+#
+# MBK via      RDS layer 1                      ...
+# name         name  DWR MODE
+##-------------------------------------------------------------------
+
+TABLE MBK_TO_RDS_TURNVIA
+
+CONT_TURN1 RDS_ALU1 0 ALL
+CONT_TURN2 RDS_ALU2 0 ALL
+CONT_TURN3 RDS_ALU3 0 ALL
+CONT_TURN4 RDS_ALU4 0 ALL
+CONT_TURN5 RDS_ALU5 0 ALL
+CONT_TURN6 RDS_ALU6 0 ALL
+
+END
+
+
+##-------------------------------------------------------------------
+# TABLE LYNX_GRAPH :
+#
+# RDS layer   Rds layer 1   Rds layer 2    ...
+# name        name          name           ...
+##-------------------------------------------------------------------
+
+TABLE LYNX_GRAPH
+
+##---------------------------
+#
+# Modifie par L.Jacomme (Pb Bulk/Alim avec Lynx)
+# 23.11.99
+#
+# RDS_NWELL  RDS_NTIE   RDS_NWELL
+# RDS_PWELL  RDS_PTIE   RDS_PWELL
+# RDS_NDIF  RDS_CONT RDS_NDIF
+# RDS_PDIF  RDS_CONT RDS_PDIF
+# RDS_NTIE  RDS_CONT RDS_NTIE RDS_NWELL
+# RDS_PTIE  RDS_CONT RDS_PTIE RDS_PWELL
+
+  RDS_NDIF  RDS_CONT RDS_NDIF
+  RDS_PDIF  RDS_CONT RDS_PDIF
+  RDS_NTIE  RDS_CONT RDS_NTIE
+  RDS_PTIE  RDS_CONT RDS_PTIE
+
+  RDS_POLY  RDS_CONT RDS_POLY 
+  RDS_POLY2  RDS_CONT RDS_POLY2 
+  RDS_CONT  RDS_PDIF RDS_NDIF RDS_POLY RDS_PTIE  RDS_NTIE RDS_ALU1 RDS_CONT
+  RDS_ALU1  RDS_CONT RDS_VIA1 RDS_ALU1 RDS_VALU1 RDS_ALU1
+  RDS_VALU1 RDS_CONT RDS_VIA1 RDS_ALU1 RDS_VALU1
+  RDS_VIA1  RDS_ALU1 RDS_ALU2 RDS_VIA1
+  RDS_VIA2  RDS_ALU2 RDS_ALU3 RDS_VIA2
+  RDS_VIA3  RDS_ALU3 RDS_ALU4 RDS_VIA3
+  RDS_VIA4  RDS_ALU4 RDS_ALU5 RDS_VIA4
+  RDS_VIA5  RDS_ALU5 RDS_ALU6 RDS_VIA5
+  RDS_ALU2  RDS_VIA1 RDS_VIA2 RDS_ALU2 
+  RDS_ALU3  RDS_VIA2 RDS_VIA3 RDS_ALU3
+  RDS_ALU4  RDS_VIA3 RDS_VIA4 RDS_ALU4 
+  RDS_ALU5  RDS_VIA4 RDS_VIA5 RDS_ALU5 
+  RDS_ALU6  RDS_VIA5          RDS_ALU6 
+
+END
+
+##-------------------------------------------------------------------
+# TABLE LYNX_CAPA : 
+#
+# RDS layer   Surface capacitance  Perimetric capacitance
+# name        piF / Micron^2       piF / Micron 
+##-------------------------------------------------------------------
+
+TABLE LYNX_CAPA
+
+  RDS_POLY    1.00e-04    1.00e-04
+  RDS_POLY2   1.00e-04    1.00e-04
+  RDS_ALU1    0.50e-04    0.90e-04
+  RDS_ALU2    0.25e-04    0.95e-04
+  RDS_ALU3    0.25e-04    0.95e-04
+  RDS_ALU4    0.25e-04    0.95e-04
+  RDS_ALU5    0.25e-04    0.95e-04
+  RDS_ALU6    0.25e-04    0.95e-04
+
+END
+
+##-------------------------------------------------------------------
+# TABLE LYNX_RESISTOR :
+#
+# RDS layer   Surface resistor
+# name        Ohm / Micron^2 
+##-------------------------------------------------------------------
+
+TABLE LYNX_RESISTOR
+
+  RDS_POLY    50.0
+  RDS_POLY2   50.0
+  RDS_ALU1     0.1
+  RDS_ALU2     0.05
+  RDS_ALU3     0.05
+  RDS_ALU4     0.05
+  RDS_ALU5     0.05
+  RDS_ALU6     0.05
+
+END
+
+##-------------------------------------------------------------------
+# TABLE LYNX_TRANSISTOR : 
+#
+# MBK layer  Transistor Type  MBK via
+# name       name             name
+##-------------------------------------------------------------------
+
+TABLE LYNX_TRANSISTOR
+
+  NTRANS  NTRANS  C_X_N   RDS_POLY   RDS_NDIF  RDS_NDIF  RDS_PWELL
+  PTRANS  PTRANS  C_X_P   RDS_POLY   RDS_PDIF  RDS_PDIF  RDS_NWELL
+
+END
+
+##-------------------------------------------------------------------
+# TABLE LYNX_DIFFUSION :
+#
+# RDS layer  RDS layer
+# name       name    
+##-------------------------------------------------------------------
+
+TABLE LYNX_DIFFUSION
+END
+
+##-------------------------------------------------------------------
+# TABLE LYNX_BULK_IMPLICIT :
+#
+# RDS layer  Bulk type
+# name       EXPLICIT/IMPLICIT
+##-------------------------------------------------------------------
+
+TABLE LYNX_BULK_IMPLICIT
+
+##---------------------------
+#
+# Modifie par L.Jacomme (Pb Bulk/Alim avec Lynx)
+# 23.11.99
+#
+# NWELL  EXPLICIT
+# PWELL  IMPLICIT
+
+END
+
+
+
+##-------------------------------------------------------------------
+# TABLE S2R_OVERSIZE_DENOTCH :
+##-------------------------------------------------------------------
+
+TABLE S2R_OVERSIZE_DENOTCH 
+END
+
+##-------------------------------------------------------------------
+# TABLE S2R_BLOC_RING_WIDTH :
+##-------------------------------------------------------------------
+
+TABLE S2R_BLOC_RING_WIDTH
+END
+
+##-------------------------------------------------------------------
+# TABLE S2R_MINIMUM_LAYER_WIDTH :
+##-------------------------------------------------------------------
+
+TABLE S2R_MINIMUM_LAYER_WIDTH 
+
+  RDS_NWELL   4
+  RDS_PDIF    2
+  RDS_NTIE    2
+  RDS_PTIE    2
+  RDS_POLY    1
+  RDS_POLY2   1
+  RDS_TPOLY   1
+  RDS_CONT    1
+  RDS_ALU1    1
+  RDS_TALU1   1
+  RDS_VIA1    1
+  RDS_ALU2    2
+  RDS_TALU2   2
+  RDS_VIA2    1
+  RDS_ALU3    2
+  RDS_TALU3   2
+  RDS_VIA3    1
+  RDS_ALU4    2
+  RDS_TALU4   2
+  RDS_VIA4    1
+  RDS_ALU5    2
+  RDS_TALU5   2
+  RDS_VIA5    1
+  RDS_ALU6    2
+  RDS_TALU6   2
+
+END
+
+##-------------------------------------------------------------------
+# TABLE MBK_WIRESETTING :
+##-------------------------------------------------------------------
+#
+# This table is used by ocp, nero & ring. It supplies *symbolic*
+# information about the routing grid, the cell gauge and the power
+# wires.
+
+
+TABLE MBK_WIRESETTING
+
+  X_GRID                  5
+  Y_GRID                  5
+  Y_SLICE                50
+  WIDTH_VDD               6
+  WIDTH_VSS               6
+  TRACK_WIDTH_ALU8        0
+  TRACK_WIDTH_ALU7        2
+  TRACK_WIDTH_ALU6        2
+  TRACK_WIDTH_ALU5        2
+  TRACK_WIDTH_ALU4        2
+  TRACK_WIDTH_ALU3        2
+  TRACK_WIDTH_ALU2        2
+  TRACK_WIDTH_ALU1        2
+  TRACK_SPACING_ALU8      0
+  TRACK_SPACING_ALU7      8
+  TRACK_SPACING_ALU6      8
+  TRACK_SPACING_ALU5      3
+  TRACK_SPACING_ALU4      3
+  TRACK_SPACING_ALU3      3
+  TRACK_SPACING_ALU2      3
+  TRACK_SPACING_ALU1      3
+
+END
+
+
+##-------------------------------------------------------------------
+# TABLE CIF_LAYER :
+##-------------------------------------------------------------------
+
+TABLE CIF_LAYER
+
+  RDS_NWELL    LNWELL
+  RDS_NDIF     LNDIF
+  RDS_PDIF     LPDIF
+  RDS_NTIE     LNTIE
+  RDS_PTIE     LPTIE
+  RDS_POLY     LPOLY
+  RDS_POLY2    LPOLY2
+  RDS_TPOLY    LTPOLY
+  RDS_CONT     LCONT
+  RDS_ALU1     LALU1
+  RDS_VALU1    LVALU1
+  RDS_TALU1    LTALU1
+  RDS_VIA1     LVIA
+  RDS_TVIA1    LTVIA1
+  RDS_ALU2     LALU2
+  RDS_TALU2    LTALU2
+  RDS_VIA2     LVIA2
+  RDS_ALU3     LALU3
+  RDS_TALU3    LTALU3
+  RDS_VIA3     LVIA3
+  RDS_ALU4     LALU4
+  RDS_TALU4    LTALU4
+  RDS_VIA4     LVIA4
+  RDS_ALU5     LALU5
+  RDS_TALU5    LTALU5
+  RDS_VIA5     LVIA5
+  RDS_ALU6     LALU6
+  RDS_TALU6    LTALU6
+  RDS_REF      LREF
+
+END
+
+##-------------------------------------------------------------------
+# TABLE GDS_LAYER :
+##-------------------------------------------------------------------
+
+TABLE GDS_LAYER
+
+  RDS_NWELL    1
+  RDS_NDIF     3
+  RDS_PDIF     4
+  RDS_NTIE     5
+  RDS_PTIE     6
+  RDS_POLY     7
+  RDS_POLY2    8
+  RDS_TPOLY    9
+  RDS_CONT    10
+  RDS_ALU1    11
+  RDS_VALU1   12
+  RDS_TALU1   13
+  RDS_VIA1    14
+  RDS_TVIA1   15
+  RDS_ALU2    16
+  RDS_TALU2   17
+  RDS_VIA2    18
+  RDS_ALU3    19
+  RDS_TALU3   20
+  RDS_VIA3    21
+  RDS_ALU4    22
+  RDS_TALU4   23
+  RDS_VIA4    25
+  RDS_ALU5    26
+  RDS_TALU5   27
+  RDS_VIA5    28
+  RDS_ALU6    29
+  RDS_TALU6   30
+  RDS_REF     24
+
+END
+
+##-------------------------------------------------------------------
+# TABLE S2R_POST_TREAT :
+##-------------------------------------------------------------------
+
+TABLE S2R_POST_TREAT
+
+END
+DRC_RULES
+
+layer RDS_NWELL 4.;
+layer RDS_NTIE 2.;
+layer RDS_PTIE 2.;
+layer RDS_NDIF 2.;
+layer RDS_PDIF 2.;
+layer RDS_ACTIV 2.;
+layer RDS_CONT 1.;
+layer RDS_VIA1 1.;
+layer RDS_VIA2 1.;
+layer RDS_VIA3 1.;
+layer RDS_VIA4 1.;
+layer RDS_VIA5 1.;
+layer RDS_POLY 1.;
+layer RDS_POLY2 1.;
+layer RDS_ALU1 1.;
+layer RDS_ALU2 2.;
+layer RDS_ALU3 2.;
+layer RDS_ALU4 2.;
+layer RDS_ALU5 2.;
+layer RDS_ALU6 2.;
+layer RDS_USER0 1.;
+layer RDS_USER1 1.;
+layer RDS_USER2 1.;
+
+rules
+# Note : ``>:'' is different from ``>=''.
+# >: is applied on polygons and >= is applied on rectangles.
+# There is the same difference between <: and <=.
+# >= is faster than >:, but >: must be used where it is
+# required to consider polygons, for example spacing of
+# two objects in the same layer 
+#
+# There is no rule to check NTIE and PDIF are included in NWELL
+# since this is necessarily true
+#----------------------------------------------------------- 
+
+# Check the NWELL shapes
+#-----------------------
+characterize RDS_NWELL (
+  rule 1 : width >= 4. ;
+  rule 2 : intersection_length >: 4. ;
+  rule 3 : notch >= 12. ;
+);
+relation RDS_NWELL, RDS_NWELL (
+  rule 4 : spacing axial >: 12. ;
+);
+
+# Check RDS_PTIE is really excluded outside NWELL
+#------------------------------------------------
+relation RDS_PTIE, RDS_NWELL (
+  rule 5 : spacing axial >= 7.5;
+  rule 6 : enveloppe intersection_length < 0. ;
+  rule 7 : margin intersection_length < 0. ;
+  rule 8 : cross intersection_length < 0. ;
+  rule 9 : intersection intersection_length < 0. ;
+  rule 10 : extension intersection_length < 0. ;
+  rule 11 : inclusion intersection_length < 0. ;
+);
+
+# Check RDS_NDIF is really excluded outside NWELL
+#------------------------------------------------
+relation RDS_NDIF, RDS_NWELL (
+  rule 12 : spacing axial >= 7.5;
+  rule 13 : enveloppe intersection_length < 0. ;
+  rule 14 : margin intersection_length < 0. ;
+  rule 15 : cross intersection_length < 0. ;
+  rule 16 : intersection intersection_length < 0. ;
+  rule 17 : extension intersection_length < 0. ;
+  rule 18 : inclusion intersection_length < 0. ;
+);
+
+# Check the RDS_PDIF shapes
+#--------------------------
+characterize RDS_PDIF (
+  rule 19 : width >= 2. ;
+  rule 20 : intersection_length >: 2. ;
+  rule 21 : notch >= 3. ;
+);
+relation RDS_PDIF, RDS_PDIF (
+  rule 22 : spacing axial >: 3. ;
+);
+
+# Check the RDS_NDIF shapes
+#--------------------------
+characterize RDS_NDIF (
+  rule 23 : width >= 2. ;
+  rule 24 : intersection_length >: 2. ;
+  rule 25 : notch >= 3. ;
+);
+relation RDS_NDIF, RDS_NDIF (
+  rule 26 : spacing axial >: 3. ;
+);
+
+# Check the RDS_PTIE shapes
+#--------------------------
+characterize RDS_PTIE (
+  rule 27 : width >= 2. ;
+  rule 28 : intersection_length >: 2. ;
+  rule 29 : notch >= 3. ;
+);
+relation RDS_PTIE, RDS_PTIE (
+  rule 30 : spacing axial >: 3. ;
+);
+
+# Check the RDS_NTIE shapes
+#--------------------------
+characterize RDS_NTIE (
+  rule 31 : width >= 2. ;
+  rule 32 : intersection_length >: 2. ;
+  rule 33 : notch >= 3. ;
+);
+relation RDS_NTIE, RDS_NTIE (
+  rule 34 : spacing axial >: 3. ;
+);
+
+define RDS_PDIF, RDS_PTIE union -> ANY_P_DIF;
+define RDS_NDIF, RDS_NTIE union -> ANY_N_DIF;
+
+# Check the ANY_N_DIF ANY_P_DIFF exclusion
+#--------------------------------------
+relation ANY_N_DIF, ANY_P_DIF (
+  rule 35 : spacing axial >= 3. ;
+  rule 36 : enveloppe intersection_length < 0. ;
+  rule 37 : margin intersection_length < 0. ;
+  rule 38 : cross intersection_length < 0. ;
+  rule 39 : intersection intersection_length < 0. ;
+  rule 40 : extension intersection_length < 0. ;
+  rule 41 : inclusion intersection_length < 0. ;
+);
+
+undefine ANY_P_DIF;
+undefine ANY_N_DIF;
+
+define RDS_NDIF, RDS_PDIF union -> NP_DIF;
+
+# Check RDS_POLY related to NP_DIF
+#---------------------------------
+relation RDS_POLY, NP_DIF (
+  rule 42 : spacing axial >= 1. ;
+  rule 43 : intersection intersection_length < 0. ;
+);
+
+define NP_DIF, RDS_POLY intersection -> CHANNEL;
+
+# Check the RDS_POLY shapes
+#--------------------------
+characterize RDS_POLY (
+  rule 44 : width >= 1. ;
+  rule 45 : intersection_length >: 1. ;
+  rule 46 : notch >= 2. ;
+);
+relation RDS_POLY, RDS_POLY (
+  rule 47 : spacing axial >: 2.;
+);
+
+define NP_DIF, RDS_CONT intersection -> CONT_DIFF;
+# Check the CHANNEL shapes
+#--------------------------
+characterize CHANNEL (
+  rule 48 : notch >= 3. ;
+);
+relation CHANNEL, CHANNEL (
+  rule 49 : spacing axial >: 3.;
+);
+
+undefine CHANNEL;
+
+# Check RDS_POLY is distant from ACTIV ZONE of TRANSISTOR
+#--------------------------------------------------------
+relation RDS_POLY, RDS_ACTIV (
+  rule 79 : spacing axial >= 1. ;
+);
+
+relation RDS_POLY, CONT_DIFF (
+  rule 50 : spacing axial >= 2. ;
+);
+
+undefine CONT_DIFF;
+undefine NP_DIF;
+
+
+# Check RDS_ALU1 shapes
+#----------------------
+characterize RDS_ALU1 (
+  rule 51 : width >= 1. ;
+  rule 52 : intersection_length >: 1. ;
+  rule 53 : notch >= 3. ;
+);
+relation RDS_ALU1, RDS_ALU1 (
+  rule 54 : spacing axial >: 3. ;
+);
+
+# Check RDS_ALU2 shapes
+#----------------------
+characterize RDS_ALU2 (
+  rule 55 : width >= 2. ;
+  rule 56 : intersection_length >: 2. ;
+  rule 57 : notch >= 3. ;
+);
+relation RDS_ALU2, RDS_ALU2 (
+  rule 58 : spacing axial >: 3. ;
+);
+
+# Check RDS_ALU3 shapes
+#----------------------
+characterize RDS_ALU3 (
+  rule 59 : width >= 2. ;
+  rule 60 : intersection_length >: 2. ;
+  rule 61 : notch >= 3. ;
+);
+relation RDS_ALU3, RDS_ALU3 (
+  rule 62 : spacing axial >: 3. ;
+);
+
+# Check RDS_ALU4 shapes
+#----------------------
+characterize RDS_ALU4 (
+  rule 63 : width >= 2. ;
+  rule 64 : intersection_length >: 2. ;
+  rule 65 : notch >= 3. ;
+);
+relation RDS_ALU4, RDS_ALU4 (
+  rule 66 : spacing axial >: 3. ;
+);
+
+# Check RDS_ALU5 shapes
+#----------------------
+characterize RDS_ALU5 (
+  rule 80 : width >= 2. ;
+  rule 81 : intersection_length >: 2. ;
+  rule 82 : notch >= 3. ;
+);
+relation RDS_ALU5, RDS_ALU5 (
+  rule 83 : spacing axial >: 3. ;
+);
+
+# Check RDS_ALU6 shapes
+#----------------------
+characterize RDS_ALU6 (
+  rule 84 : width >= 2. ;
+  rule 85 : intersection_length >: 2. ;
+  rule 86 : notch >= 3. ;
+);
+relation RDS_ALU6, RDS_ALU6 (
+  rule 87 : spacing axial >: 3. ;
+);
+
+# Check ANY_VIA layers, stacking are free
+#----------------------------------------
+relation RDS_CONT, RDS_CONT (
+  rule 67 : spacing axial >= 3. ;
+);
+relation RDS_VIA, RDS_VIA (
+  rule 68 : spacing axial >= 4. ;
+);
+relation RDS_VIA2, RDS_VIA2 (
+  rule 69 : spacing axial >= 4. ;
+);
+relation RDS_VIA3, RDS_VIA3 (
+  rule 70 : spacing axial >= 4. ;
+);
+relation RDS_VIA4, RDS_VIA4 (
+  rule 88 : spacing axial >= 4. ;
+);
+relation RDS_VIA5, RDS_VIA5 (
+  rule 89 : spacing axial >= 4. ;
+);
+characterize RDS_CONT (
+  rule 71 : width >= 1. ;
+  rule 72 : length <= 1. ;
+);
+characterize RDS_VIA (
+  rule 73 : width >= 1. ;
+  rule 74 : length <= 1. ;
+);
+characterize RDS_VIA2 (
+  rule 75 : width >= 1. ;
+  rule 76 : length <= 1. ;
+);
+characterize RDS_VIA3 (
+  rule 77 : width >= 1. ;
+  rule 78 : length <= 1. ;
+);
+characterize RDS_VIA4 (
+  rule 90 : width >= 1. ;
+  rule 91 : length <= 1. ;
+);
+characterize RDS_VIA5 (
+  rule 92 : width >= 1. ;
+  rule 93 : length <= 1. ;
+);
+
+# Check the POLY2 shapes
+#-----------------------
+characterize RDS_POLY2 (
+  rule 94 : width >= 1. ;
+  rule 95 : intersection_length >: 1. ;
+  rule 96 : notch >= 5. ;
+);
+relation RDS_POLY2, RDS_POLY2 (
+  rule 97 : spacing axial >: 5. ;
+);
+
+# Check RDS_POLY2 is really included inside RDS_POLY1
+#----------------------------------------------------
+relation RDS_POLY, RDS_POLY2 (
+  rule 98 : spacing axial < 0.;
+  rule 99 : envelope inferior >: 5. ;
+  rule 100 : margin intersection_length < 0. ;
+  rule 101 : cross intersection_length < 0. ;
+  rule 102 : intersection intersection_length < 0. ;
+  rule 103 : extension intersection_length < 0. ;
+  rule 104 : inclusion intersection_length < 0. ;
+);
+
+end rules
+
+DRC_COMMENT
+1 (RDS_NWELL) minimum width 4. 
+2 (RDS_NWELL) minimum width 4. 
+3 (RDS_NWELL) Manhatan distance min 12. 
+4 (RDS_NWELL,RDS_NWELL) Manhatan distance min 12. 
+5 (RDS_PTIE,RDS_NWELL) Manhatan distance min 7.5
+6 (RDS_PTIE,RDS_NWELL) must never been in contact
+7 (RDS_PTIE,RDS_NWELL) must never been in contact
+8 (RDS_PTIE,RDS_NWELL) must never been in contact
+9 (RDS_PTIE,RDS_NWELL) must never been in contact
+10 (RDS_PTIE,RDS_NWELL) must never been in contact
+11 (RDS_PTIE,RDS_NWELL) must never been in contact
+12 (RDS_NDIF,RDS_NWELL) Manhatan distance min 7.5
+13 (RDS_NDIF,RDS_NWELL) must never been in contact
+14 (RDS_NDIF,RDS_NWELL) must never been in contact
+15 (RDS_NDIF,RDS_NWELL) must never been in contact
+16 (RDS_NDIF,RDS_NWELL) must never been in contact
+17 (RDS_NDIF,RDS_NWELL) must never been in contact
+18 (RDS_NDIF,RDS_NWELL) must never been in contact
+19 (RDS_PDIF) minimum width 2. 
+20 (RDS_PDIF) minimum width 2. 
+21 (RDS_PDIF) Manhatan distance min 3. 
+22 (RDS_PDIF,RDS_PDIF) Manhatan distance min 3. 
+23 (RDS_NDIF) minimum width 2. 
+24 (RDS_NDIF) minimum width 2. 
+25 (RDS_NDIF) Manhatan distance min 3. 
+26 (RDS_NDIF,RDS_NDIF) Manhatan distance min 3. 
+27 (RDS_PTIE) minimum width 2. 
+28 (RDS_PTIE) minimum width 2. 
+29 (RDS_PTIE) Manhatan distance min 3. 
+30 (RDS_PTIE,RDS_PTIE) Manhatan distance min 3. 
+31 (RDS_NTIE) minimum width 2. 
+32 (RDS_NTIE) minimum width 2. 
+33 (RDS_NTIE) Manhatan distance min 3. 
+34 (RDS_NTIE,RDS_NTIE) Manhatan distance min 3. 
+35 (ANY_N_DIF,ANY_P_DIF) Manhatan distance min 3. 
+36 (ANY_N_DIF,ANY_P_DIF) must never been in contact
+37 (ANY_N_DIF,ANY_P_DIF) must never been in contact
+38 (ANY_N_DIF,ANY_P_DIF) must never been in contact
+39 (ANY_N_DIF,ANY_P_DIF) must never been in contact
+40 (ANY_N_DIF,ANY_P_DIF) must never been in contact
+41 (ANY_N_DIF,ANY_P_DIF) must never been in contact
+42 (RDS_POLY,ANY_N_DIF) Manhatan distance min 1. 
+43 (RDS_POLY,NP_DIF) bad intersection
+44 (RDS_POLY) minimum width 1. 
+45 (RDS_POLY) minimum width 1. 
+46 (RDS_POLY) Manhatan distance min 2. 
+47 (RDS_POLY,RDS_POLY) Manhatan distance min 2.
+48 (CHANNEL) Manhatan distance min 3. 
+49 (CHANNEL,CHANNEL) Manhatan distance min 3.
+50 (RDS_POLY,CONT_DIFF) Manhatan distance min 2. 
+51 (RDS_ALU1) minimum width 1. 
+52 (RDS_ALU1) minimum width 1. 
+53 (RDS_ALU1) Manhatan distance min 3.
+54 (RDS_ALU1,RDS_ALU1) Manhatan distance min 3.
+55 (RDS_ALU2) minimum width 2. 
+56 (RDS_ALU2) minimum width 2. 
+57 (RDS_ALU2) Manhatan distance min 3. 
+58 (RDS_ALU2,RDS_ALU2) Manhatan distance min 3. 
+59 (RDS_ALU3) minimum width 2. 
+60 (RDS_ALU3) minimum width 2. 
+61 (RDS_ALU3) Manhatan distance min 3. 
+62 (RDS_ALU3,RDS_ALU3) Manhatan distance min 3. 
+63 (RDS_ALU4) minimum width 2. 
+64 (RDS_ALU4) minimum width 2. 
+65 (RDS_ALU4) Manhatan distance min 3. 
+66 (RDS_ALU4,RDS_ALU4) Manhatan distance min 3. 
+67 (RDS_CONT,RDS_CONT) Manhatan distance min 3. 
+68 (RDS_VIA,RDS_VIA) Manhatan distance min 4. 
+69 (RDS_VIA2,RDS_VIA2) Manhatan distance min 4. 
+70 (RDS_VIA3,RDS_VIA3) Manhatan distance min 4. 
+71 (RDS_CONT) minimum width 1. 
+72 (RDS_CONT) maximum length 1. 
+73 (RDS_VIA) minimum width 1. 
+74 (RDS_VIA) maximum length 1. 
+75 (RDS_VIA2) minimum width 1. 
+76 (RDS_VIA2) maximum length 1. 
+77 (RDS_VIA3) minimum width 1. 
+78 (RDS_VIA3) maximum length 1. 
+79 (RDS_POLY,RDS_ACTIV) Manhatan distance min 1. 
+80 (RDS_ALU5) minimum width 2. 
+81 (RDS_ALU5) minimum width 2. 
+82 (RDS_ALU5) Manhatan distance min 4. 
+83 (RDS_ALU5,RDS_ALU5) Manhatan distance min 4. 
+84 (RDS_ALU6) minimum width 2. 
+85 (RDS_ALU6) minimum width 2. 
+86 (RDS_ALU6) Manhatan distance min 4. 
+87 (RDS_ALU6,RDS_ALU6) Manhatan distance min 4. 
+88 (RDS_VIA4,RDS_VIA4) Manhatan distance min 4. 
+89 (RDS_VIA5,RDS_VIA5) Manhatan distance min 4. 
+90 (RDS_VIA4) minimum width 1. 
+91 (RDS_VIA4) maximum length 1. 
+92 (RDS_VIA5) minimum width 1. 
+93 (RDS_VIA5) maximum length 1. 
+94 (RDS_POLY2) minimum width 1. 
+95 (RDS_POLY2) minimum width 1. 
+96 (RDS_POLY2) Manhatan distance min 5. 
+97 (RDS_POLY2,POLY2) Manhatan distance min 5. 
+98 (RDS_POLY,RDS_POLY2) POLY2 must be enclosed by POLY of 5. 
+99 (RDS_POLY,RDS_POLY2) POLY2 must be enclosed by POLY of 5. 
+100 (RDS_POLY,RDS_POLY2) POLY2 must be enclosed by POLY of 5. 
+101 (RDS_POLY,RDS_POLY2) POLY2 must be enclosed by POLY of 5. 
+102 (RDS_POLY,RDS_POLY2) POLY2 must be enclosed by POLY of 5. 
+103 (RDS_POLY,RDS_POLY2) POLY2 must be enclosed by POLY of 5. 
+104 (RDS_POLY,RDS_POLY2) POLY2 must be enclosed by POLY of 5. 
+END_DRC_COMMENT
+END_DRC_RULES
diff --git a/alliance/src/ylwrap b/alliance/src/ylwrap
index 84d56340..1c4d7761 100755
--- a/alliance/src/ylwrap
+++ b/alliance/src/ylwrap
@@ -1,10 +1,9 @@
 #! /bin/sh
 # ylwrap - wrapper for lex/yacc invocations.
 
-scriptversion=2009-04-28.21; # UTC
+scriptversion=2012-12-21.17; # UTC
 
-# Copyright (C) 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004, 2005,
-# 2007, 2009 Free Software Foundation, Inc.
+# Copyright (C) 1996-2013 Free Software Foundation, Inc.
 #
 # Written by Tom Tromey <tromey@cygnus.com>.
 #
@@ -30,9 +29,41 @@ scriptversion=2009-04-28.21; # UTC
 # bugs to <bug-automake@gnu.org> or send patches to
 # <automake-patches@gnu.org>.
 
+get_dirname ()
+{
+  case $1 in
+    */*|*\\*) printf '%s\n' "$1" | sed -e 's|\([\\/]\)[^\\/]*$|\1|';;
+    # Otherwise,  we want the empty string (not ".").
+  esac
+}
+
+# guard FILE
+# ----------
+# The CPP macro used to guard inclusion of FILE.
+guard()
+{
+  printf '%s\n' "$1"                                                    \
+    | sed                                                               \
+        -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'   \
+        -e 's/[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]/_/g'                        \
+        -e 's/__*/_/g'
+}
+
+# quote_for_sed [STRING]
+# ----------------------
+# Return STRING (or stdin) quoted to be used as a sed pattern.
+quote_for_sed ()
+{
+  case $# in
+    0) cat;;
+    1) printf '%s\n' "$1";;
+  esac \
+    | sed -e 's|[][\\.*]|\\&|g'
+}
+
 case "$1" in
   '')
-    echo "$0: No files given.  Try \`$0 --help' for more information." 1>&2
+    echo "$0: No files given.  Try '$0 --help' for more information." 1>&2
     exit 1
     ;;
   --basedir)
@@ -67,6 +98,8 @@ esac
 # The input.
 input="$1"
 shift
+# We'll later need for a correct munging of "#line" directives.
+input_sub_rx=`get_dirname "$input" | quote_for_sed`
 case "$input" in
   [\\/]* | ?:[\\/]*)
     # Absolute path; do nothing.
@@ -76,15 +109,47 @@ case "$input" in
     input="`pwd`/$input"
     ;;
 esac
+input_rx=`get_dirname "$input" | quote_for_sed`
+
+# Since DOS filename conventions don't allow two dots,
+# the DOS version of Bison writes out y_tab.c instead of y.tab.c
+# and y_tab.h instead of y.tab.h. Test to see if this is the case.
+y_tab_nodot=false
+if test -f y_tab.c || test -f y_tab.h; then
+  y_tab_nodot=true
+fi
+
+# The parser itself, the first file, is the destination of the .y.c
+# rule in the Makefile.
+parser=$1
+
+# A sed program to s/FROM/TO/g for all the FROM/TO so that, for
+# instance, we rename #include "y.tab.h" into #include "parse.h"
+# during the conversion from y.tab.c to parse.c.
+sed_fix_filenames=
+
+# Also rename header guards, as Bison 2.7 for instance uses its header
+# guard in its implementation file.
+sed_fix_header_guards=
 
-pairlist=
 while test "$#" -ne 0; do
   if test "$1" = "--"; then
     shift
     break
   fi
-  pairlist="$pairlist $1"
+  from=$1
+  # Handle y_tab.c and y_tab.h output by DOS
+  if $y_tab_nodot; then
+    case $from in
+      "y.tab.c") from=y_tab.c;;
+      "y.tab.h") from=y_tab.h;;
+    esac
+  fi
   shift
+  to=$1
+  shift
+  sed_fix_filenames="${sed_fix_filenames}s|"`quote_for_sed "$from"`"|$to|g;"
+  sed_fix_header_guards="${sed_fix_header_guards}s|"`guard "$from"`"|"`guard "$to"`"|g;"
 done
 
 # The program to run.
@@ -99,7 +164,11 @@ esac
 # FIXME: add hostname here for parallel makes that run commands on
 # other machines.  But that might take us over the 14-char limit.
 dirname=ylwrap$$
-trap "cd '`pwd`'; rm -rf $dirname > /dev/null 2>&1" 1 2 3 15
+do_exit="cd '`pwd`' && rm -rf $dirname > /dev/null 2>&1;"' (exit $ret); exit $ret'
+trap "ret=129; $do_exit" 1
+trap "ret=130; $do_exit" 2
+trap "ret=141; $do_exit" 13
+trap "ret=143; $do_exit" 15
 mkdir $dirname || exit 1
 
 cd $dirname
@@ -111,98 +180,56 @@ esac
 ret=$?
 
 if test $ret -eq 0; then
-  set X $pairlist
-  shift
-  first=yes
-  # Since DOS filename conventions don't allow two dots,
-  # the DOS version of Bison writes out y_tab.c instead of y.tab.c
-  # and y_tab.h instead of y.tab.h. Test to see if this is the case.
-  y_tab_nodot="no"
-  if test -f y_tab.c || test -f y_tab.h; then
-    y_tab_nodot="yes"
-  fi
-
-  # The directory holding the input.
-  input_dir=`echo "$input" | sed -e 's,\([\\/]\)[^\\/]*$,\1,'`
-  # Quote $INPUT_DIR so we can use it in a regexp.
-  # FIXME: really we should care about more than `.' and `\'.
-  input_rx=`echo "$input_dir" | sed 's,\\\\,\\\\\\\\,g;s,\\.,\\\\.,g'`
-
-  while test "$#" -ne 0; do
-    from="$1"
-    # Handle y_tab.c and y_tab.h output by DOS
-    if test $y_tab_nodot = "yes"; then
-      if test $from = "y.tab.c"; then
-    	from="y_tab.c"
-      else
-    	if test $from = "y.tab.h"; then
-    	  from="y_tab.h"
-    	fi
-      fi
-    fi
+  for from in *
+  do
+    to=`printf '%s\n' "$from" | sed "$sed_fix_filenames"`
     if test -f "$from"; then
       # If $2 is an absolute path name, then just use that,
-      # otherwise prepend `../'.
-      case "$2" in
-    	[\\/]* | ?:[\\/]*) target="$2";;
-    	*) target="../$2";;
+      # otherwise prepend '../'.
+      case $to in
+        [\\/]* | ?:[\\/]*) target=$to;;
+        *) target="../$to";;
       esac
 
-      # We do not want to overwrite a header file if it hasn't
-      # changed.  This avoid useless recompilations.  However the
-      # parser itself (the first file) should always be updated,
-      # because it is the destination of the .y.c rule in the
-      # Makefile.  Divert the output of all other files to a temporary
-      # file so we can compare them to existing versions.
-      if test $first = no; then
-	realtarget="$target"
-	target="tmp-`echo $target | sed s/.*[\\/]//g`"
+      # Do not overwrite unchanged header files to avoid useless
+      # recompilations.  Always update the parser itself: it is the
+      # destination of the .y.c rule in the Makefile.  Divert the
+      # output of all other files to a temporary file so we can
+      # compare them to existing versions.
+      if test $from != $parser; then
+        realtarget="$target"
+        target=tmp-`printf '%s\n' "$target" | sed 's|.*[\\/]||g'`
       fi
-      # Edit out `#line' or `#' directives.
-      #
-      # We don't want the resulting debug information to point at
-      # an absolute srcdir; it is better for it to just mention the
-      # .y file with no path.
-      #
-      # We want to use the real output file name, not yy.lex.c for
-      # instance.
-      #
-      # We want the include guards to be adjusted too.
-      FROM=`echo "$from" | sed \
-            -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'\
-            -e 's/[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]/_/g'`
-      TARGET=`echo "$2" | sed \
-            -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'\
-            -e 's/[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]/_/g'`
 
-      sed -e "/^#/!b" -e "s,$input_rx,," -e "s,$from,$2," \
-          -e "s,$FROM,$TARGET," "$from" >"$target" || ret=$?
+      # Munge "#line" or "#" directives.  Don't let the resulting
+      # debug information point at an absolute srcdir.  Use the real
+      # output file name, not yy.lex.c for instance.  Adjust the
+      # include guards too.
+      sed -e "/^#/!b"                           \
+          -e "s|$input_rx|$input_sub_rx|"       \
+          -e "$sed_fix_filenames"               \
+          -e "$sed_fix_header_guards"           \
+        "$from" >"$target" || ret=$?
 
-      # Check whether header files must be updated.
-      if test $first = no; then
-	if test -f "$realtarget" && cmp -s "$realtarget" "$target"; then
-	  echo "$2" is unchanged
-	  rm -f "$target"
-	else
-          echo updating "$2"
+      # Check whether files must be updated.
+      if test "$from" != "$parser"; then
+        if test -f "$realtarget" && cmp -s "$realtarget" "$target"; then
+          echo "$to is unchanged"
+          rm -f "$target"
+        else
+          echo "updating $to"
           mv -f "$target" "$realtarget"
         fi
       fi
     else
-      # A missing file is only an error for the first file.  This
-      # is a blatant hack to let us support using "yacc -d".  If -d
-      # is not specified, we don't want an error when the header
-      # file is "missing".
-      if test $first = yes; then
+      # A missing file is only an error for the parser.  This is a
+      # blatant hack to let us support using "yacc -d".  If -d is not
+      # specified, don't fail when the header file is "missing".
+      if test "$from" = "$parser"; then
         ret=1
       fi
     fi
-    shift
-    shift
-    first=no
   done
-else
-  ret=$?
 fi
 
 # Remove the directory.