riscv
/
alliance
mirror of https://gitlab.lip6.fr/vlsi-eda/alliance.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

English keywords support for RDS file (courtesy of Frederic Petrot).

This commit is contained in:
Jean-Paul Chaput 2019-03-21 11:09:40 +01:00
parent c5d9fbe540
commit 7a8824dd34
6 changed files with 1391 additions and 367 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

348
alliance/src/druc/src/drucompi_l.l
View File

@ -1,4 +1,3 @@
%option noinput %option noinput
%option nounput %option nounput
@ -39,6 +38,15 @@ int yylineno;
: yytchar) : yytchar)
#endif #endif
void DrucEcho ( char *text )
{
if ( DrucStructStat.FLAG_VIEW_RULE_MODE == DRUC_VERBOSE )
{
DrucViewString ( text );
}
}
%} %}
%p 3000 %p 3000
@ -61,137 +69,217 @@ comment [#]({lettre}*{dec}*{esp}*{pct}*)*{rc}
%% %%
{blanc} { DrucEcho ( yytext ); {blanc} {
} DrucEcho ( yytext );
layer { DrucEcho ( yytext ); }
return(DRUC_LAYER);} layer {
regle { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_REGLE);} return DRUC_LAYER;
regles { DrucEcho ( yytext ); }
return(DRUC_REGLES);} regle|rule {
fin { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_FIN);} return DRUC_REGLE;
}
define { DrucEcho ( yytext ); regles|rules {
return(DRUC_DEFINE);} DrucEcho ( yytext );
undefine { DrucEcho ( yytext ); return DRUC_REGLES;
return(DRUC_UNDEFINE);} }
caracterise { DrucEcho ( yytext ); fin|end {
return(DRUC_CARACTERISE);} DrucEcho ( yytext );
relation { DrucEcho ( yytext ); return DRUC_FIN;
return(DRUC_RELATION);} }
define {
resize { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_RESIZE);} return DRUC_DEFINE;
exclusion { DrucEcho ( yytext ); }
return(DRUC_EXCLUSION);} undefine {
union { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_UNION);} return DRUC_UNDEFINE;
enveloppe { DrucEcho ( yytext ); }
return(DRUC_ENVELOPPE);} caracterise|characterize {
marge { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_MARGE);} return DRUC_CARACTERISE;
croix { DrucEcho ( yytext ); }
return(DRUC_CROIX);} relation {
intersection { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_INTERSECT);} return DRUC_RELATION;
extension { DrucEcho ( yytext ); }
return(DRUC_EXTENSION);}
inclusion { DrucEcho ( yytext ); resize {
return(DRUC_INCLUSION);} DrucEcho ( yytext );
distance { DrucEcho ( yytext ); return DRUC_RESIZE;
return(DRUC_DISTANCE);} }
exclusion {
surface_inter { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_SURFACE_INTER);} return DRUC_EXCLUSION;
longueur_inter { DrucEcho ( yytext ); }
return(DRUC_LONG_INTER);} union {
largeur_inter { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_LARGE_INTER);} return DRUC_UNION;
penetre_inter { DrucEcho ( yytext ); }
return(DRUC_PENET_INTER);} enveloppe|envelope {
parallele_inter { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_PARAL_INTER);} return DRUC_ENVELOPPE;
perpendiculaire_inter { DrucEcho ( yytext ); }
return(DRUC_PERPEN_INTER);} marge|margin {
DrucEcho ( yytext );
axiale { DrucEcho ( yytext ); return DRUC_MARGE;
return(DRUC_AXIALE);} }
geodesique { DrucEcho ( yytext ); croix|cross {
return(DRUC_GEODESIQUE);} DrucEcho ( yytext );
frontale { DrucEcho ( yytext ); return DRUC_CROIX;
return(DRUC_FRONTALE);} }
laterale_min { DrucEcho ( yytext ); intersection {
return(DRUC_LATERALE_MIN);} DrucEcho ( yytext );
laterale_max { DrucEcho ( yytext ); return DRUC_INTERSECT;
return(DRUC_LATERALE_MAX);} }
extension {
longueur_min { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_LONGUEUR_MIN);} return DRUC_EXTENSION;
longueur_max { DrucEcho ( yytext ); }
return(DRUC_LONGUEUR_MAX);} inclusion {
largeur_min { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_LARGEUR_MIN);} return DRUC_INCLUSION;
largeur_max { DrucEcho ( yytext ); }
return(DRUC_LARGEUR_MAX);} distance|spacing {
superieure { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_SUP);} return DRUC_DISTANCE;
inferieure { DrucEcho ( yytext ); }
return(DRUC_INF);} surface_inter|intersection_area {
DrucEcho ( yytext );
surface { DrucEcho ( yytext ); return DRUC_SURFACE_INTER;
return(DRUC_SURFACE);} }
longueur { DrucEcho ( yytext ); longueur_inter|intersection_length {
return(DRUC_LONGUEUR);} DrucEcho ( yytext );
largeur { DrucEcho ( yytext ); return DRUC_LONG_INTER;
return(DRUC_LARGEUR);} }
largeur_inter|intersection_width {
notch { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_NOTCH);} return DRUC_LARGE_INTER;
min { DrucEcho ( yytext ); }
return(DRUC_MIN);} penetre_inter|inclusion_intersection {
max { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_MAX);} return DRUC_PENET_INTER;
"<=" { DrucEcho ( yytext ); }
return(DRUC_INFEQ);} parallele_inter|parallel_intersection {
">=" { DrucEcho ( yytext ); DrucEcho ( yytext );
return(DRUC_SUPEQ);} return DRUC_PARAL_INTER;
}
"->" { DrucEcho ( yytext ); perpendiculaire_inter|perpendicular_intersection {
return(DRUC_DESTINATION);} DrucEcho ( yytext );
return DRUC_PERPEN_INTER;
{decimal} { DrucEcho ( yytext ); }
sscanf(yytext,"%d",&DrucInputEntier); axiale|axial {
return(DRUC_ENTIER); DrucEcho ( yytext );
} return DRUC_AXIALE;
{reel} { DrucEcho ( yytext ); }
sscanf( yytext,"%f",& DrucInputFloat); geodesique|geodetic {
return(DRUC_FLOAT); DrucEcho ( yytext );
} return DRUC_GEODESIQUE;
{negat} { DrucEcho ( yytext ); }
sscanf( yytext,"%f",& DrucInputFloat); frontale {
return(DRUC_NEG_FLOAT); DrucEcho ( yytext );
} return DRUC_FRONTALE;
{ident} { DrucEcho ( yytext ); }
sscanf(yytext,"%s",DrucInputChaine); laterale_min|min_sideways {
return(DRUC_NOM); DrucEcho ( yytext );
} return DRUC_LATERALE_MIN;
{comment} { DrucEcho ( yytext ); }
} laterale_max|max_sideways {
. { DrucEcho ( yytext ); DrucEcho ( yytext );
return (*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 return 1;
)
{
DrucViewString ( text );
}
} }
int yywrap()
{ return(1) ; }

244
alliance/src/druc/src/drucompi_y.y
View File

@ -27,12 +27,13 @@
\------------------------------------------------------------*/ \------------------------------------------------------------*/
extern int yylineno; extern int yylineno;
extern FILE *yyin; extern FILE *yyin;
int DrucIndexMesure;
int DrucInputEntier;
int DrucNegatif;
float DrucInputFloat;
char DrucInputChaine[DRUC_MAX_STRING_BUFFER + 1];
extern int yylex (); 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 | | Druc Types LEX/YACC |
| | | |
\------------------------------------------------------------*/ \------------------------------------------------------------*/
%union {
unsigned int uint;
}
/*------------------------------------------------------------\ /*------------------------------------------------------------\
| | | |
| Druc Terminaux | | Druc Terminaux |
@ -54,29 +59,25 @@ extern int yylex ();
DRUC_UNION DRUC_EXCLUSION DRUC_RESIZE 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_DESTINATION
DRUC_ENTIER DRUC_FLOAT DRUC_NEG_FLOAT 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 | | Druc Racine |
@ -93,11 +94,11 @@ extern int yylex ();
drc : { DrucNombreInstructions = 0; drc : { DrucNombreInstructions = 0;
DrucInitCompiler () ;} DrucInitCompiler () ;}
list_layer list_layer
DRUC_REGLES DRUC_REGLES
list_bloc list_bloc
DRUC_FIN DRUC_FIN
DRUC_REGLES { return 0;} DRUC_REGLES { return 0;}
; ;
list_layer: list_layer layer list_layer: list_layer layer
@ -105,66 +106,66 @@ list_layer: list_layer layer
; ;
layer : DRUC_LAYER layer : DRUC_LAYER
DRUC_NOM { DrucInitRdsLayerName ( DrucInputChaine ) ;} DRUC_NOM { DrucInitRdsLayerName ( DrucInputChaine ) ;}
DRUC_FLOAT { DrucInitRdsLayerDef ( RprTranslateParam ( DrucInputFloat ) );} DRUC_FLOAT { DrucInitRdsLayerDef ( RprTranslateParam ( DrucInputFloat ) );}
';' ';'
; ;
list_bloc : list_bloc list_bloc : list_bloc
bloc bloc
| bloc | bloc
; ;
bloc : define { DrucLoadInstructionDefine () ;} bloc : define { DrucLoadInstructionDefine () ;}
| undefine { DrucLoadInstructionUndefine () ;} | undefine { DrucLoadInstructionUndefine () ;}
| caracter { DrucLoadInstructionRegle () ;} | caracter { DrucLoadInstructionRegle () ;}
| relation { DrucLoadInstructionRegle () ;} | relation { DrucLoadInstructionRegle () ;}
; ;
define : DRUC_DEFINE define : DRUC_DEFINE
DRUC_NOM { DrucInitDefineLayerA ( DrucInputChaine ) ;} DRUC_NOM { DrucInitDefineLayerA ( DrucInputChaine ) ;}
',' ','
resiz resiz
DRUC_DESTINATION DRUC_DESTINATION
DRUC_NOM { DrucInitDefineLayerDest ( DrucInputChaine ) ;} DRUC_NOM { DrucInitDefineLayerDest ( DrucInputChaine ) ;}
';' ';'
; ;
resiz : valresiz resiz : valresiz
defmodif defmodif
defoper defoper
| DRUC_NOM { DrucInitDefineLayerB ( DrucInputChaine ) ;} | DRUC_NOM { DrucInitDefineLayerB ( DrucInputChaine ) ;}
compose compose
; ;
valresiz : DRUC_FLOAT { DrucInitDefineValeur ( RprTranslateParam ( DrucInputFloat)) ;} valresiz : DRUC_FLOAT { DrucInitDefineValeur ( RprTranslateParam ( DrucInputFloat)) ;}
| DRUC_NEG_FLOAT { long i ; | DRUC_NEG_FLOAT { long i ;
i = RprTranslateParam ( DrucInputFloat ); i = RprTranslateParam ( DrucInputFloat );
DrucInitDefineValeur ( i );} DrucInitDefineValeur ( i );}
; ;
defoper : ',' { DrucInitOpUnaire ( ) ;} defoper : ',' { DrucInitOpUnaire ( ) ;}
DRUC_NOM { DrucInitDefineLayerB ( DrucInputChaine ) ;} DRUC_NOM { DrucInitDefineLayerB ( DrucInputChaine ) ;}
compose compose
| |
; ;
compose : DRUC_UNION { DrucStructDefineOpCompose( DRUC_COMPOSE_UNION );} compose : DRUC_UNION { DrucStructDefineOpCompose( DRUC_COMPOSE_UNION );}
| DRUC_INTERSECT { DrucStructDefineOpCompose( DRUC_COMPOSE_INTERSECT );} | DRUC_INTERSECT { DrucStructDefineOpCompose( DRUC_COMPOSE_INTERSECT );}
| DRUC_EXCLUSION { DrucStructDefineOpCompose( DRUC_COMPOSE_EXCLUSION );} | DRUC_EXCLUSION { DrucStructDefineOpCompose( DRUC_COMPOSE_EXCLUSION );}
| DRUC_INCLUSION { DrucStructDefineOpCompose( DRUC_COMPOSE_INCLUSION );} | DRUC_INCLUSION { DrucStructDefineOpCompose( DRUC_COMPOSE_INCLUSION );}
; ;
defmodif : DRUC_RESIZE { DrucStructDefineOpCompose( DRUC_COMPOSE_RESIZE );} defmodif : DRUC_RESIZE { DrucStructDefineOpCompose( DRUC_COMPOSE_RESIZE );}
; ;
undefine : DRUC_UNDEFINE undefine : DRUC_UNDEFINE
DRUC_NOM { DrucInitUndefineUserLayer ( DrucInputChaine ) ;} DRUC_NOM { DrucInitUndefineUserLayer ( DrucInputChaine ) ;}
';' ';'
; ;
caracter : DRUC_CARACTERISE caracter : DRUC_CARACTERISE
DRUC_NOM { DrucInitRegleLayerA ( DrucInputChaine ) ; DRUC_NOM { DrucInitRegleLayerA ( DrucInputChaine ) ;
DrucInitRegleInstruction ( DRUC_INSTR_CARACTERISE ) ; DrucInitRegleInstruction ( DRUC_INSTR_CARACTERISE ) ;
DrucIndexMesure = -1 ;} DrucIndexMesure = -1 ;}
'(' '('
@ -179,20 +180,22 @@ lst_rgl_1 : lst_rgl_1
; ;
regle_1 : DRUC_REGLE { DrucIndexMesure ++ ;} regle_1 : DRUC_REGLE { DrucIndexMesure ++ ;}
DRUC_ENTIER { DrucInitRegleNumero ( DrucInputEntier, DRUC_ENTIER { DrucInitRegleNumero ( DrucInputEntier,
DrucIndexMesure) ;} DrucIndexMesure) ;}
':' ':'
mesure mesure { DrucInitRegleMesure( $6,
compar DrucIndexMesure );}
DRUC_FLOAT { DrucInitRegleValeur ( RprTranslateParam ( DrucInputFloat ), compar { DrucInitRegleOpCompare ( $8,
DrucIndexMesure );}
DRUC_FLOAT { DrucInitRegleValeur ( RprTranslateParam ( DrucInputFloat ),
DrucIndexMesure );} DrucIndexMesure );}
';' ';'
; ;
relation : DRUC_RELATION { DrucInitRegleInstruction ( DRUC_INSTR_RELATION ) ;} 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 ; } DrucIndexMesure = -1 ; }
'(' '('
lst_rgl_2 lst_rgl_2
@ -205,103 +208,66 @@ lst_rgl_2 : lst_rgl_2
| regle_2 | regle_2
; ;
regle_2 : DRUC_REGLE { DrucIndexMesure ++ ;} regle_2 : DRUC_REGLE { DrucIndexMesure++ ;}
DRUC_ENTIER { DrucInitRegleNumero ( DrucInputEntier, DRUC_ENTIER { DrucInitRegleNumero ( DrucInputEntier,
DrucIndexMesure ) ;} DrucIndexMesure ) ;}
':' ':'
config config { DrucInitRegleRelation( $6,
mesure_rel DrucIndexMesure );}
compar mesure_rel { DrucInitRegleMesure( $8,
DRUC_FLOAT { DrucInitRegleValeur ( RprTranslateParam ( DrucInputFloat ), DrucIndexMesure );}
DrucIndexMesure );} compar { DrucInitRegleOpCompare ( $10,
DrucIndexMesure );}
DRUC_FLOAT { DrucInitRegleValeur ( RprTranslateParam ( DrucInputFloat ),
DrucIndexMesure );}
';' ';'
; ;
config : DRUC_DISTANCE { DrucInitRegleRelation( DRUC_RELATION_DISTANCE, config : DRUC_DISTANCE { $$ = DRUC_RELATION_DISTANCE;}
DrucIndexMesure );} | DRUC_INTERSECT { $$ = DRUC_RELATION_INTERSECTION;}
| DRUC_INTERSECT { DrucInitRegleRelation( DRUC_RELATION_INTERSECTION, | DRUC_EXTENSION { $$ = DRUC_RELATION_EXTENSION;}
DrucIndexMesure );} | DRUC_INCLUSION { $$ = DRUC_RELATION_INCLUSION;}
| DRUC_EXTENSION { DrucInitRegleRelation( DRUC_RELATION_EXTENSION, | DRUC_ENVELOPPE { $$ = DRUC_RELATION_ENVELOPPE;}
DrucIndexMesure );} | DRUC_MARGE { $$ = DRUC_RELATION_MARGE;}
| DRUC_INCLUSION { DrucInitRegleRelation( DRUC_RELATION_INCLUSION, | DRUC_CROIX { $$ = DRUC_RELATION_CROIX;}
DrucIndexMesure );}
| DRUC_ENVELOPPE { DrucInitRegleRelation( DRUC_RELATION_ENVELOPPE,
DrucIndexMesure );}
| DRUC_MARGE { DrucInitRegleRelation( DRUC_RELATION_MARGE,
DrucIndexMesure );}
| DRUC_CROIX { DrucInitRegleRelation( DRUC_RELATION_CROIX,
DrucIndexMesure );}
; ;
mesure_rel: DRUC_SURFACE_INTER{ DrucInitRegleMesure( DRUC_MESURE_SURFACE_INTER, mesure_rel: DRUC_SURFACE_INTER { $$ = DRUC_MESURE_SURFACE_INTER;}
DrucIndexMesure );} | DRUC_LONG_INTER { $$ = DRUC_MESURE_LONGUEUR_INTER;}
| DRUC_LONG_INTER { DrucInitRegleMesure( DRUC_MESURE_LONGUEUR_INTER, | DRUC_LARGE_INTER { $$ = DRUC_MESURE_LARGEUR_INTER;}
DrucIndexMesure );} | DRUC_PENET_INTER { $$ = DRUC_MESURE_PENETRE_INTER;}
| DRUC_LARGE_INTER { DrucInitRegleMesure( DRUC_MESURE_LARGEUR_INTER, | DRUC_PARAL_INTER { $$ = DRUC_MESURE_PARALEL_INTER;}
DrucIndexMesure );} | DRUC_PERPEN_INTER { $$ = DRUC_MESURE_PERPEND_INTER;}
| DRUC_PENET_INTER { DrucInitRegleMesure( DRUC_MESURE_PENETRE_INTER, | DRUC_LONGUEUR_MIN { $$ = DRUC_MESURE_LONGUEUR_MIN;}
DrucIndexMesure );} | DRUC_LONGUEUR_MAX { $$ = DRUC_MESURE_LONGUEUR_MAX;}
| DRUC_PARAL_INTER { DrucInitRegleMesure( DRUC_MESURE_PARALEL_INTER, | DRUC_LARGEUR_MIN { $$ = DRUC_MESURE_LARGEUR_MIN;}
DrucIndexMesure );} | DRUC_LARGEUR_MAX { $$ = DRUC_MESURE_LARGEUR_MAX;}
| DRUC_PERPEN_INTER{ DrucInitRegleMesure( DRUC_MESURE_PERPEND_INTER, | DRUC_FRONTALE { $$ = DRUC_MESURE_FRONTALE;}
DrucIndexMesure );} | DRUC_LATERALE_MIN { $$ = DRUC_MESURE_LATERALE_MIN;}
| DRUC_LONGUEUR_MIN{ DrucInitRegleMesure( DRUC_MESURE_LONGUEUR_MIN, | DRUC_LATERALE_MAX { $$ = DRUC_MESURE_LATERALE_MAX;}
DrucIndexMesure );} | DRUC_SUP { $$ = DRUC_MESURE_SUP;}
| DRUC_LONGUEUR_MAX{ DrucInitRegleMesure( DRUC_MESURE_LONGUEUR_MAX, | DRUC_INF { $$ = DRUC_MESURE_INF;}
DrucIndexMesure );} | DRUC_AXIALE { $$ = DRUC_MESURE_AXIALE;}
| DRUC_LARGEUR_MIN { DrucInitRegleMesure( DRUC_MESURE_LARGEUR_MIN, | DRUC_GEODESIQUE { $$ = DRUC_MESURE_GEODESIQUE;}
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 : DRUC_SURFACE { DrucInitRegleMesure( DRUC_MESURE_SURFACE, mesure : DRUC_SURFACE { $$ = DRUC_MESURE_SURFACE;}
DrucIndexMesure );} | DRUC_LONGUEUR { $$ = DRUC_MESURE_LONGUEUR;}
| DRUC_LONGUEUR { DrucInitRegleMesure( DRUC_MESURE_LONGUEUR, | DRUC_LARGEUR { $$ = DRUC_MESURE_LARGEUR;}
DrucIndexMesure );} | DRUC_NOTCH { $$ = DRUC_MESURE_NOTCH;}
| DRUC_LARGEUR { DrucInitRegleMesure( DRUC_MESURE_LARGEUR, | DRUC_SURFACE_INTER { $$ = DRUC_MESURE_SURFACE_INTER;}
DrucIndexMesure );} | DRUC_LONG_INTER { $$ = DRUC_MESURE_LONGUEUR_INTER;}
| DRUC_NOTCH { DrucInitRegleMesure( DRUC_MESURE_NOTCH, | DRUC_LARGE_INTER { $$ = DRUC_MESURE_LARGEUR_INTER;}
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 );}
; ;
compar : DRUC_MIN { DrucInitRegleOpCompare ( DRUC_OPERATION_MIN, compar : DRUC_MIN { $$ = DRUC_OPERATION_MIN;}
DrucIndexMesure );} | DRUC_MAX { $$ = DRUC_OPERATION_MAX;}
| DRUC_MAX { DrucInitRegleOpCompare ( DRUC_OPERATION_MAX, | DRUC_INFEQ { $$ = DRUC_OPERATION_INFEQ;}
DrucIndexMesure );} | DRUC_SUPEQ { $$ = DRUC_OPERATION_SUPEQ;}
| DRUC_INFEQ { DrucInitRegleOpCompare ( DRUC_OPERATION_INFEQ, | '<' { $$ = DRUC_OPERATION_INF;}
DrucIndexMesure );} | '>' { $$ = DRUC_OPERATION_SUP;}
| DRUC_SUPEQ { DrucInitRegleOpCompare ( DRUC_OPERATION_SUPEQ, | '=' { $$ = DRUC_OPERATION_EQUAL;}
DrucIndexMesure );} | DRUC_DIFF { $$ = DRUC_OPERATION_DIFF;}
| '<' { DrucInitRegleOpCompare ( DRUC_OPERATION_INF,
DrucIndexMesure );}
| '>' { DrucInitRegleOpCompare ( DRUC_OPERATION_SUP,
DrucIndexMesure );}
| '=' { DrucInitRegleOpCompare ( DRUC_OPERATION_EQUAL,
DrucIndexMesure );}
| DRUC_DIFF { DrucInitRegleOpCompare ( DRUC_OPERATION_DIFF,
DrucIndexMesure );}
; ;
%% %%

27
alliance/src/druc/src/drucutil.c
View File

@ -89,9 +89,9 @@ void DrucViewString ( String
if ( DrucStructStat.FLAG_VERBOSE_MODE == DRUC_VERBOSE if ( DrucStructStat.FLAG_VERBOSE_MODE == DRUC_VERBOSE
) )
{ {
fprintf ( stdout, fprintf ( stdout,
"%s", "%s",
String String
); );
fflush ( stdout fflush ( stdout
); );
@ -113,9 +113,9 @@ void DrucViewNumber ( Number
if ( DrucStructStat.FLAG_VERBOSE_MODE == DRUC_VERBOSE if ( DrucStructStat.FLAG_VERBOSE_MODE == DRUC_VERBOSE
) )
{ {
fprintf ( stdout, fprintf ( stdout,
"%3ld", "%3ld",
Number Number
); );
} }
} }
@ -127,7 +127,7 @@ void DrucViewNumber ( Number
| Calcule et met a jour le checksumm des instructions | | Calcule et met a jour le checksumm des instructions |
| assembleur ecrites dans le fichier DRUC_OUTPUT_NAME; | | assembleur ecrites dans le fichier DRUC_OUTPUT_NAME; |
void DrucComputeCheckSumm ( Value void DrucComputeCheckSumm ( Value
) )
int Value; int Value;
@ -148,7 +148,7 @@ unsigned int TmpCheckSumm;
| | | |
\------------------------------------------------------------*/ \------------------------------------------------------------*/
char *DrucGetRuleComment ( Rule char *DrucGetRuleComment ( Rule
) )
long Rule; long Rule;
@ -158,13 +158,13 @@ DrucTypeStructRuleComment *Scan;
for ( Scan = DrucRuleCommentList; for ( Scan = DrucRuleCommentList;
Scan != (DrucTypeStructRuleComment *)NULL; 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; for ( Scan = DrucRuleCommentList;
Scan != (DrucTypeStructRuleComment *)NULL; Scan != (DrucTypeStructRuleComment *)NULL;
Scan = Scan->NEXT Scan = Scan->NEXT
) )
{ {
DrucViewNumber ( Scan->RULE DrucViewNumber ( Scan->RULE
@ -217,7 +217,8 @@ void DrucStatInit ( Flatten,
FileType FileType
) )
boolean Flatten; boolean Flatten;
boolean Verbose; boolean Verbose;
boolean View_Rules;
boolean FileType; boolean FileType;
{ {

2
alliance/src/rds/etc/Makefile.am
View File

@ -1,7 +1,7 @@
etcdir=$(prefix)/etc 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) EXTRA_DIST=$(etc_DATA)

942
alliance/src/rds/etc/symbolic.rds Normal file
View File

@ -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

195
alliance/src/ylwrap
View File

@ -1,10 +1,9 @@
#! /bin/sh #! /bin/sh
# ylwrap - wrapper for lex/yacc invocations. # 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, # Copyright (C) 1996-2013 Free Software Foundation, Inc.
# 2007, 2009 Free Software Foundation, Inc.
# #
# Written by Tom Tromey <tromey@cygnus.com>. # 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 # bugs to <bug-automake@gnu.org> or send patches to
# <automake-patches@gnu.org>. # <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 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 exit 1
;; ;;
--basedir) --basedir)
@ -67,6 +98,8 @@ esac
# The input. # The input.
input="$1" input="$1"
shift shift
# We'll later need for a correct munging of "#line" directives.
input_sub_rx=`get_dirname "$input" | quote_for_sed`
case "$input" in case "$input" in
[\\/]* | ?:[\\/]*) [\\/]* | ?:[\\/]*)
# Absolute path; do nothing. # Absolute path; do nothing.
@ -76,15 +109,47 @@ case "$input" in
input="`pwd`/$input" input="`pwd`/$input"
;; ;;
esac 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 while test "$#" -ne 0; do
if test "$1" = "--"; then if test "$1" = "--"; then
shift shift
break break
fi 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 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 done
# The program to run. # The program to run.
@ -99,7 +164,11 @@ esac
# FIXME: add hostname here for parallel makes that run commands on # FIXME: add hostname here for parallel makes that run commands on
# other machines. But that might take us over the 14-char limit. # other machines. But that might take us over the 14-char limit.
dirname=ylwrap$$ 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 mkdir $dirname || exit 1
cd $dirname cd $dirname
@ -111,98 +180,56 @@ esac
ret=$? ret=$?
if test $ret -eq 0; then if test $ret -eq 0; then
set X $pairlist for from in *
shift do
first=yes to=`printf '%s\n' "$from" | sed "$sed_fix_filenames"`
# 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
if test -f "$from"; then if test -f "$from"; then
# If $2 is an absolute path name, then just use that, # If $2 is an absolute path name, then just use that,
# otherwise prepend `../'. # otherwise prepend '../'.
case "$2" in case $to in
[\\/]* | ?:[\\/]*) target="$2";; [\\/]* | ?:[\\/]*) target=$to;;
*) target="../$2";; *) target="../$to";;
esac esac
# We do not want to overwrite a header file if it hasn't # Do not overwrite unchanged header files to avoid useless
# changed. This avoid useless recompilations. However the # recompilations. Always update the parser itself: it is the
# parser itself (the first file) should always be updated, # destination of the .y.c rule in the Makefile. Divert the
# because it is the destination of the .y.c rule in the # output of all other files to a temporary file so we can
# Makefile. Divert the output of all other files to a temporary # compare them to existing versions.
# file so we can compare them to existing versions. if test $from != $parser; then
if test $first = no; then realtarget="$target"
realtarget="$target" target=tmp-`printf '%s\n' "$target" | sed 's|.*[\\/]||g'`
target="tmp-`echo $target | sed s/.*[\\/]//g`"
fi 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," \ # Munge "#line" or "#" directives. Don't let the resulting
-e "s,$FROM,$TARGET," "$from" >"$target" || ret=$? # 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. # Check whether files must be updated.
if test $first = no; then if test "$from" != "$parser"; then
if test -f "$realtarget" && cmp -s "$realtarget" "$target"; then if test -f "$realtarget" && cmp -s "$realtarget" "$target"; then
echo "$2" is unchanged echo "$to is unchanged"
rm -f "$target" rm -f "$target"
else else
echo updating "$2" echo "updating $to"
mv -f "$target" "$realtarget" mv -f "$target" "$realtarget"
fi fi
fi fi
else else
# A missing file is only an error for the first file. This # A missing file is only an error for the parser. This is a
# is a blatant hack to let us support using "yacc -d". If -d # blatant hack to let us support using "yacc -d". If -d is not
# is not specified, we don't want an error when the header # specified, don't fail when the header file is "missing".
# file is "missing". if test "$from" = "$parser"; then
if test $first = yes; then
ret=1 ret=1
fi fi
fi fi
shift
shift
first=no
done done
else
ret=$?
fi fi
# Remove the directory. # Remove the directory.