Copie des fichiers du lex/bison, remise en forme du .lex. Totu est à faire dans le .yy

git-svn-id: file:///var/svn/2010-netlemmings/trunk@139 077b3477-7977-48bd-8428-443f22f7bfda

2 files changed, 1152 insertions, 0 deletions

diff --git a/src/parser/parse_ini.lex b/src/parser/parse_ini.lex
new file mode 100644
index 0000000..6a376f9
--- /dev/null
+++ b/src/parser/parse_ini.lex
@@ -0,0 +1,122 @@
+%{
+#include "y.tab.h"
+#include <string.h>
+#define MAX_STR_LEN 255
+
+	int string(int tok) {
+		int lg = strlen(yytext);
+		if ( lg > MAX_STR_LEN ) {
+			return LEXERROR;
+		} else {
+			yylval.str = malloc(sizeof(char)*(lg+1));
+			strcpy(yylval.str, yytext);
+			return tok;
+		}
+	}
+%}
+
+%option nounput
+%option noyywrap
+
+BLANK [ \t]
+NOT_BLANK [^ \t]
+IDENT [a-zA-Z][a-zA-Z0-9_-]*
+NUMBER "-"?[0-9]+
+COMMENT "#"[^\n]*
+
+	/*
+		%s : inclusive start condition (inclus aussi les règles sans <cond>)
+		%x : exclusive start condition (règles sans <cond> inactives)
+	*/
+%x INI_VALUE
+%x STR_M
+%x STR_MM
+%%
+
+"="	{ 
+		BEGIN(INI_VALUE);
+		return AFF;
+	}
+
+<INI_VALUE>\n	{
+			yylineno++;
+			BEGIN(INITIAL);
+			return EOL; 
+		}
+
+<INI_VALUE>{NUMBER}{BLANK}*{COMMENT}?
+		{ 
+			yylval.num = atoi(yytext);
+			return INT;
+		}
+
+<INI_VALUE>","	{
+			return VIR;
+		}
+
+"style"		{ 
+			BEGIN(STR_M);
+			return STYLE;
+		}
+
+"name"		{ 
+			BEGIN(STR_M);
+			return NAME;
+		}
+
+"superlemming"	{ 
+			BEGIN(STR_M);
+			return SLEM;
+		}
+
+"bgColor"i	{ 
+			BEGIN(STR_M);
+			return BGCOLOR;
+		}
+
+"debrisColor"	{ 
+			BEGIN(STR_M);
+			return DEBRISCOLOR;
+		}
+
+"particleColor"	{ 
+			BEGIN(STR_M);
+			return PARTICLECOLOR;
+		}
+
+<STR_M>{BLANK}*"="{BLANK}*
+		{
+			BEGIN(STR_MM);
+			return AFF;
+		}
+
+<STR_M>{BLANK}*
+<STR_MM>{BLANK}*
+
+<STR_MM>{BLANK}*[^\n]*
+		{
+			BEGIN(INITIAL);
+			return string(STR);
+		}
+
+<STR_MM>\n	{
+			yylineno++;
+			BEGIN(INITIAL);
+			return EOL; 
+		}
+
+{IDENT}		{
+			return string(IDENT);
+		}
+
+"#"[^\n]*\n	{ yylineno++; } /* Single line Comment*/
+\r		/* http://fr.wikipedia.org/wiki/Fin_de_ligne : CRLF*/
+\n		{ yylineno++; return EOL; }
+
+{BLANK}*	/* Ignore */
+
+{NOT_BLANK}	{	/* Pour tout ce qu'on a pas encore chopé */
+			fprintf(stderr, "LEX : ERROR : unknown char '%c'", yytext[0]);
+			return LEXERROR;
+		}
+
diff --git a/src/parser/parse_ini.yy b/src/parser/parse_ini.yy
new file mode 100644
index 0000000..cba649c
--- /dev/null
+++ b/src/parser/parse_ini.yy
@@ -0,0 +1,1030 @@
+%{
+#include "y.tab.h"
+
+#include "SDL/SDL.h"
+#include "SDL/SDL_image.h"
+
+#include <sys/types.h>
+#include <dirent.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+	/** time per frame in microseconds - this is the timing everything else is based on */
+#define FPS 150
+	/** redraw animated level obejcts every 3rd frame (about 100ms) */
+#define ANIM_STEP_FPS 3
+
+	// the original formula is: release lemming every 4+(99-speed)/2 time steps
+	// where one step is 60ms (3s/50) or 66ms (4s/60).
+	// Lemmini runs at 30ms/33ms, so the term has to be multiplied by 2
+	// 8+(99-releaseRate) should be correct
+	//releaseBase = 8 + (99 - releaseRate);
+
+	extern FILE *yyin;
+
+	const int TIME_WAIT_TRAP_START = 15000; // milliseconde
+
+	const int INTERFACE_HEIGHT = 150;//200;
+	//Les attributs de l'écran (640 * 480)
+	const int SCREEN_WIDTH = 800;//1280
+	const int SCREEN_HEIGHT = 500; // 480 //SCREEN_HEIGHT =  LEVEL_HEIGHT + INTERFACE_HEIGHT + 30;
+	const int SCREEN_BPP = 32;
+
+	//MINIMAP
+	/*
+#define MINIMAP_X0 420 //636
+#define MINIMAP_Y0 365
+#define MINIMAP_MX 210 //464
+#define MINIMAP_MY 48 //120*/
+
+#define MINIMAP_X0 420
+#define MINIMAP_Y0 325
+#define MINIMAP_MX 350
+#define MINIMAP_MY 175
+
+	const int INTER_BUTTON_X = 0;
+	const int INTER_BUTTON_Y = 50;
+
+	//Les dimensions du niveau
+	const int LEVEL_WIDTH = 1664*2;
+	const int LEVEL_HEIGHT = 160*2;
+
+	// Decale le tableau d'objet
+	//0: lemmfont.gif
+	//1: numfont.gif
+	//2: countdown.gif
+	//3: cursor.gif
+	//4: explode.gif
+	//5: border.gif
+	//6: replay.gif
+	//7: select.gif
+	//8: font7x10.bmp
+	//9: alphabet.gif
+
+	//10: mask_10.gif
+	//11: mask_11.gif
+	//12: mask_6.gif
+	//13: mask_13.gif
+	//14: mask_14.gif
+	//15: mask_15.gif
+	//16: imask_13.gif
+	//17: imask_14.gif
+	//18: imask_15.gif
+#define NBR_ADD_OBJ 19
+	//9-21 : icone_XX.gif
+#define NBR_BUTTON_LEMMING 13
+	const int ADD_OBJ = NBR_ADD_OBJ + NBR_BUTTON_LEMMING;
+
+	//cyan pixel color
+	Uint32 ccc_cyan= 0x00ffff;
+	//yellow pixel color
+	Uint32 ccc_yellow = 0xffff00;
+	//Red pixel color
+	Uint32 ccc_red= 0xff0000;
+	//green pixel color
+	Uint32 ccc_green= 0x00ff00;
+	// erase surface;
+	Uint32 ccc_black= 0x000000;
+
+	// gimp
+	Uint32 ccc_gimp = 0xffffff;
+
+	//Blanc cursor
+	Uint32 ccc_cursor = 0x000000;
+	//Noir colorKeyGif
+	Uint32 ccc_keyGif = 0x000000;
+	// lemming color
+	Uint32 ccc_lemming = 0x001a82;
+
+	// object color
+	// terrain
+	Uint32 ccc_tRemove = 0x007f00ff; // Violet
+	Uint32 ccc_tRemoveNoOverwrite = 0x009932cd; // Lilas
+	Uint32 ccc_tFull = 0xff38b0de; // Ciel d'été
+	Uint32 ccc_tNoOverwrite = 0xff0000ff; // bleu
+	Uint32 ccc_tHidden = 0xff236b8e; // Bleu Acier
+
+	// after conversion
+	// destructible => brick	
+	Uint32 ccc_tBrick = 0x00edaa;//0x00ed4f; // vert
+	// empty => bgStencil
+	Uint32 ccc_bgStencil = 0x000000;
+	// steel
+	// indestructible => steel
+	Uint32 ccc_s = 0xff00aa;//0xff00ff;//rose bonbon
+
+	// object
+	Uint32 ccc_oPassive = 0x6b8ebb;//0x6b8e23; // Vert olive clair
+
+	Uint32 ccc_oNoDigLeft = 0xff7fbb;//0xff7f00; // Thé
+	Uint32 ccc_oNoDigRight = 0xd987bb;//0xd98719; // Ocre
+
+	Uint32 ccc_oTrapDrown = 0x7fffbb;//0x7fff00;// Vert de Hooker
+	Uint32 ccc_oTrapAndNoLem = 0x8c17bb;//0x8c1717; // Ecarlate
+	Uint32 ccc_oTrapAndLem = 0xa62abb;//0xa62a2a; // Brun
+
+	Uint32 ccc_oExit = 0xd9d9bb;//0xd9d919; // Blond
+	Uint32 ccc_oEntry = 0x855ebb;//0x855e42; // Bronze
+
+	Uint32 ccc_oUnknow = 0xffffbb;//0xffffff; // Blanc
+
+
+	// error
+	Uint32 ccc_error = 0x666669;
+
+	// lemming
+	Uint32 ccc_lWalk_on = 0xffddcc;
+
+	Uint32 ccc_lStopper = 0xffffcb;
+
+	Uint32 ccc_lStopperLeft = 0xffbbcb;
+	Uint32 ccc_lStopperRight = 0xffcccb;
+
+
+
+
+	// Config Cam
+	const int CAM_VITESSE = 8;
+	const int BOUND_SENSIBILITE = 50;
+
+
+
+	//Les surfaces
+
+	SDL_Surface *pTerrain = NULL; //Fond avec juste la map
+	SDL_Surface *pSpr_Lem = NULL; // Fond + lemmings + animations
+	SDL_Surface *screen = NULL; // Ecran via la caméra
+	SDL_Surface *pStencil= NULL; // Ecran Stencil
+	SDL_Surface *pStencilFixe= NULL; // Ecran Stencil Fixe
+
+	struct list_int {
+		int val;
+		struct list_int *next;
+	};
+
+	struct val {
+		int type;
+		union ptr_u { char * str; struct list_int *ints;} ptr;
+	};
+
+	//DEBUT NEW CONCEPTION
+
+	// DEBUT: MAP_STRUCTURE
+#define NBR_STYLE_MAP 11
+#define PARTICULE_COUNT 16
+
+	enum eMapStyle {
+		brick , bubble , crystal , dirt , fire , marble ,
+		pillar , rock , snow , special, undefined 
+	};
+
+	char tabString_eMapStyle[NBR_STYLE_MAP][10] = {
+		"brick" , "bubble" , "crystal" , "dirt" , "fire" , "marble" ,
+		"pillar" , "rock" , "snow" , "special", "undefined" 
+	};
+
+	struct colorMap {
+		Uint32 bgColor;// background color present in "style".ini
+		Uint32 debrisColor;// debris color present in "style".ini
+		Uint32* particleColor; //particle color present in "style".ini
+	};
+
+	struct spriteObjet {
+		// ID == Objet.ID
+		int state; // number of state in terraino_XX.gif;
+
+		// animation types
+		// 0 - don't animate
+		// 1 - animate continously
+		// 2 - trap - animate on trigger - else show first pic
+		// 3 - entry animation: animate once at level start
+		int anim;
+
+		// object types
+		// 0  - passive
+		// 3  - no digging to the left
+		// 4  - no digging to the right
+		// 5  - trap which makes lemmings drown (water/quick sand/mud)
+		// 6  - trap which replaces lemming with death animation
+		// 7  - trap which triggers lemming death animation
+		// 8  - exit
+		// 32 - entry	 
+		int type;
+
+		int sound; // numero of sound
+	};	
+
+	struct mapStyle {
+		enum eMapStyle style; // map' style
+		int superLemming; // off = 0; on = 1;		
+		int tiles; // number of terrain_XX.gif present in "style".ini
+		int tilesObjet; //number of terraino_XX.gif
+		int tilesSteel; // number of terrainom_XX.gif
+
+		struct colorMap cmap; // level's info's color
+
+		struct spriteObjet* tabDataSprO; // sprite'data ; default=NULL;
+		SDL_Surface **tabGif; // all gif are stored in; default=NULL;
+	};
+	// FIN: MAP_STRUCTURE
+
+	// DEBUT: LEMMINGS_STRUCTURE 
+	// LEM_JOB == lemm_XX.gif
+
+
+#define MAX_LEM_FALL 3
+#define MAX_LEM_FALL_FLOATER 2
+#define FALLER_MAX 126
+#define FLOATER_TO_FALLER 32
+#define MAX_LEM_FLOATER 2
+
+	/** a jumper moves up two pixels per frame */
+#define MAX_JUMPER_STEP 2
+	/** if a walker jumps up 6 pixels, it becomes a jumper */
+#define MAX_JUMPER_JUMP 4
+#define MAX_BUILD_BRICK 9
+#define MAX_BUILD_END 3
+
+#define WALKER_OBSTACLE_HEIGHT 14
+#define FALLER_STEP 3
+#define FLOATER_STEP 2
+#define FALL_DISTANCE_FALL 8
+#define FALL_DISTANCE_FORCE_FALL  2 * FALL_DISTANCE_FALL
+#define FALL_DISTANCE_FLOAT 32
+#define JUMPER_STEP 2
+#define WALKER_STEP 1
+#define CLIMBER_STEP 1
+#define BASHER_FALL_DISTANCE 6
+#define STEPS_WARNING 9
+#define STEPS_MAX 12
+
+#define LEM_JOB 17
+	//0:	walker
+	//1:	faller
+	//2:	climber
+	//3:	climber_to_walker
+	//4:	floater
+	//5:	splat
+	//6:	stopper
+	//7:	drowning
+	//8:	trap_death
+	//9:	exIt
+	//10:	bomber
+	//11:	builder
+	//12:	builder_end
+	//13:	digger
+	//14:	basher
+	//15:	miner
+	//16:	jumper
+#define OTHER_LEM_JOB 6
+	//17:	died
+	//18:	enter
+	//19:	safe
+	//20: nuke
+	//21: bomber_stopper
+	//22: floater_start
+#define	TOTAL_LEM_JOB LEM_JOB + OTHER_LEM_JOB
+
+
+	enum eLemmingJob {
+		walker , faller , climber , climber_to_walker , floater , 
+		splat , stopper , drowning , trap_death , exIt , bomber,
+		builder , builder_end , digger , basher , miner , jumper ,
+		died , enter , safe , nuke , bomber_stopper , floater_start
+	};
+
+	char tabString_eLemmingJob[TOTAL_LEM_JOB][20] = {
+		"walker" , "faller" , "climber" , "climber_to_walker" , "floater" , 
+		"splat" , "stopper" , "drowning" , "trap_death" , "exIt" , "bomber",
+		"builder" , "builder_end , digger" , "basher" , "miner" , "jumper",
+		"died" , "enter" , "safe" , "nuke", "bomber_stopper", "floater_start"
+	};
+
+	struct lemmingMask {
+		// ID == lemming.ID;
+		int stateM; // number of state in mask_XX.gif;
+		int dirM; // number of direction
+		int cooldown; // after <cooldown> animations of lemming animation, do mask action and increase mask frame idx
+	};
+
+	struct lemmingImask {
+		// ID == lemming.ID;
+		int stateI; // number of state in imask_XX.gif;
+		int dirI; // number of direction
+	};
+
+	struct lemmingJobAndSprite {
+		// ID == lemming.ID;
+		int state; // number of state in lemm_XX.gif;
+		int dir; // direction of lemming: 0=left(do FlipLR); 1=right; default=1;
+		int anim; // animation type: 0=loop, 1=once (state change if finished);
+
+		// foot: director 's foot for collision 's test
+		//	calcul the X' symetry if lemming.dir==0(left)
+		int footX; // position X of right's lemming's foot;
+		int footY; // position Y of right's lemming's foot;
+		int footSize; // size of lemming's foot;
+
+		// mask for screen ...
+		struct lemmingMask* mask; // mask of this job; default=NULL;
+		struct lemmingImask* imask; // imask of this job; default=NULL;
+	};
+	// FIN: LEMMINGS_STRUCTURE
+
+	// DEBUT: INFOMAP
+#define IDENT_COUNT 12
+
+	enum eParaMap { 	
+		releaseRate,numLemmings,numToRescue,timeLimit,
+		numClimbers,numFloaters,numBombers,numBlockers,numBuilders,
+		numBashers,numMiners,numDiggers 
+	};
+
+	char tabString_eParaMap[IDENT_COUNT][32] = {
+		"releaseRate","numLemmings","numToRescue","timeLimit",
+		"numClimbers","numFloaters","numBombers","numBlockers",
+		"numBuilders","numBashers","numMiners","numDiggers"
+	};
+
+	struct infoMap {
+		char* name; // map name; default=NULL;
+		int paraMap[IDENT_COUNT]; // some parameter of this map
+		int xPos; // camera started position
+		int MaxFallDistance; // max pixel lemming fall before died;default=0;
+		int nuke; // hiroshima= 1; default =0;
+		int nbrEntry; // number of entry in this map; default=0;
+		struct mapStyle map; // map
+		struct lemmingJobAndSprite *lemmingDATA; // DATA of lemmingJob; default=NULL; 
+	};
+	// FIN: INFOMAP
+
+	// DEBUT: GAMEINIT
+	struct paraTerrain {
+		int modif; //modifier: 8=NO_OVERWRITE, 4=UPSIDE_DOWN, 2=REMOVE (combining allowed, 0=FULL);
+	};
+
+	struct paraObjet {
+		int UD; // upside down (0,1);
+		int paintMode;// paint modes: 8=VIS_ON_TERRAIN, 4=NO_OVERWRITE, 0=FULL (only one value possible)
+		int cptState; // count number of frame for an animation at once, default=0;
+	};
+
+	struct paraSteel {
+		int w;// weight
+		int h;// height
+	};
+
+	struct paraLemming {
+		int dir; // direction of lemming; default=1;
+		int climber; // skill climber; default = 0;
+		int blocker; // skill blocker; default = 0;
+		int bomber; // skill bomber; default = -1;
+		int floater; // skill floater; default = 0;
+		int nuke; // nuked or not; default=0;
+		int cptFall; // count number of pixel when lemming falling;default = 0;
+		int cptFall2;// count number of pixel when lemming falling;default = 0;
+		int cptJump; // count number of pixel when lemming jumping;default = 0;
+		int cptBrick; // count number of brick ;default = 0;
+		int cptBoom; // count number of boom ;default = -1;
+		int cptState; // count number of frame for an animation at once, default=0;
+	};
+
+	struct listeSimplementChainee {
+		int ID; // ID for tabGif;
+		int x; // x position;
+		int y; // y position;
+
+		union listeDataType { 
+			struct paraTerrain *pt; // other para about terrain; default=NULL;
+			struct paraObjet *po; // other para about objet; default=NULL;
+			struct paraSteel *ps; // other para about steel; default=NULL;
+			struct paraLemming *pl; // other para about lemming; default=NULL;
+		} data;
+
+		struct listeSimplementChainee *next;// default=NULL;
+	};
+
+	struct terrain {
+		int nbr; // number of terrain on this map; default=0;
+		struct listeSimplementChainee *lt; // list of terrain; default=NULL;
+	};
+
+	struct objet {
+		int nbr; // number of objet on this map; default=0;
+		struct listeSimplementChainee *lo; // list of objet; default=NULL;
+	};
+
+	struct steel {
+		int nbr; // number of steel on this map; default=0;
+		struct listeSimplementChainee *ls; // list of steel; default=NULL;
+	};
+
+	struct lemming {
+		int nbrInput; // number of lemming will be create; default=0;
+		int nbr; // number of lemming on this map; default=0;
+		int nbrDied; // number of lemming Died on this map; default=0;
+		int nbrSafe; // number of lemming Saved on this map; default=0;
+		struct listeSimplementChainee *ll; // list of lemming; default=NULL;
+	};
+
+	// game use some cpt
+#define NBR_CPT 20
+
+	struct gameInit {
+		struct infoMap mapI; // all DATA of the map;
+		struct terrain t; // all DATA of terrain on this map;
+		struct objet o; // all DATA of objet on this map;
+		struct steel s; // all DATA of steel on this map;
+		struct lemming l; // all DATA of lemming on this map;
+		// 0-13 : BUTTON_LEMMING state button 0: off; 1: on;
+		// 14 : CURSOR STATE
+		// 15 : FREE CPT: for all need it ...; default=0;
+		// 16 : NBR_ENTRY OPEN; default=0;
+		// 17 : clic on mouse on lemning skill; default=-1;
+		// 18 : clic on mouse on lemning;default=0;
+		int cptGame[NBR_CPT]; // default=0;
+	};
+	// FIN: GAMEINIT
+
+	//FIN NEW CONCEPTION
+
+	enum sens { UD , LR };
+
+	extern int yylineno; // Bidouille pour avoir le numero de ligne du lexer ^^
+
+	int yylex();
+	void yyerror(struct gameInit *gInit, char *s);
+
+	SDL_Surface *load_image( char* filename, Uint32 cbg );
+
+	//	void apply_surface( int x, int y, SDL_Surface* source, SDL_Surface* destination, SDL_Rect* clip );
+
+	int init();
+
+	SDL_Surface* flipSurfaceUD_LR(SDL_Surface* src, enum sens sensO, Uint32 c);
+
+	int load_fields(char *folder, struct gameInit *gInit, int tabnum[255] );
+
+	int afficher(struct gameInit *gInit);
+
+	int load_files(struct gameInit *gInit);
+
+	int clean_up();
+
+	int anim_objet(int typeS, int typeO, int cptFps, int frames, int *cpt, struct gameInit *gInit);// returne le state de l'oblet a afficher
+
+	Uint32 get_pixel32( int x, int y, SDL_Surface *surface );
+
+	int putPixel(SDL_Surface *surface,Uint16 x,Uint16 y,Uint32 color);
+
+	int checkPixelDOWN(int nbr,  int x, int y );
+
+	int checkPixelUP(int nbr, int x, int y, int size );
+
+	int outOfLowerMap(int y);
+
+	int aboveGround(int x, int y);
+
+	int midY(int y, int size);
+
+	int reachedPlateau(int x, int y, int size, int dir);
+
+	int stencilMid(int x, int y);
+
+	int turnedByStopper(int x, int y, int dir);
+
+	int explode(int x, int y, int size);
+
+	int stateLemming(struct gameInit *gInit);
+
+	int ereasePx(int x,int y,SDL_Surface *s,Uint32 bgColor);
+
+	struct listeSimplementChainee* rev_listeO (struct listeSimplementChainee* liste);
+
+	int initGame(struct gameInit *gInit);
+
+	int creationLemming(struct gameInit *gInit);
+
+	int paint_terrain (struct gameInit *gInit, int choix);
+
+	int paint_manip(SDL_Surface *spr,SDL_Rect from,SDL_Surface *t,SDL_Rect to,Uint32 ccc_t, Uint32 ccc_spr, int mode, SDL_Surface *stencil);
+
+	int paint_objet (struct gameInit *gInit, int cptFps);
+
+	int paint_objet_stencil (struct gameInit *gInit, int cptFps);
+
+	int supprLem (struct gameInit *gInit, int cptFps);
+
+	int paint_lemming (struct gameInit *gInit, int cptFps);
+
+	int test_O_UD(int UD);
+
+	Uint32 string_to_Uint32 (char* c, int taille);
+
+	Uint32* tab_of_string_to_Uint32 (char* c, int taille);
+
+	int paint_letters (char* text);
+
+	int findTerrain( struct gameInit *gInit,int x, int y, int x0);
+
+	int paint_cursor(SDL_Surface *dst1,SDL_Surface *dst2, SDL_Surface *src, int x, int y, int x0, struct gameInit *gInit);
+
+	int print_num(SDL_Surface *dst, SDL_Surface *font, int x, int y, int value);
+
+	int print_alpha(SDL_Surface *dst, SDL_Surface *src, int x, int y, char* msg);
+
+	int	paint_bomber(int x,int y,int xMax,SDL_Surface *cooldown,SDL_Surface *dst,int cpt);	
+
+	int testAlpha(SDL_Surface *dst, SDL_Surface *src,SDL_Surface *src2, int x, int y);
+
+	int legende (struct gameInit *gInit);
+
+	int paint_interface(struct gameInit *gInit);
+
+	int giveSkill (struct gameInit *gInit, struct listeSimplementChainee* k, int skill );
+
+	int mouse_action (struct gameInit *gInit, int x, int y, int camX , int camY);
+
+	int lancement();
+
+	int test_blit(SDL_Surface *spr,SDL_Rect* from,SDL_Surface *t,SDL_Rect* to);
+
+	int test_FillRect( SDL_Surface *t, SDL_Rect *to, Uint32 ccc);
+
+	int miniMap (SDL_Surface *s, int x0, int y0, float coefX, float coefY);
+
+	int paint_stencil=0;
+
+	%}
+
+	%parse-param { struct gameInit *gInit }
+
+	%union {char* str; int num; struct list_int *ints; struct val *val;}
+
+	%token LEXERROR
+	%token STYLE
+	%token NAME
+	%token SLEM
+	%token BGCOLOR
+	%token DEBRISCOLOR
+	%token PARTICLECOLOR
+	%token AFF
+	%token XC
+	%token EOL
+	%token VIR
+	%token <str> IDENT
+	%token <str> STR
+	%token <num> INT
+
+	%type <ints> extra_vals
+	%type <val> val
+
+	%start ini 
+
+	%%
+
+	ini:
+	| ini decl
+	| ini EOL
+
+	decl: STYLE AFF val {
+		int ok=0;
+		enum eMapStyle s; // STYLE
+		////-DEBUG-printf("Le style\n");
+		if ( $3->type != 0 ) { 
+			//-DEBUG-printf("ERREUR: Fichier .ini corrompu (style n'est pas de style int)\n");
+		} else {
+			s=0;
+			while(s<NBR_STYLE_MAP){
+
+				if (	(strcmp($3->ptr.str,"undefined")!=0)&&
+						(strcmp($3->ptr.str,tabString_eMapStyle[s]) == 0 )	){
+
+					ok=2;
+					gInit->mapI.map.style=s;
+					break;
+				}
+				++s;
+			}
+			if (ok!=2) { 
+				// BUG ...
+				//-DEBUG-printf("Style [%s] invalide (undefined) !!\n",$3->ptr.str);
+				exit(2);
+			}
+		}
+	}
+| NAME AFF val {
+	////-DEBUG-printf("Le name \n");
+	gInit->mapI.name=$3->ptr.str; //FIXME
+}
+| SLEM AFF val {
+	int res=99;
+	////-DEBUG-printf("Le superlemming \n");
+	if(strcmp($3->ptr.str,"true")==0){
+		res = 1;
+	}
+	if(strcmp($3->ptr.str,"false")==0){
+		res = 0;
+	}
+	if(res!=99){
+		gInit->mapI.map.superLemming=res;
+	} else {
+		//-DEBUG-printf("superlemming value invalid: %d %s\n",res,$3->ptr.str);
+		exit(1);
+	}
+}
+| BGCOLOR AFF val {
+	//-DEBUG-printf("BGCOLOR XC\n");
+	gInit->mapI.map.cmap.bgColor = string_to_Uint32($3->ptr.str,6);
+}
+| DEBRISCOLOR AFF val  {
+	//-DEBUG-printf("DEBRISCOLOR XC\n");
+	gInit->mapI.map.cmap.debrisColor = string_to_Uint32($3->ptr.str,6);
+}
+| PARTICLECOLOR AFF val  {
+	gInit->mapI.map.cmap.particleColor=tab_of_string_to_Uint32($3->ptr.str,6);	
+}
+| IDENT AFF val EOL	{
+	enum eParaMap t; // parameter of this map
+	int i=0,state=0;
+	// cette variable sert a derteminer dans quel cas on se trouve
+
+	// lvl*.ini => fichier de conf des d'une map de lemming
+	// state==0: aucun token detecter
+	// state==1: token para de la map detecter
+	// state==2: token xPos detecter
+	// state==3: token terrain_ detecter
+	// state==4: token object_ detecter
+	// state==5: token steel_ detecter
+
+	// style.ini => fichire de conf des objets animes
+	// state==6: token frames_ detecter  
+	// state==7: token anim_ detecter  
+	// state==8: token type_ detecter  	
+	// state==9: token sound_ detecter  
+
+	// state==10: token title detecter FIXME
+
+	// lemming.ini => fichier de conf des lemmings
+	// state==11: token lemm_ detecter 
+	// state==12: token pos_ detecter 
+	// state==13: token mask_ detecter 
+	// state==14: token imask_ detecter 
+
+	// liste terrain || objet || steel
+	struct listeSimplementChainee **listeItem=NULL;
+
+	////-DEBUG-printf("'%s' ^\n ", $1);
+	// donne les parametres de la map
+	t=0;
+	while(t<IDENT_COUNT){
+		if (strcmp($1,tabString_eParaMap[t]) == 0 ){
+			state=1;
+			gInit->mapI.paraMap[t]=$3->ptr.ints->val; 
+			break;
+		}
+		++t;
+	}
+	if (state!=1){ 
+
+		if (strcmp($1,"xPos") == 0){
+			state=2;
+			gInit->mapI.xPos=$3->ptr.ints->val;
+		}
+
+		if(strncmp($1,"terrain_",8) == 0){
+			state=3;
+			// init terrain
+			if(gInit->t.lt==NULL){
+				gInit->t.nbr=0;
+
+			} else {
+				gInit->t.nbr+=1;
+			}
+			listeItem=&gInit->t.lt;
+		}
+
+		if(strncmp($1,"object_",7) == 0){
+			state=4;
+			// init objet
+			if(gInit->o.lo==NULL){
+				gInit->o.nbr=0;
+			} else {
+				gInit->o.nbr+=1;
+			}
+			listeItem=&gInit->o.lo;
+		}
+
+		if(strncmp($1,"steel_",6) == 0){
+			state=5;
+			// init steel
+			if(gInit->s.ls==NULL){
+				gInit->s.nbr=0;
+			} else {
+				gInit->o.nbr+=1;
+			}
+			listeItem=&gInit->s.ls;
+		}
+
+
+		// Sprite Objet
+		if(strncmp($1,"frames_",7) == 0){
+			state=6;
+			// 1ER CAS
+			if(gInit->mapI.map.tilesObjet == 0){//-DEBUG-printf("ERREUR: tilesObjet == 0 => exit to prevent a segFault\n");
+				exit(4);
+			}
+			if(gInit->mapI.map.tabDataSprO == NULL){
+				gInit->mapI.map.tabDataSprO= malloc((sizeof(struct spriteObjet))*(gInit->mapI.map.tilesObjet));
+				gInit->cptGame[15] = -1;
+			} 
+			gInit->cptGame[15] +=1;
+			gInit->mapI.map.tabDataSprO[gInit->cptGame[15]].state=$3->ptr.ints->val;
+		}
+
+		if(strncmp($1,"anim_",5) == 0){
+			state=7;
+			gInit->mapI.map.tabDataSprO[gInit->cptGame[15]].anim=$3->ptr.ints->val;
+		}
+
+		if(strncmp($1,"type_",5) == 0){
+			state=8;
+			gInit->mapI.map.tabDataSprO[gInit->cptGame[15]].type=$3->ptr.ints->val;
+		}
+
+		if(strncmp($1,"sound_",6) == 0){
+			state=9;
+			gInit->mapI.map.tabDataSprO[gInit->cptGame[15]].sound=$3->ptr.ints->val;
+		}
+		// "style".ini
+		if(strncmp($1,"tiles",5) == 0){
+			state=10;
+			if($3->ptr.ints->val!=gInit->mapI.map.tiles){
+				//-DEBUG-printf("BUG: variable parse && nbrFichier are different %d waiting and  %d found\n",$3->ptr.ints->val,gInit->mapI.map.tiles);
+				exit(2);
+			}
+			//gInit->mapI.map.tiles=$3->ptr.ints->val;
+		}
+
+		// lemming .ini
+		if(strncmp($1,"lemm_",5)==0){
+			state=11;
+			// PREMIER CAS
+			if(gInit->mapI.lemmingDATA == NULL){
+				// 1ER CAS
+				gInit->mapI.lemmingDATA=malloc((sizeof(struct lemmingJobAndSprite))*LEM_JOB);
+				gInit->cptGame[15] = -1;
+			} 
+			gInit->cptGame[15] +=1;
+			gInit->mapI.lemmingDATA[gInit->cptGame[15]].mask=NULL;
+			gInit->mapI.lemmingDATA[gInit->cptGame[15]].imask=NULL;
+		}
+
+		if(strncmp($1,"pos_",4)==0){
+			state=12;
+		}
+
+		if(strncmp($1,"mask_",5)==0){
+			state=13;
+			gInit->mapI.lemmingDATA[gInit->cptGame[15]].mask=malloc(sizeof(struct lemmingMask));
+		}
+
+		if(strncmp($1,"imask_",6)==0){
+			state=14;
+			gInit->mapI.lemmingDATA[gInit->cptGame[15]].imask=malloc(sizeof(struct lemmingImask));
+		}
+
+		if((state>2 && state<6)||(state>10 && state<15)){
+			struct list_int *curr=$3->ptr.ints;
+
+			struct listeSimplementChainee *k = malloc(sizeof(struct listeSimplementChainee));
+
+			//k->data.pt=NULL;
+
+
+			//i=0;
+			switch(state){
+				// 3: terrain
+				case 3 : {i=0;k->data.pt=malloc(sizeof(struct paraTerrain));break;}
+					 // 4: objet
+				case 4 : {
+						 i=4;
+						 k->data.po=malloc(sizeof(struct paraObjet));
+						 k->data.po->cptState=0;
+						 break;
+					 }
+					 // 5 : steel
+				case 5 : {i=9;k->ID=0;k->data.ps=malloc(sizeof(struct paraSteel));break;}
+
+				case 11 : {i=13;break;}
+				case 12 : {i=16;break;}
+				case 13 : {i=19;break;}
+				case 14 : {i=22;break;}
+					  // en cas de BUG
+				default: //-DEBUG-printf("BUG parser: state = %d\n",state);
+					  exit(6);
+			}
+			
+			while (curr!=NULL) {
+				//	//-DEBUG-printf("%i ", curr->val);
+				switch(i) {
+					// pour les terrains
+					case 0: k->ID=curr->val; break;
+					case 3: k->x=curr->val; break;
+					case 2: k->y=curr->val; break;
+					case 1: {
+						k->data.pt->modif=curr->val; 			
+						switch(k->data.pt->modif){
+							case 0:
+							case 2:
+							case 4:
+							case 6:
+							case 8:
+							case 10:
+							case 12:
+							case 14:
+							case 15:
+							break;
+							default: printf("Erreur valeur interdite pour modif Terrain %d\n",k->data.pt->modif);exit (9);
+						} 
+						break;
+					}
+						// pour les objets
+					case 4: k->ID=curr->val; if(k->ID==1){++gInit->mapI.nbrEntry;} break;
+					case 8: k->x=curr->val; break;
+					case 7: k->y=curr->val; break;
+					case 6: {
+						k->data.po->paintMode=curr->val; 						
+						switch(k->data.po->paintMode){
+								case 0:
+								case 2:
+								case 4:
+								case 8:
+								break;
+								default: printf("Erreur valeur interdite pour paint Objet %d\n",k->data.po->paintMode);exit (19);
+							}
+						break;
+					}
+					case 5: {
+						k->data.po->UD = curr->val; 
+						if((k->data.po->UD!=0)&&(k->data.po->UD!=1)){
+							printf("Erreur valeur interdite pour UD Objet %d\n",k->data.po->UD);
+							exit (29);
+						} 
+						break;
+					}
+						// pour les steels
+					case 9:  k->x=curr->val; break;
+					case 12: k->y=curr->val; break;
+					case 11: k->data.ps->w = curr->val; break;
+					case 10: k->data.ps->h = curr->val; break;
+						 // pour les lemmings
+						 // lemm_
+					case 13: gInit->mapI.lemmingDATA[gInit->cptGame[15]].state=curr->val;break;
+					case 15: gInit->mapI.lemmingDATA[gInit->cptGame[15]].dir=curr->val;break;
+					case 14: gInit->mapI.lemmingDATA[gInit->cptGame[15]].anim=curr->val;break;
+						 // pos_
+					case 16: gInit->mapI.lemmingDATA[gInit->cptGame[15]].footX=curr->val;break;
+					case 18: gInit->mapI.lemmingDATA[gInit->cptGame[15]].footY=curr->val;break;
+					case 17: gInit->mapI.lemmingDATA[gInit->cptGame[15]].footSize=curr->val;break;		
+						 // mask_
+					case 19: gInit->mapI.lemmingDATA[gInit->cptGame[15]].mask->stateM=curr->val;break;
+					case 21: gInit->mapI.lemmingDATA[gInit->cptGame[15]].mask->dirM=curr->val;break;
+					case 20: gInit->mapI.lemmingDATA[gInit->cptGame[15]].mask->cooldown=curr->val;break;
+						 // imask_
+					case 22: gInit->mapI.lemmingDATA[gInit->cptGame[15]].imask->stateI=curr->val;break;
+					case 23: gInit->mapI.lemmingDATA[gInit->cptGame[15]].imask->dirI=curr->val;break;
+						 // en cas de BUG
+					default: //-DEBUG-printf("BUG parser i = %d\n",i);
+						 exit(7);
+				}
+				curr=curr->next;
+				++i;
+			}
+			// fichier lvl*.ini
+			if(state>2 && state<6){
+				k->next=*listeItem;
+				*listeItem=k;
+			}
+			//free(curr);
+		} else {
+
+			if(state == 0) {
+				//-DEBUG-printf("BUG: no parse for this token : %s \n",$1);
+				exit(8);
+			}
+		}
+	} // FIN ok==0
+}
+
+val: INT extra_vals	{	
+	     //	//-DEBUG-printf("creation de liste int ... \n");
+	     $$=malloc(sizeof(struct val));
+	     $$->type=1;
+	     $$->ptr.ints=malloc(sizeof(struct list_int));
+	     $$->ptr.ints->val=$1;
+	     $$->ptr.ints->next=$2;
+	     //	//-DEBUG-printf("liste int %d\n",$1);
+     }
+| STR	{	
+	//	//-DEBUG-printf("creation de liste STR ...\n");
+	$$=malloc(sizeof(struct val));
+	$$->type=0;
+
+	$$->ptr.str=malloc(sizeof(char)*strlen($1)+1);
+	strcpy($$->ptr.str, $1);
+	//	//-DEBUG-printf("liste STR %s\n",$1);
+}
+extra_vals:			{ $$=NULL; }
+| extra_vals VIR INT	{ //FIXME : =>  VIR INT extra_vals
+	$$=malloc(sizeof(struct list_int));
+	$$->val=$3;
+	$$->next=$1; 
+}
+
+%%
+
+void yyerror(struct gameInit *gInit, char *s)
+{
+	//fprintf(stderr, "Syntax Error : '%s' at l%d,c%d-l%d,c%d\n", s, @$.first_column, @$.last_line, @$.last_column); // Nécessite l'option %locations et un lexer qui va bien
+	fprintf(stderr, "(stdin):%i: error: %s\n", yylineno, s);
+	exit(9);
+}
+
+#include "fonctions_integrees.c"
+#include "fonctions_non_integrees.c"
+
+
+int main (int argc, char **argv)
+{	
+	int res,i,num,lt;
+	char *temp,*temp0;
+	//Uint32 ctest;
+	//int j,k;
+	//argc=3;
+	//argv[1]="1";
+	//argv[2]="72";
+	if (argc<2 || argc>3) { 
+		fprintf(stderr, "Usage %s [Option] <Filename>\n",argv[0]);
+		fprintf(stderr,"\nOption:\n\t- 1: on se place dans le dossier 1_orig\n");
+		fprintf(stderr,"\t- 2: on se place dans le dossier 2_ohno\n");
+		fprintf(stderr,"\t- 3: on se place dans le dossier 3_test\n");
+		fprintf(stderr,"Filename:\n\t- numero du lvl (ex: 1, 4, 13, 65b )\n");
+		return(44);
+	}
+	if (argc==3) {
+		i=1;
+		num=atoi(argv[2]);
+		if (num >= 10) ++i;
+		if (num >= 100) ++i;
+		if (num >= 1000){
+			fprintf(stderr,"Too many lvl (%d > 999)\n",num);
+			return(45);
+		}
+		temp0=malloc(sizeof(char)*(3-i));// => [00] [0] []
+		switch(i){ 
+			case 1 : temp0 = "00";break;
+			case 2 : temp0 = "0";break;
+			case 3 : temp0 = "";break;
+			default:fprintf(stderr,"BUG: i[=%d] > 3 ERREUR\n",i);return(46);
+		}
+
+		lt = (strlen("../../../../trunk/level/1_orig/lvl.ini")+5);// + 4 : 4 chiffres lvl.ini, +1 : string
+		temp=malloc(sizeof(char)*lt);
+		switch(atoi(argv[1])){
+			case 1 : sprintf(temp,"../../../../trunk/level/1_orig/lvl0%s%d.ini",temp0,num);break;
+			case 2 : sprintf(temp,"../../../../trunk/level/2_ohno/lvl1%s%d.ini",temp0,num);break;
+			case 3 : sprintf(temp,"../../../../trunk/level/3_test/lvl2%s%d.ini",temp0,num);break;
+			default:fprintf(stderr,"ERREUR: dossier [%d] inconnu\n",atoi(argv[1]));return(47);
+		}
+	} else {
+		temp=malloc(sizeof(char)*(strlen(argv[1])+1));
+		sprintf(temp,"%s",argv[1]);
+	}
+	yyin=fopen(temp, "r");
+	//yyin=fopen("./lvlTest01.ini", "r");
+	if (yyin==NULL) { 
+		fprintf(stderr,"Filename INVALIDE: %s\n",temp);
+		perror("Impossible d'ouvrir le niveau"); return(48); }
+
+		/*
+		   for(i=0;i<256;++i){
+		   for(j=0;j<256;++j){
+		   for(k=0;k<256;++k){
+		   ctest = ((i<<16 | j<<8 | k) & 0xffffff);
+		//-DEBUG-printf("[i]=%d, R = %X G = %X B = %X\n",
+		i, ((ctest>>16) & 0xff), 
+		((ctest>>8) & 0xff),
+		(ctest & 0xff) );
+		}}}*/
+
+		res=lancement();
+		printf("code retour %d\n",res);
+		//fclose(yyin); fait dans lancement
+
+		return res;
+
+}
+
+