Corrigé-type : PARTIE I

/* XXXXXXXXXXXXXXXXXXXXXXXXXX  gram1.2d.bison  XXXXXXXXXXXXXXXXXXXXXXXXXX */
%token SHOW_PAGE  PS_PROLOG
%token NEW_PATH CLOSE_PATH
%token STROKE  FILL
%token MOVE_TO RLINE_TO  SLW
%token INT

%{
void syntaxCheck( char * s ) {
  fprintf( stderr, "<<%s>> ", s );
  }
%}

%%
Page                :   PS_PROLOG   Paths   SHOW_PAGE
                        { syntaxCheck( "Page" ); }
                    ;
                    
Paths               :
                    |   Paths  FilledPolygon
                        { syntaxCheck( "FilledPolygon" ); }
                        
                    |   Paths  Polyline   
                        { syntaxCheck( "Polyline" ); }
                    ;
                    
MoveTo              :   INT  INT  MOVE_TO
                        { syntaxCheck( "MoveTo" ); }
                    ;
                    
FilledPolygon       :   NEW_PATH  MoveTo  RLineToList  CLOSE_PATH   FILL
                    ;

Polyline            :   NEW_PATH  MoveTo  RLineToList  CLOSE_PATH   SetLineWidth  STROKE
                    |   NEW_PATH  MoveTo  RLineToList  SetLineWidth  STROKE
                    ;

RLineToList         :   RLineTo
                        { syntaxCheck( "RLineTo" ); }
                        
                    |   RLineToList   RLineTo
                        { syntaxCheck( "RLineTo" ); }
                    ;  
                    
RLineTo             :   INT  INT  RLINE_TO
                    ;
                    
SetLineWidth        :   INT  SLW
                    ;
%%

/* XXXXXXXXXXXXXXXXXXXXXXXXXX  lex1.2d.flex  XXXXXXXXXXXXXXXXXXXXXXXXXX */

%{
#include "gram1.2d.tab.bison"

void rawCheck( ) { fprintf( stderr,"[%s]", yytext); }
void typedCheck( char *type, char *s ) { fprintf( stderr,"[%s:%s]", type, s); }
%}

%%
setlinewidth  { rawCheck(); return SLW;        }
showpage      { rawCheck(); return SHOW_PAGE;  }
newpath       { rawCheck(); return NEW_PATH;   }
closepath     { rawCheck(); return CLOSE_PATH; }
stroke        { rawCheck(); return STROKE;     }
fill          { rawCheck(); return FILL;       }
moveto        { rawCheck(); return  MOVE_TO;   }
rlineto       { rawCheck(); return RLINE_TO;   }
"%!"          { rawCheck(); return PS_PROLOG;  }
\-?[0-9]+     { rawCheck(); return INT;        }
\n              fprintf( stderr,"\n");;
[ \t]+          fprintf(stderr,"%s", yytext);
.             { fprintf(stderr,"[%s!!!]",yytext); }
%%

Corrigé-type : PARTIE II

/* XXXXXXXXXXXXXXXXXXXXXXXXXX  gram2.1b7.flex  XXXXXXXXXXXXXXXXXXXXXXXXXX */

%token            SHOW_PAGE  PS_PROLOG
%token            NEW_PATH CLOSE_PATH
%token            STROKE  FILL
%token            MOVE_TO RLINE_TO  SLW
%token    INT

%union {
  int  intVal;
}

%{
#include "figs.c"

Fig       currFig;
FigArray  theFigs;

int currX, currY, xOrig, yOrig;

void syntaxCheck( char * s ) {
  fprintf( stderr, "<<%s>> ", s );
  }
%}

%%
Page                :   PS_PROLOG   Paths   SHOW_PAGE
                        { 
                          syntaxCheck( "Page" );
                          genAllFigsCode( theFigs );
                        }
                    ;
                    
Paths               :
                    |   Paths  FilledPolygon
                        { 
                          syntaxCheck( "FilledPolygon" );
                        }
                        
                    |   Paths  Polyline   
                        { syntaxCheck( "Polyline" ); }
                    ;
                    
MoveTo              :   INT  INT  MOVE_TO
                        {  currX = $1;
                           currY = $2;
                           addCoords( &currFig, currY, currX );  // y d'abord !!
                           fprintf( stderr, "<<%d %d MoveTo>>", $1, $2 );
                        }
                    ;
                    
FilledPolygon       :   NewPath  MoveTo  RLineToList  ClosePath   FILL
                        { 
                          setAction( &currFig, 1 );
                          checkFig( currFig );
                          addFig( &theFigs, currFig );
                        }
                    ;

Polyline            :   NewPath  MoveTo  RLineToList  ClosePath   SetLineWidth  STROKE
                        { 
                          setAction( &currFig, 0 );
                          checkFig( currFig );
                          addFig( &theFigs, currFig );
                        }
                        
                    |   NewPath  MoveTo  RLineToList  SetLineWidth  STROKE
                        {
                          setAction( &currFig, 0 );
                          checkFig( currFig );
                          addFig( &theFigs, currFig );
                        }
                    ;
                    
NewPath             :   NEW_PATH
                        { currFig = newFig( );  }
                    ;
                    
ClosePath           :   CLOSE_PATH
                        { addCoords( &currFig, currFig.x[0], currFig.y[0]  );  }
                    ;

RLineToList         :   RLineTo                        
                    |   RLineToList   RLineTo
                    ;  
                    
RLineTo             :   INT  INT  RLINE_TO
                        { currX += $1;  currY += $2;
                          addCoords( &currFig, currY, currX );  // y d'abord !
                          fprintf( stderr, "<<%d %d RLineTo -> x=%d y=%d>>",
                                           $1, $2, currX, currY );
                        }
                    ;
                    
SetLineWidth        :   INT SLW
                        { 
                          setLineWidth( &currFig, (float) $1 );
                          fprintf( stderr, "<<%d SetLineWidth>>", $1 );
                        }
                    ;
%%

/* XXXXXXXXXXXXXXXXXXXXXXXXXX  lex2.1b7.flex  XXXXXXXXXXXXXXXXXXXXXXXXXX */
%{
#include "gram2.1b7.tab.bison"

void rawCheck( ) { fprintf( stderr,"[%s]", yytext); }
void typedCheck( char *type, char *s ) { fprintf( stderr,"[%s:%s]", type, s); }
%}

%%
setlinewidth  { rawCheck(); return SLW;        }
showpage      { rawCheck(); return SHOW_PAGE;  }
newpath       { rawCheck(); return NEW_PATH;   }
closepath     { rawCheck(); return CLOSE_PATH; }
stroke        { rawCheck(); return STROKE;     }
fill          { rawCheck(); return FILL;       }
moveto        { rawCheck(); return MOVE_TO;    }
rlineto       { rawCheck(); return RLINE_TO;   }
"%!"          { rawCheck(); return PS_PROLOG;  }
\-?[0-9]+     { 
                rawCheck();
                sscanf( yytext, "%d", &yylval.intVal );
                return INT;
              }
\n              fprintf( stderr,"\n");;
[ \t]+          fprintf(stderr,"%s", yytext);
.             { fprintf(stderr,"[%s!!!]",yytext); }
%%

/* XXXXXXXXXXXXXXXXXXXXXX Integration dans le GUI Java XXXXXXXXXXXXXXXXXXXXX

Les actions dans la grammaire precedente generent le code Java suivant :
 
v.content.addJFig( new JFig(
new int[] { 300, 300, 400, 400, 300 },
new int[] { 400, 500, 500, 400, 400 },
4.000000f,JFig.Action.STROKE ) );

v.content.addJFig( new JFig(
new int[] { 200, 200, 350, 350, 200 },
new int[] { 300, 350, 350, 300, 300 },
1.000000f,JFig.Action.FILL ) );

Remarques
- la fonction addCoords( ) prend les arguments dans l'ordre y, puis x
- on n'obtient pas exactement la meme figure qu'avec l'afficheur gv,
  a cause de la difference PostScript/Java pour l'orientation des axes Oy
- pour corriger, il faudrait :
  . soustraire et non additionner les deplacements verticaux
  . mais aussi tenir compte de la hauteur de la fenetre de trace
    (sinon les positions respectives des 2 rectangles peuvent etre changees)