import java.awt.Color;
import Instruction;

class XXX extends Instruction
{

	// Le contrôle du nombre et du type des arguments se
	// fait dans chkArg()

	// constructeur pour instruction sans argument
	public XXX()
	{
		super();
	}

	// constructeur pour instruction à 1 argument
	public XXX(int _t1,int _a1)
	{
		super(_t1,_a1);
	}

	// constructeur pour instruction à 2 arguments
	public XXX(int _t1,int _a1,int _t2,int _a2)
	{
		super(_t1,_a1,_t2,_a2);
	}

	// renvoie le nom de l'instruction
	// Cette méthode est obligatoire
	public String getName()
	{
		return "XXX";
	}

	// clonage
	// Cette méthode est obligatoire
	public Instruction getClone()
	{
		Instruction r = new XXX(ta1,arg1,ta2,arg2);
		copyMembers(r);
		return r;
	}

	// vérifie les arguments après un reinit
	// Cette méthode est obligatoire
	public void chkArg()
	{
		// code à adapter en fonction de la syntaxe de l'instruction
		erreur = false;
		if(nbArg == 0 || nbArg == 1) erreur = true;
		if(ta1 == Instruction.ADIRECT || ta2 == Instruction.ADIRECT) erreur = true;
	}

	// renvoie la durée
	// Instruction.duree() renvoie 1, il faut donc redéfinir duree()
	// uniquement si l'instruction dure plus longtemps.
	public int duree() { return 16; }

	// renvoie l'instruction en "clair"
	public String toString()
	{
		// cette méthode a déjà un comportement défini dans Instruction :

		// return getName() + typesAdr[ta1] + arg1 + typesAdr[ta2] + arg2;

		// si ce comportement convient à XXX, supprimez simplement cette
		// méthode dans la classe XXX
	}

	// exécute l'instruction
	public boolean exe(Process P)
	{
		// L'appel à super.exe avant tout est très fortement recommandé
		if(!super.exe(P)) return false;

		// ------------------------------------------------------------------------
		// code de l'instruction ici
		// ------------------------------------------------------------------------
		// ad1 contient l'adresse pointée par Arg1 (ne pas utiliser si adressage #)
		// ad2 contient l'adresse pointée par Arg2 (ne pas utiliser si adressage #)
		// v1 contient la valeur présente dans ad1 (ou bien Arg1 si adressage #)
		// v2 contient la valeur présente dans ad2 (ou bien Arg2 si adressage #)
		// Ces 4 valeurs sont mises à jour lors du super.exe(P)
		// C'est beau la Prog Par Objet, non ?
		// ------------------------------------------------------------------------

		// Ne pas oublier de positionner l'instruction suivante de P à l'aide
		// de P.jump(i) qui fera un saut relatif de i cases. P.jump(1) passe
		// donc à la case suivante.
		// ou bien P.jumpd(i) qui fera un saut direct à la case i. P.jumpd(ad1)
		// positionne donc le Processus sur l'adresse pointée par Arg1. Notez
		// que si Arg1 à un adressage #, P.jumpd(ad1) n'a pas de sens et réagira
		// comme si Arg1 était relatif.

		return true; // si tout s'est bien passé...
	}

	// si cette méthode n'est pas redéfinie, la couleur sera le noir.
	// vous pouvez créer une couleur par new Color(R,G,B)
	public Color getColor() { return Color.white; }
}