<p>i release my private librairy "qbytes" (quantique bytes)<br>this is a mathematic tool where all bits of a double word have 3 states : one , zero and unknow<br>i implemented the addition , multiplication (with an integer), a new concept "fusion" (equivalent to = ) , and all basic booleean functions (binary version of xor, or, no , and)
<br>there are some utilities like error detection, error depth etc ...</p>
<p>i used this lib for coding fuckmd5.cpp</p>
<p>if you want to use multithreading the code need modification</p>
<p>i think this tool is good for easy recomputation and error detection in the case of a cryptographic attack</p>
<p>quantique.h : structure definition<br>qbyte.h : class definition<br>qbyte.cpp : all the functions</p>
<p>download link : <a href="http://81.57.125.106/~slythers/qbyte%20and%20md5%20recomputation.rar">http://81.57.125.106/~slythers/qbyte%20and%20md5%20recomputation.rar</a></p>
<p>the quantique.h<br>-----------------------------------------------------------------------------<br>/*<br>(c) b4d coder<br>Malloc(0) Wicked Attitude</p>
<p>Copyright (c) 2006, overdose : <a href="mailto:slythers@gmail.com">slythers@gmail.com</a><br>All rights reserved.</p>
<p>Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:</p>
<p> * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.<br> * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
<br> * Neither the name of the Malloc(0) Wicked Attitude nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.</p>
<p>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,<br>BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
<br>IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,<br>OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
<br>OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,<br>OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
<br>OF SUCH DAMAGE.<br>*/</p>
<p>#define PARAM_LIST_SIZE_BASE (sizeof(unsigned int)+sizeof(unsigned char)+sizeof(char)+sizeof(bool))<br>#define MAX_ADD (255)</p>
<p>struct quantique<br>{<br> unsigned int value;<br> unsigned int know;<br>};</p>
<p>struct quantparam{<br> unsigned int size;<br> char type;<br> unsigned char nb;<br> bool error;<br> struct quantique *wesh[2];<br>};</p>
<p><br>the qbyte.h<br>-----------------------------------------------------------------------------<br>/*<br> B4d coder (c)<br> Quantique Bytes librairy (cryptographic attack tool)<br> coded by <a href="mailto:overdose/slythers@gmail.com">
overdose/slythers@gmail.com</a><br> Malloc(0) Wicked Attitude<br> <a href="http://malloczerowickedattitude.new.fr/">http://malloczerowickedattitude.new.fr</a><br> <br> created:10/03/2006<br>*/<br>#include <iostream.h>
<br>#include "quantique.h"</p>
<p>class qbyte<br>{<br> public:<br> qbyte();<br> bool error;<br> unsigned int value;<br> unsigned int know;<br> static unsigned int ldepth;<br> static unsigned int hdepth;<br> bool multi(qbyte &un,unsigned int entier);
<br> bool add(qbyte &un,qbyte &deux);<br> bool xor(qbyte &un,qbyte &deux);<br> bool and(qbyte &un,qbyte &deux);<br> bool or(qbyte &un,qbyte &deux);<br> bool no(qbyte &un);<br> void no();
<br> bool fusion(qbyte &of);<br> void copy(qbyte &a);<br> bool existbit(unsigned int number);<br> void setbit(unsigned int number,bool value);<br> void disablebit(unsigned int number);<br> bool getbit(unsigned int number);
<br> void copyrealvalue();<br> void setvalue();<br> void setvalue(unsigned int v);<br> void leftrotation(unsigned int nb);<br> void rightrotation(unsigned int nb);<br> void leftdecalage(unsigned int nb);<br> void rightdecalage(unsigned int nb);
<br> //systeme de profondeur des erreur<br> bool enabledepth();<br> bool depthisenable();<br> bool disabledepth();<br> void reinitdepth();<br> unsigned int getldepth();<br> unsigned int gethdepth();<br> unsigned int getredzone();
<br> bool depthsaved();<br> bool enablecopyerror();<br> bool disablecopyerror();<br> //surcharge des opérateurs, be aware to memory leak<br> struct quantparam * operator * (unsigned int constante);<br> struct quantparam * operator + (qbyte &a);
<br> struct quantparam * operator + (struct quantparam * list);<br> struct quantparam * operator | (qbyte &a);<br> struct quantparam * operator | (struct quantparam * list);<br> struct quantparam * operator & (qbyte &a);
<br> struct quantparam * operator & (struct quantparam * list);<br> struct quantparam * operator ^ (qbyte &a);<br> struct quantparam * operator ^ (struct quantparam * list);<br> bool operator = (struct quantparam *list);
<br> bool operator = (qbyte &a);<br> //machin amie<br> friend ostream &operator << (ostream &sortie, qbyte &a)<br> {<br> sortie << "Quantique Bytes value: "<<hex<<a.me.value
<<" Mask: "<<a.me.know<<dec<<" Error:"<<a.error<<endl;<br> return sortie;<br> }<br> struct quantique me;<br> private:<br> bool checkbitforadd(struct quantique *x,struct quantique *y,struct quantique *z);
<br> bool checkbitforxor(struct quantique *x,struct quantique *y,struct quantique *z);<br> bool checkbitforand(struct quantique *x,struct quantique *y,struct quantique *z);<br> bool checkbitforor(struct quantique *x,struct quantique *y,struct quantique *z);
<br> bool checkfusion(struct quantique *x,struct quantique *y);<br> bool checkmulti(struct quantique *x,unsigned int entier,struct quantique *z);<br> bool pyramide(struct quantparam *list,char type);<br> struct quantparam *addtolist(struct quantparam * list,char type);
<br> struct quantparam *newlist(qbyte &a,char type);<br> void increment();<br> void savedepth();<br> void savedepth(bool b);<br> static unsigned int compteur;<br> static unsigned int compteur2;<br> static unsigned int profondeur;
<br> static unsigned int profondeur2;<br> static unsigned int redzone;<br> static bool copyerror;<br> static bool enable;<br> static bool initialised;<br> static bool saved;<br>};</p>
<p><br>the qbyte.cpp<br>-----------------------------------------------------------------------------<br>/*<br>(c) B4d coder<br>Malloc(0) Wicked Attitude</p>
<p>Copyright (c) 2006, overdose : <a href="mailto:slythers@gmail.com">slythers@gmail.com</a><br>All rights reserved.</p>
<p>private stuff</p>
<p>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,<br>BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
<br>IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,<br>OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
<br>OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,<br>OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
<br>OF SUCH DAMAGE.<br>*/</p>
<p>#include "qbyte.h"</p>
<p>bool qbyte::initialised = 0;<br>unsigned int qbyte::ldepth;<br>unsigned int qbyte::hdepth;<br>unsigned int qbyte::compteur;<br>unsigned int qbyte::compteur2;<br>unsigned int qbyte::profondeur;<br>unsigned int qbyte::profondeur2;
<br>unsigned int qbyte::redzone;<br>bool qbyte::copyerror;<br>bool qbyte::enable;<br>bool qbyte::saved;</p>
<p><br>qbyte::qbyte()<br>{<br> this->value = 0x00;<br> this->know = 0x00;<br> me.value = 0x00;<br> me.know = 0x00;<br> error = 0;<br> if(!initialised)<br> {<br> initialised = 1;<br> copyerror = 1;<br> disabledepth();
<br> }<br>}</p>
<p>bool qbyte::checkbitforadd(struct quantique *x,struct quantique *y,struct quantique *z)<br>{<br> bool modified=0;<br> bool retenuemodified =0;<br> bool retmod=0;<br> unsigned int flagerror = 0x00;<br> unsigned int mask;
<br> struct quantique save1,save2,save3;<br> save1 = *x;<br> save2 = *y;<br> save3 = *z;<br> struct quantique retenue;<br> retenue.value = 0x00;<br> retenue.know = 0x00;<br> increment();<br> do{<br> if(modified)<br> retmod = 1;
<br> modified = 0;<br> retenuemodified = 0;<br> mask = 0x01;<br> for(unsigned char cpt = 0;cpt <32;cpt++)<br> {<br> //si on connait toute les valeurs on calcul la retenue et on se casse pas<br> if((z->know & mask) && (x->know & mask) && (y->know & mask) && !(
retenue.know & mask))<br> {<br> /*if(retenue.know & mask)<br> continue;*/<br> if(!cpt)<br> {<br> retenuemodified = 1;<br> retenue.know |= mask;<br> if((x->value & mask) && (y->value & mask))
<br> retenue.value |= mask;<br> else<br> retenue.value &= ~mask;<br> }<br> else if(retenue.know & (mask>>1))<br> {<br> retenuemodified = 1;<br> retenue.know |= mask;<br> if( ((x->value & mask) || (y->value & mask)) && ( ((x->value & mask) && (y->value & mask)) || (
retenue.value & (mask>>1)) ) )<br> retenue.value |= mask;<br> else<br> retenue.value &= ~mask;<br> }<br> else if(((x->value & mask) && (y->value & mask)))<br> {<br>
retenuemodified = 1;<br> retenue.know |= mask;<br> retenue.value |= mask;<br> };<br> //continue;<br> }<br> //premier bit pas de retenue<br> if(!cpt)<br> {<br> //au cas ou on connait la retenue
<br> if((retenue.know & mask) && (!(x->know & mask) || !(y->know & mask)) && (retenue.value & mask))<br> {<br> modified = 1;<br> y->know |= mask;<br> x->know |= mask;
<br> y->value |= mask;<br> x->value |= mask;<br> }<br> else if((retenue.know & mask) && !(x->know & mask) && (y->know & mask) && (y->value & mask) && !(
retenue.value & mask))<br> {<br> modified = 1;<br> x->know |= mask;<br> x->value &= ~mask;<br> }<br> else if((retenue.know & mask) && !(y->know & mask) && (x->know & mask) && (x->value & mask) && !(
retenue.value & mask))<br> {<br> modified = 1;<br> y->know |= mask;<br> y->value &= ~mask;<br> };<br> //si on connait le bit du resultat<br> if(z->know & mask)<br> {<br> //si on connait le bit de x a 1 et pas y
<br> if((x->know & mask) && (x->value & mask) && !(y->know & mask))<br> {<br> modified = 1;<br> y->know |= mask;<br> //on met y a 0<br> if(z->value & mask)
<br> y->value &= ~mask;<br> else<br> y->value |= mask;<br> }<br> else if((x->know & mask) && !(x->value & mask) && !(y->know & mask))// bit de x a 0<br>
{<br> modified = 1;<br> y->know |= mask;<br> if(z->value & mask)<br> y->value |= mask;<br> else<br> y->value &= ~mask;<br> }<br> //on connait y et pas x<br>
else if((y->know & mask) && (y->value & mask) && !(x->know & mask))<br> {<br> modified = 1;<br> x->know |= mask;<br> //on met y a 0<br> if(z->value & mask)
<br> x->value &= ~mask;<br> else<br> x->value |= mask;<br> }<br> else if((y->know & mask) && !(y->value & mask) && !(x->know & mask) )// bit de x a 0
<br> {<br> modified = 1;<br> x->know |= mask;<br> if(z->value & mask)<br> x->value |= mask;<br> else<br> x->value &= ~mask;<br> }<br> }<br> //si on connait les deux !
<br> else if((x->know & mask) && (y->know & mask) && !(z->know & mask))<br> {<br> modified = 1;<br> z->know |= mask;<br> if( (x->value & mask) ^ (y->value & mask) )
<br> z->value |= mask;<br> else<br> z->value &= ~mask;<br> };<br> //calcul de la retenue<br> if((x->know & mask) && (y->know & mask) && !(retenue.know & mask))
<br> {<br> retenuemodified = 1;<br> retenue.know |= mask;<br> if((x->value & mask) && (y->value & mask))<br> retenue.value |= mask;<br> else<br> retenue.value &= ~mask;
<br> }<br> //on verifie les erreurs<br> if((z->know & mask) && (x->know & mask) && (y->know & mask))<br> {<br> if(( (x->value & mask) ^ (y->value & mask) ) != (z->value & mask))
<br> {<br> if(!(flagerror & mask))<br> {<br> flagerror |= mask;<br> savedepth(1);<br> }<br> error = 1;<br> }<br> }<br> }<br> else<br> {<br> //au cas ou on connait la retenue courante et peut etre la precedente pas z mais !a | !b
<br> if((retenue.know & mask) && (!(x->know & mask) || !(y->know & mask))/* && !(z->know & mask)*/)<br> {<br> if((retenue.value & mask) && (retenue.know & (mask>>1)) && !(
retenue.value & (mask>>1)))<br> {<br> modified = 1;<br> y->know |= mask;<br> x->know |= mask;<br> y->value |= mask;<br> x->value |= mask;<br> }<br> else if((retenue.value
& mask) && (retenue.know & (mask>>1)) && (retenue.value & (mask>>1)))<br> {<br> if((x->know & mask) && !(x->value & mask) && !(y->know & mask))
<br> {<br> modified = 1;<br> y->know |= mask;<br> y->value |= mask;<br> }<br> else if((y->know & mask) && !(y->value & mask) && !(x->know & mask))
<br> {<br> modified = 1;<br> x->know |= mask;<br> x->value |= mask;<br> };<br> }<br> else if((retenue.know & (mask>>1)) && (retenue.value & (mask>>1)) && !(
retenue.value & mask))<br> {<br> modified = 1;<br> y->know |= mask;<br> x->know |= mask;<br> y->value &= ~mask;<br> x->value &= ~mask;<br> }<br> else if((retenue.know
& (mask>>1)) && !(retenue.value & (mask>>1)) && !(retenue.value & mask))<br> {<br> if((y->know & mask) && (y->value & mask) && !(x->know & mask))
<br> {<br> modified = 1;<br> x->know |= mask;<br> x->value &= ~mask;<br> }<br> else if((x->know & mask) && (x->value & mask) && !(y->know & mask))
<br> {<br> modified = 1;<br> y->know |= mask;<br> y->value &= ~mask;<br> };<br> }<br> //au cas ou on connait pas la précendente valeur<br> else if(!(retenue.know & (mask>>1)))
<br> {<br> if((retenue.value & mask) && (x->know & mask) && !(x->value & mask))<br> {<br> modified = 1;<br> y->know |= mask;<br> y->value |= mask;<br>
}<br> else if((retenue.value & mask) && (y->know & mask) && !(y->value & mask))<br> {<br> modified = 1;<br> x->know |= mask;<br> x->value |= mask;<br>
};<br> };<br> }<br> //calcul avec retenue precedente inconnu wesh <br> if(!(retenue.know & (mask >> 1)))<br> {<br> if((retenue.know & mask) && (z->know & mask) && !(
retenue.value & mask) && !(z->value & mask))<br> {<br> //cout <<"debug ret"<<endl;<br> retenuemodified = 1;<br> retenue.know |= (mask>>1);<br> retenue.value
&= ~(mask>>1);<br> }<br> //calcul de la retenu precedente<br> if((x->know & mask) && (y->know & mask) && (z->know & mask))<br> {<br> retenuemodified = 1;
<br> retenue.know |= (mask >> 1);<br> if( ((x->value & mask) ^ (y->value & mask)) ^ (z->value & mask))<br> retenue.value |= (mask >> 1);<br> else<br> retenue.value
&= ~(mask >> 1);<br> }<br> //on connait la retenue actuel et x et y<br> else if((x->know & mask) && (y->know & mask) && (retenue.know & mask))<br> {<br> //si Rx=1 et !(x&&y) alors rx-1 = 1
<br> if((retenue.value & mask) && !((x->value & mask) && (y->value & mask)))<br> {<br> //cout <<"debug 17"<<endl;<br> retenuemodified = 1;<br>
retenue.know |= (mask>>1);<br> retenue.value |= (mask>>1);<br> } <br> // si rx = 0 et x||y rx-1 = 0<br> else if(!(retenue.value & mask) && ((x->value & mask) || (y->value & mask)) )
<br> {<br> retenuemodified = 1;<br> retenue.know |= (mask>>1);<br> retenue.value &= ~(mask>>1);<br> };<br> };<br> }<br> //calcul avec retenue precedente connu<br> else if(
retenue.know & (mask >> 1))<br> {<br> if((x->know & mask) && (y->know & mask) && !(z->know & mask))<br> {<br> modified = 1;<br> z->know |= mask;<br> if((x->value & mask) ^ (y->value & mask) ^ ((
retenue.value & (mask>>1))<<1))<br> z->value |= mask;<br> else<br> z->value &= ~mask;<br> }<br> else if((x->know & mask) && !(y->know & mask) && (z->know & mask))
<br> {<br> modified = 1;<br> y->know |= mask;<br> if((x->value & mask) ^ (z->value & mask) ^ ((retenue.value & (mask>>1))<<1))<br> y->value |= mask;<br> else
<br> y->value &= ~mask;<br> }<br> else if(!(x->know & mask) && (y->know & mask) && (z->know & mask))<br> {<br> modified = 1;<br> x->know |= mask;<br>
if((z->value & mask) ^ (y->value & mask) ^ ((retenue.value & (mask>>1))<<1))<br> x->value |= mask;<br> else<br> x->value &= ~mask;<br> };<br> //calcul retenu
<br> if(!(retenue.know & mask) && (x->know & mask) && !(y->know & mask) && !(z->know & mask) )<br> {<br> if(!(retenue.value & (mask>>1)) && !(x->value & mask))
<br> {<br> retenuemodified = 1;<br> retenue.know |= mask;<br> retenue.value &= ~mask;<br> }<br> else if((retenue.value & (mask>>1)) && (x->value & mask))<br> {
<br> retenuemodified = 1;<br> retenue.know |= mask;<br> retenue.value |= mask;<br> };<br> }<br> else if(!(retenue.know & mask) && (y->know & mask) && !(x->know & mask) && !(z->know & mask))
<br> {<br> if(!(retenue.value & (mask>>1)) && !(y->value & mask))<br> {<br> retenuemodified = 1;<br> retenue.know |= mask;<br> retenue.value &= ~mask;<br> }
<br> else if((retenue.value & (mask>>1)) && (y->value & mask))<br> {<br> retenuemodified = 1;<br> retenue.know |= mask;<br> retenue.value |= mask;<br> };<br> };
<br> }<br> //calcul de la retenu<br> if(!(retenue.know & mask) && (retenue.know & (mask>>1)) && (x->know & mask) && (y->know & mask))<br> {<br> retenuemodified = 1;
<br> retenue.know |= mask;<br> if( ((x->value & mask) && (y->value & mask)) || ((x->value & mask) && (retenue.value & (mask>>1))) || ((retenue.value & (mask>>1)) && (y->value & mask)) )
<br> retenue.value |= mask;<br> else<br> retenue.value &= ~mask;<br> }<br> else if(!(retenue.know & mask) && !(retenue.know & (mask>>1)) && (x->know & mask) && (y->know & mask) && (x->value & mask) && (y->value & mask))
<br> {<br> retenuemodified = 1;<br> retenue.know |= mask;<br> retenue.value |= mask;<br> }<br> else if(!(retenue.know & mask) && (retenue.know & (mask>>1)) && (x->know & mask) && !(y->know & mask) && !(
retenue.value & (mask>>1)) && !(x->value & mask))<br> {<br> retenuemodified = 1;<br> retenue.know |= mask;<br> retenue.value &= ~mask;<br> }<br> else if(!(retenue.know & mask) && (
retenue.know & (mask>>1)) && !(x->know & mask) && (y->know & mask) && !(retenue.value & (mask>>1)) && !(y->value & mask))<br> {<br> retenuemodified = 1;
<br> retenue.know |= mask;<br> retenue.value &= ~mask;<br> };<br> if((x->know & mask) && (y->know & mask) && !(x->value & mask) && !(y->value & mask) && !(
retenue.know & mask) )<br> {<br> //cout <<"debug ret 2"<<endl;<br> retenuemodified = 1;<br> retenue.know |= mask;<br> retenue.value &= ~mask;<br> }<br> else if((x->know & mask) && (y->know & mask) && (x->value & mask) && (y->value & mask) && !(
retenue.know & mask) )<br> {<br> //cout <<"debug ret 3"<<endl;<br> retenuemodified = 1;<br> retenue.know |= mask;<br> retenue.value |= mask;<br> }<br> }<br> //on verifie les erreurs
<br> if((z->know & mask) && (x->know & mask) && (y->know & mask) && cpt && (retenue.know & (mask>>1)))<br> {<br> if(( (x->value & mask) ^ (y->value & mask) ^ ((
retenue.value & (mask>>1))<<1) ) != (z->value & mask))<br> {<br> if(!(flagerror & mask))<br> {<br> flagerror |= mask;<br> savedepth(1);<br> }<br> error = 1;<br> }<br> }<br>
mask = mask <<1;<br> }<br> }while(modified || retenuemodified);<br> //verification des erreur<br> if(!(~(x->know)) && !(~(y->know)) && !(~(z->know)))<br> {<br> if((x->value + y->value) != z->value)
<br> {<br> savedepth();<br> error = 1;<br> }<br> }<br> if((save1.value & save1.know) != (x->value & save1.know))<br> {<br> savedepth();<br> error = 1;<br> }<br> if((save2.value & save2.know) != (y->value &
save2.know))<br> {<br> savedepth();<br> error = 1;<br> }<br> if((save3.value & save3.know) != (z->value & save3.know))<br> {<br> savedepth();<br> error = 1;<br> }<br> return retmod;<br>}</p>
<p>//version fast ...<br>bool qbyte::checkmulti(struct quantique *x,unsigned int entier,struct quantique *z)<br>{<br> struct quantique pile[32];<br> struct quantique palier;<br> struct quantique copiedex;<br> struct quantique cx,cz;
<br> unsigned int mask;<br> unsigned char cpt,nb,max;<br> bool modified=0;<br> cx = *x;<br> cz = *z; <br> palier.value = 0x00;<br> palier.know = 0x00;<br> nb = 0;<br> increment();<br> for(cpt =0; cpt<32;cpt++)<br> {<br>
pile[cpt].value = 0x00;<br> pile[cpt].know = 0x00;<br> }<br> for(max =31;!((0x01<<max) & entier) && max ;max--);<br> pile[0].know = 0xffffffff;<br> do{<br> modified = 0;<br> mask = 0x01<<31;<br>
nb = 0;<br> for(cpt=0;cpt<32;cpt++)<br> {<br> if(mask & entier)<br> {<br> palier.value = x->value << (31-cpt);<br> palier.know = (x->know << (31-cpt)) | ((cpt == 31) ? 0x00 : (0xffffffff >> (cpt+1)) );
<br> if(checkbitforadd(&(pile[nb]),&palier, (cpt == max)? z : &(pile[nb+1]) ))<br> modified = 1;<br> nb++;<br> palier.value = palier.value >> (31-cpt);<br> palier.know = palier.know >> (31-cpt);
<br> copiedex.know = x->know;<br> if(checkfusion(&palier,x))<br> {<br> if(copiedex.know != x->know)<br> modified = 1;<br> }<br> }<br> mask = mask >>1;<br> }<br> //on refait dans l'autre sens
<br> for(;cpt;cpt--)<br> {<br> if(mask & entier)<br> {<br> palier.value = (x->value) << (31-(cpt-1));<br> palier.know = (x->know) << (31-(cpt-1)) | ((cpt == 32) ? 0x00 : (0xffffffff >> (cpt)) );
<br> if(checkbitforadd(&(pile[nb]),&palier, (cpt == (max+1))? z : &(pile[nb+1]) ))<br> modified = 1;<br> nb--;<br> palier.value = (palier.value) >> (31-(cpt-1));<br> palier.know = (palier.know
) >> (31-(cpt-1));<br> copiedex.know = x->know;<br> if(checkfusion(&palier,x))<br> {<br> if(copiedex.know != x->know)<br> modified = 1;<br> }<br> }<br> mask = mask <<1;<br> }
<br> }while(modified && !error);<br> //verification erreur<br> if(cx.value != (x->value & cx.know))<br> {<br> savedepth();<br> error = 1;<br> }<br> if(cz.value != (z->value & cz.know))<br> {<br> savedepth();
<br> error = 1;<br> }<br> if((cz.know != z->know) || (cx.know != x->know))<br> return 1;<br> return 0;<br>}</p>
<p>bool qbyte::checkbitforxor(struct quantique *x,struct quantique *y,struct quantique *z)<br>{<br> bool modified=0;<br> unsigned int mask=0x01;<br> unsigned int tmp;<br> unsigned int flagerror=0x00;<br> increment();<br>
tmp = z->know & x->know & y->know;<br> if((z->value & tmp) != ((x->value & tmp) ^ (y->value & tmp)))<br> {<br> savedepth();<br> error = 1;<br> }<br> for(unsigned int cpt = 0;cpt<32;cpt++)
<br> {<br> if(z->know & mask)<br> {<br> if(z->value & mask)<br> {<br> if((x->know & mask) && (x->value & mask))<br> {<br> //cout <<"debug 1"<<endl;
<br> if(!(y->know & mask))<br> modified = 1;<br> y->know |= mask;<br> y->value &= ~mask;<br> }<br> else if((y->know & mask) && (y->value & mask))<br> {<br> //cout <<"debug 2"<<endl;
<br> if(!(x->know & mask))<br> modified = 1;<br> x->know |= mask;<br> x->value &= ~mask;<br> };<br> }<br> else<br> {<br> if(x->know & mask)<br> {<br> //cout <<"debug 3"<<endl;
<br> if(!(y->know & mask))<br> modified = 1;<br> y->know |= mask;<br> if(x->value&mask)<br> y->value |= mask;<br> else<br> y->value &= ~mask;<br> }<br> else if(y->know & mask)
<br> {<br> //cout <<"debug 4"<<endl;<br> //inutile ici mais bon =)<br> if(!(x->know & mask))<br> modified = 1;<br> x->know |= mask;<br> if(y->value&mask)<br>
x->value |= mask;<br> else<br> x->value &= ~mask;<br> };<br> }<br> }<br> else if((x->know & mask) && (y->know & mask))<br> {<br> //cout <<"debug 5"<<endl;
<br> modified = 1;<br> z->know |= mask;<br> if((x->value & mask) ^ (y->value & mask))<br> z->value |= mask;<br> else<br> z->value &= ~mask;<br> };<br> //on check les erreur<br> if((z->know & mask) && (x->know & mask) && (y->know & mask))
<br> {<br> if((z->value & mask) != ((x->value & mask) ^ (y->value & mask)))<br> {<br> if(!(flagerror & mask))<br> {<br> flagerror |= mask;<br> savedepth(1);<br> }<br> error = 1;
<br> }<br> }<br> mask = mask << 1;<br> }<br> return modified;<br>}</p>
<p>bool qbyte::checkbitforand(struct quantique *x,struct quantique *y,struct quantique *z)<br>{<br> bool modified=0;<br> unsigned int mask=0x01;<br> unsigned int flagerror = 0x00;<br> unsigned int tmp;<br> increment();<br>
tmp = z->know & x->know & y->know;<br> if((z->value & tmp) != ((x->value & tmp) & (y->value & tmp)))<br> {<br> savedepth();<br> error = 1;<br> }<br> for(unsigned int cpt = 0;cpt<32;cpt++)
<br> {<br> if((z->know & mask) && (z->value & mask))<br> {<br> if(!((x->know & mask) && (y->know & mask)) )<br> modified = 1;<br> x->know |= mask;<br> y->know |= mask;
<br> x->value |= mask;<br> y->value |= mask;<br> }<br> else if((z->know & mask) && !(z->value & mask))<br> {<br> if((x->know & mask)&&(x->value & mask))<br> {<br>
if(!(y->know & mask))<br> modified = 1;<br> y->know |= mask;<br> y->value &= ~mask;<br> }<br> else if((y->know & mask)&&(y->value & mask))<br> {<br> if(!(x->know & mask))
<br> modified = 1;<br> x->know |= mask;<br> x->value &= ~mask;<br> };<br> }<br> else if(!(z->know & mask) && ((x->know & mask) || (y->know & mask)))<br> {<br> if((x->know & mask) && !(x->value & mask))
<br> {<br> modified = 1;<br> z->know |= mask;<br> z->value &= ~mask;<br> }<br> else if((y->know & mask) && !(y->value & mask))<br> {<br> modified = 1;<br> z->know |= mask;
<br> z->value &= ~mask;<br> }<br> else if((x->know & mask) && (y->know & mask))// normelement les deux sont a 1<br> {<br> modified = 1;<br> z->know |= mask;<br> z->value |= mask;
<br> }<br> };<br> //on check les erreur<br> if((z->know & mask) && (x->know & mask) && (y->know & mask))<br> {<br> if((z->value & mask) != ((x->value & mask) & (y->value & mask)))
<br> {<br> if(!(flagerror & mask))<br> {<br> flagerror |= mask;<br> savedepth(1);<br> }<br> error = 1;<br> }<br> }<br> mask = mask<<1;<br> }<br> return modified;<br>}</p>
<p>bool qbyte::checkbitforor(struct quantique *x,struct quantique *y,struct quantique *z)<br>{<br> bool modified=0;<br> unsigned int mask=0x01;<br> unsigned int tmp;<br> unsigned int flagerror = 0x00;<br> increment();<br>
tmp = z->know & x->know & y->know;<br> if((z->value & tmp) != ((x->value & tmp) | (y->value & tmp)))<br> {<br> savedepth();<br> error = 1;<br> }<br> for(unsigned int cpt = 0;cpt<32;cpt++)
<br> {<br> if((z->know & mask) && !(z->value & mask))<br> {<br> if(!((x->know & mask) && (y->know & mask)) )<br> modified = 1;<br> x->know |= mask;<br> y->know |= mask;
<br> x->value &= ~mask;<br> y->value &= ~mask;<br> }<br> else if((z->know & mask) && (z->value & mask))<br> {<br> if((x->know & mask) && !(x->value & mask))
<br> {<br> if(!(y->know & mask))<br> modified = 1;<br> y->know |= mask;<br> y->value |= mask;<br> }<br> else if((y->know & mask) && !(y->value & mask))<br> {<br> if(!(x->know & mask))
<br> modified = 1;<br> x->know |= mask;<br> x->value |= mask;<br> };<br> }<br> else if(!(z->know & mask) && ((x->know & mask) || (y->know & mask)))<br> {<br> if((x->know & mask) && (x->value & mask))
<br> {<br> modified = 1;<br> z->know |= mask;<br> z->value |= mask;<br> }<br> else if((y->know & mask) && (y->value & mask))<br> {<br> modified = 1;<br> z->know |= mask;
<br> z->value |= mask;<br> }<br> else if((x->know & mask) && (y->know & mask))// normelement le deux sont a 0<br> {<br> modified = 1;<br> z->know |= mask;<br> z->value &= ~mask;
<br> }<br> };<br> //on check les erreur<br> if((z->know & mask) && (x->know & mask) && (y->know & mask))<br> {<br> if((z->value & mask) != ((x->value & mask) | (y->value & mask)))
<br> {<br> if(!(flagerror & mask))<br> {<br> flagerror |= mask;<br> savedepth(1);<br> }<br> error = 1;<br> }<br> }<br> mask = mask<<1;<br> }<br> return modified;<br>}</p>
<p>bool qbyte::multi(qbyte &un,unsigned int entier)<br>{<br> bool ret;<br> error |= un.error ;<br> if(error)<br> return 0;<br> ret = checkmulti(&(un.me),entier,&(this->me));<br> copyrealvalue();<br> return ret;
<br>}</p>
<p>bool qbyte::add(qbyte &un,qbyte &deux)<br>{<br> bool ret;<br> error |= un.error | deux.error;<br> /*if(error)<br> return 0;*/<br> ret = checkbitforadd(&(un.me),&(deux.me),&(this->me));<br> copyrealvalue();
<br> return ret;<br>}</p>
<p>bool qbyte::xor(qbyte &un,qbyte &deux)<br>{<br> bool ret;<br> error |= un.error | deux.error;<br> /*if(error)<br> return 0;*/<br> ret = checkbitforxor(&(un.me),&(deux.me),&(this->me));<br> copyrealvalue();
<br> return ret;<br>}</p>
<p>bool qbyte::and(qbyte &un,qbyte &deux)<br>{<br> bool ret;<br> error |= un.error | deux.error;<br> /*if(error)<br> return 0;*/<br> ret = checkbitforand(&(un.me),&(deux.me),&(this->me));<br> copyrealvalue();
<br> return ret;<br>}</p>
<p>bool qbyte::or(qbyte &un,qbyte &deux)<br>{<br> bool ret;<br> error |= un.error | deux.error;<br> /*if(error)<br> return 0;*/<br> ret = checkbitforor(&(un.me),&(deux.me),&(this->me));<br> copyrealvalue();
<br> return ret;<br>}</p>
<p>bool qbyte::no(qbyte &un)<br>{<br> bool modified=0;<br> unsigned int mask=0x01;<br> unsigned int tmp;<br> struct quantique *x;<br> increment();<br> x = &(un.me);<br> tmp = me.know & x->know;<br> if((me.value
& tmp) != (~(x->value) & tmp) )<br> {<br> savedepth();<br> error = 1;<br> }<br> for(unsigned int cpt = 0;cpt<32;cpt++)<br> {<br> if((me.know & mask) && !(x->know & mask))<br> {<br> modified = 1;
<br> x->know |= mask;<br> if(me.value & mask)<br> x->value &= ~mask;<br> else<br> x->value |= mask;<br> }<br> else if(!(me.know & mask) && (x->know & mask))<br> {<br> modified = 1;
<br> x->know |= mask;<br> if(x->value & mask)<br> me.value &= ~mask;<br> else<br> me.value |= mask;<br> };<br> if( (me.know & mask) && (x->know & mask) && ((me.value & mask) != (~(x->value) & mask)) )
<br> {<br> savedepth(1);<br> error = 1;<br> }<br> mask = mask << 1;<br> }<br> copyrealvalue();<br> return modified;<br>}</p>
<p>void qbyte::no()<br>{<br> me.value = ~(me.value);<br> me.value &= me.know;<br> copyrealvalue();<br>}</p>
<p>bool qbyte::checkfusion(struct quantique *x,struct quantique *y)<br>{<br> bool modified=0;<br> unsigned int mask=0x01;<br> increment();<br> for(unsigned int cpt = 0;cpt<32;cpt++)<br> {<br> if(x->know & mask)
<br> {<br> if((y->know & mask) && ((x->value & mask) != (y->value & mask)) )<br> {<br> savedepth(1);<br> error = 1;<br> }<br> if(!(y->know & mask))<br> modified = 1;<br>
y->know |= mask;<br> if(x->value & mask)<br> y->value |= mask;<br> else<br> y->value &= ~mask;<br> }<br> else if(y->know & mask)<br> {<br> modified = 1;<br> x->know |= mask;
<br> if(y->value & mask)<br> x->value |= mask;<br> else<br> x->value &= ~mask;<br> }<br> mask = mask << 1;<br> }<br> return modified;<br>}</p>
<p>bool qbyte::fusion(qbyte &of)<br>{<br> bool modified=0;<br> modified = checkfusion(&(of.me),&(this->me));<br> copyrealvalue();<br> return modified;<br>}</p>
<p>void qbyte::copy(qbyte &a)<br>{<br> me.value = a.me.value;<br> me.know = a.me.know;<br> if(copyerror)<br> this->error = a.error;<br> copyrealvalue();<br>}</p>
<p>void qbyte::setbit(unsigned int number,bool value)<br>{<br> me.know |= (0x01<<number);<br> if(value)<br> me.value |= (0x01<<number);<br> else<br> me.value &= ~(0x01<<number);<br> copyrealvalue();
<br>}</p>
<p>bool qbyte::existbit(unsigned int number)<br>{<br> return (me.know & (0x01<<number));<br>}</p>
<p>void qbyte::disablebit(unsigned int number)<br>{<br> me.know &= ~(0x01<<number);<br> me.value &= me.know;<br> copyrealvalue();<br>}</p>
<p>bool qbyte::getbit(unsigned int number)<br>{<br> return (me.value & (0x01<<number));<br>}</p>
<p>void qbyte::copyrealvalue()<br>{<br> this->value = me.value;<br> this->know = me.know;<br>}</p>
<p>void qbyte::setvalue()<br>{<br> me.value = this->value & this->know ;<br> me.know = this->know;<br>}</p>
<p>void qbyte::setvalue(unsigned int v)<br>{<br> me.value = v;<br> me.know = 0xffffffff;<br>}</p>
<p>void qbyte::leftrotation(unsigned int nb)<br>{<br> if(!(nb %32))<br> return;<br> me.value = ( ((me.value) << (nb)) | ((me.value) >> (32-(nb))) );<br> me.know = ( ((me.know) << (nb)) | ((me.know) >> (32-(nb))) );
<br> copyrealvalue();<br>}</p>
<p>void qbyte::rightrotation(unsigned int nb)<br>{<br> if(!(nb %32))<br> return;<br> me.value = (((me.value) >> (nb)) | ((me.value) << (32-(nb))));<br> me.know = (((me.know) >> (nb)) | ((me.know) << (32-(nb))));
<br> copyrealvalue();<br>}</p>
<p>void qbyte::leftdecalage(unsigned int nb)<br>{<br> me.value = me.value << nb;<br> me.know = me.know << nb;<br> copyrealvalue();<br>}</p>
<p>void qbyte::rightdecalage(unsigned int nb)<br>{<br> me.value = me.value >> nb;<br> me.know = me.know >> nb;<br> copyrealvalue();<br>}</p>
<p>//surcharge des operateurs<br>//a debugguer ... surtout le return modif faut checker que les entrée/sorie qui pourrait avoir changer<br>bool qbyte::pyramide(struct quantparam *list,char type)<br>{<br> struct quantique abc[MAX_ADD][MAX_ADD/2];
<br> unsigned char endessous[MAX_ADD];<br> unsigned char nbporte[MAX_ADD];<br> unsigned char cpt,ptr,hauteur,tmp;<br> bool modified=0;<br> bool ret;<br> ret =0;<br> if(list->nb < 3)<br> {<br> switch(type)<br> {<br>
case '+':<br> return checkbitforadd(list->wesh[0],list->wesh[1],&(this->me));<br> case '|':<br> return checkbitforor(list->wesh[0],list->wesh[1],&(this->me));<br> case '&':
<br> return checkbitforand(list->wesh[0],list->wesh[1],&(this->me));<br> case '^':<br> return checkbitforxor(list->wesh[0],list->wesh[1],&(this->me));<br> case '*':<br> return checkmulti(list->wesh[0],(unsigned int) list->wesh[1],&(this->me));
<br> }<br> return 0;<br> }<br> for(cpt=0;cpt<MAX_ADD;cpt++)<br> {<br> endessous[cpt] = 0xff;<br> for(ptr=0;ptr < (MAX_ADD/2);ptr++)<br> {<br> abc[cpt][ptr].know = 0x00;<br> abc[cpt][ptr].value = 0x00;<br> }
<br> }<br> do{<br> if(modified)<br> ret = 1;<br> modified = 0;<br> //on divise une premere fois par deux<br> hauteur = list->nb/2;<br> if(hauteur %2)<br> hauteur++;<br> hauteur -= 2;<br> hauteur = hauteur/2;
<br> tmp = list->nb;<br> if(tmp%2)<br> {<br> abc[(tmp/2)+1][0] = *(list->wesh[tmp]);<br> endessous[0] = tmp;<br> tmp = tmp /2;<br> nbporte[0] = tmp;<br> tmp++;<br> }<br> else<br> {<br> tmp = tmp /2;
<br> nbporte[0] = tmp;<br> }<br> for(unsigned char ok=0;ok < list->nb;ok+=2)<br> {<br> switch(type)<br> {<br> case '+':<br> checkbitforadd(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0]));
<br> break;<br> case '|':<br> checkbitforor(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0]));<br> break;<br> case '&':<br> checkbitforand(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0]));
<br> break;<br> case '^':<br> checkbitforxor(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0]));<br> break;<br> }<br> }<br> for(cpt = 0;cpt < hauteur;cpt++)<br> {<br> if(tmp%2)<br>
{<br> abc[(tmp/2)+1][cpt+1] = abc[tmp][cpt];<br> endessous[cpt+1] = tmp;<br> tmp = tmp /2;<br> nbporte[cpt+1] = tmp;<br> tmp++;<br> }<br> else<br> {<br> tmp = tmp /2;<br> nbporte[cpt+1] = tmp;
<br> }<br> <br> for(ptr=0;ptr < nbporte[cpt+1];ptr++)<br> {<br> switch(type)<br> {<br> case '+':<br> checkbitforadd(&(abc[ptr*2][cpt]),&(abc[(ptr*2)+1][cpt]),&(abc[ptr][cpt+1]));
<br> break;<br> case '|':<br> checkbitforor(&(abc[ptr*2][cpt]),&(abc[(ptr*2)+1][cpt]),&(abc[ptr][cpt+1]));<br> break;<br> case '&':<br> checkbitforand(&(abc[ptr*2][cpt]),&(abc[(ptr*2)+1][cpt]),&(abc[ptr][cpt+1]));
<br> break;<br> case '^':<br> checkbitforxor(&(abc[ptr*2][cpt]),&(abc[(ptr*2)+1][cpt]),&(abc[ptr][cpt+1]));<br> break;<br> }<br> }<br> }<br> switch(type)<br> {<br> case '+':
<br> if(checkbitforadd(&(abc[0][cpt]),&(abc[1][cpt]),&(this->me)))<br> modified = 1;<br> break;<br> case '|':<br> if(checkbitforor(&(abc[0][cpt]),&(abc[1][cpt]),&(this->me)))
<br> modified = 1;<br> break;<br> case '&':<br> if(checkbitforand(&(abc[0][cpt]),&(abc[1][cpt]),&(this->me)))<br> modified = 1;<br> break;<br> case '^':<br> if(checkbitforxor(&(abc[0][cpt]),&(abc[1][cpt]),&(this->me)))
<br> modified = 1;<br> break;<br> }<br> //on refait dans l'autre sens peut etre on aura pas besoin de boucler ^^ a verifier<br> if(endessous[cpt] != 0xff)<br> abc[endessous[cpt]][cpt-1] = abc[1][cpt];<br> for(;cpt;cpt--)
<br> {<br> for(ptr=0; ptr < nbporte[cpt];ptr++)<br> {<br> switch(type)<br> {<br> case '+':<br> checkbitforadd(&(abc[ptr*2][cpt-1]),&(abc[(ptr*2)+1][cpt-1]),&(abc[ptr][cpt]));<br>
break;<br> case '|':<br> checkbitforor(&(abc[ptr*2][cpt-1]),&(abc[(ptr*2)+1][cpt-1]),&(abc[ptr][cpt]));<br> break;<br> case '&':<br> checkbitforand(&(abc[ptr*2][cpt-1]),&(abc[(ptr*2)+1][cpt-1]),&(abc[ptr][cpt]));
<br> break;<br> case '^':<br> checkbitforxor(&(abc[ptr*2][cpt-1]),&(abc[(ptr*2)+1][cpt-1]),&(abc[ptr][cpt]));<br> break;<br> }<br> }<br> if(endessous[cpt] != 0xff)<br> abc[endessous[cpt]][cpt-1] = abc[ptr+1][cpt];
<br> }<br> if(endessous[0] != 0xff)<br> *(list->wesh[tmp]) = abc[nbporte[cpt]][0];<br> for(unsigned char ok=0;ok < list->nb;ok+=2)<br> {<br> switch(type)<br> {<br> case '+':<br> if(checkbitforadd(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0])))
<br> modified = 1;<br> break;<br> case '|':<br> if(checkbitforor(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0])))<br> modified = 1;<br> break;<br> case '&':<br> if(checkbitforand(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0])))
<br> modified = 1;<br> break;<br> case '^':<br> if(checkbitforxor(list->wesh[ok],list->wesh[ok+1],&(abc[ok/2][0])))<br> modified = 1;<br> break;<br> }<br> }<br> }while(modified);
<br> delete[] (char *)list;<br> return ret;<br>}</p>
<p>struct quantparam *qbyte::newlist(qbyte &a,char type)<br>{<br> struct quantparam *abc;<br> abc = (struct quantparam *) new char[PARAM_LIST_SIZE_BASE + (sizeof(struct quantique *)*2)];<br> abc->size = PARAM_LIST_SIZE_BASE + (sizeof(struct quantique *)*2);
<br> abc->type = type;<br> abc->nb = 2;<br> abc->error = this->error | a.error;<br> abc->wesh[0] = &(this->me);<br> abc->wesh[1] = &(a.me);<br> return abc;<br>}</p>
<p>struct quantparam *qbyte::addtolist(struct quantparam * list,char type)<br>{<br> struct quantparam *tmp;<br> if(type != list->type)<br> {<br> cout <<"wesh lascar, on supporte pas trop les melange sur ste version modif ton code la lib fait un exit(0); la:P"<<endl;
<br> exit(0);<br> }<br> tmp = (struct quantparam *) new char[list->size + sizeof(struct quantique *)];<br> memcpy(tmp,list,list->size);<br> tmp->wesh[list->nb] = &(this->me);<br> delete[] (char *)list;
<br> tmp->nb++;<br> return tmp;<br>}</p>
<p>struct quantparam * qbyte::operator + (qbyte &a)<br>{<br> return newlist(a,'+');<br>}</p>
<p>struct quantparam * qbyte::operator + (struct quantparam * list)<br>{<br> return addtolist(list,'+');<br>}</p>
<p>bool qbyte::operator = (struct quantparam *list)<br>{<br> return pyramide(list,list->type);<br>}</p>
<p>bool qbyte::operator = (qbyte &a)<br>{<br> return fusion(a);<br>}</p>
<p>struct quantparam * qbyte::operator | (qbyte &a)<br>{<br> return newlist(a,'|');<br>}</p>
<p>struct quantparam * qbyte::operator | (struct quantparam * list)<br>{<br> return addtolist(list,'|');<br>}</p>
<p>struct quantparam * qbyte::operator & (qbyte &a)<br>{<br> return newlist(a,'&');<br>}</p>
<p>struct quantparam * qbyte::operator & (struct quantparam * list)<br>{<br> return addtolist(list,'&');<br>}</p>
<p>struct quantparam * qbyte::operator ^ (qbyte &a)<br>{<br> return newlist(a,'^');<br>}</p>
<p>struct quantparam * qbyte::operator ^ (struct quantparam * list)<br>{<br> return addtolist(list,'^');<br>}<br> <br>struct quantparam * qbyte::operator * (unsigned int constante)<br>{<br> struct quantparam *abc;
<br> abc = (struct quantparam *) new char[PARAM_LIST_SIZE_BASE + (sizeof(struct quantique *)*2)];<br> abc->size = PARAM_LIST_SIZE_BASE + (sizeof(struct quantique *)*2);<br> abc->type = '*';<br> abc->nb = 2;
<br> abc->error = this->error ;<br> abc->wesh[0] = &(this->me);<br> abc->wesh[1] = (struct quantique *) constante;<br> return abc;<br>}</p>
<p>//profondeur d'erreur ...<br>void qbyte::increment()<br>{<br> if(!enable)<br> return;<br> if(saved)<br> {<br> //redzone++;<br> return ;<br> }<br> if(compteur == ~0x00)<br> compteur2++;<br> compteur++;<br>}</p>
<p>void qbyte::savedepth()<br>{<br> savedepth(0);<br>}</p>
<p>void qbyte::savedepth(bool b)<br>{<br> if(!enable)<br> return;<br> if(saved)<br> {<br> if(b)<br> redzone++;<br> return;<br> }<br> profondeur = compteur;<br> profondeur2 = compteur2;<br> ldepth = compteur;<br> hdepth = compteur2;
<br> saved = 1;<br> redzone = 1;<br>}</p>
<p>bool qbyte::enabledepth()<br>{<br> reinitdepth();<br> if(enable)<br> return 0;<br> enable = 1;<br> return 1;<br>}</p>
<p>bool qbyte::depthisenable()<br>{<br> return enable;<br>}</p>
<p>bool qbyte::disabledepth()<br>{<br> if(!enable)<br> return 0;<br> enable = 0;<br> reinitdepth();<br> return 1;<br>}</p>
<p>void qbyte::reinitdepth()<br>{<br> compteur = 0;<br> compteur2 = 0;<br> profondeur = 0;<br> profondeur2 = 0;<br> ldepth = 0;<br> hdepth = 0;<br> redzone = 0;<br> saved = 0;<br>}</p>
<p>unsigned int qbyte::getldepth()<br>{<br> if(saved)<br> return profondeur;<br> else<br> return compteur;<br>}</p>
<p>unsigned int qbyte::gethdepth()<br>{<br> if(saved)<br> return profondeur2;<br> else<br> return compteur2;<br>}</p>
<p>unsigned int qbyte::getredzone()<br>{<br> return redzone;<br>}</p>
<p>bool qbyte::depthsaved()<br>{<br> return saved;<br>}</p>
<p>bool qbyte::enablecopyerror()<br>{<br> if(copyerror)<br> return 0;<br> copyerror = 1;<br> return 1;<br>}</p>
<p>bool qbyte::disablecopyerror()<br>{<br> if(!copyerror)<br> return 0;<br> copyerror = 0;<br> return 1;<br>}<br></p>