unsigned char *mulb(unsigned char **numberOne,unsigned char **numberTwo,int lenghtFirst,int lenghtSecond,int *lenghtSumm)
{
unsigned char *result,*help;
int i,j,carry,temp,resultLenght,it;
result = (unsigned char*)malloc(lenghtFirst*lenghtSecond+5);
for (i=0;i<lenghtFirst*lenghtSecond+5;i++)
result[i]=0;
i=0;
help = (unsigned char*)malloc(lenghtFirst*lenghtSecond+5);
while (1)
{
if (i == lenghtSecond)
break;
for (j=0;j<i;j++)
help[j]=0;
j=0;carry=0;
while(1)
{
if (j == lenghtFirst)
break;
temp = (*numberTwo)[i]*(*numberOne)[j];
help[i+j] = (temp+carry)%256;
carry = (temp+carry)/256;
j++;
}
if (carry != 0)
{
help[i+j] = carry;
if (i != 0)
result = summb(&result,&help,resultLenght,i+j+1,&resultLenght);
else
{
for (it=0;it<i+j+1;it++)
result[it]=help[it];;
resultLenght=i+j+1;
}
}
else
{
if (i != 0)
result = summb(&result,&help,resultLenght,i+j,&resultLenght);
else
{
for (it=0;it<i+j;it++)
result[it]=help[it];;
resultLenght=i+j;
}
}
i++;
}
*lenghtSumm = resultLenght;
return result;
}
veryLong veryLong::operator+(veryLong n1)
{
veryLong n;
unsigned char *del;
if (!binary)
{
turn(&number);
turn(&n1.number);
del=n.number;
if ((znak=='+')&&(n1.znak=='+'))
{
n.number = summ(&number,&n1.number);
n.znak='+';
}
if ((znak=='-')&&(n1.znak=='-'))
{
n.number = summ(&number,&n1.number);
n.znak='-';
}
if ((znak=='+')&&(n1.znak=='-'))
{
if (cmp(&number,&n1.number) == 1)
{
n.number = sub(&number,&n1.number);
n.znak='+';
}
else
{
n.number = sub(&n1.number,&number);
n.znak='-';
}
}
if ((znak=='-')&&(n1.znak=='+'))
{
if (cmp(&number,&n1.number) == 1)
{
n.number = sub(&number,&n1.number);
n.znak='-';
}
else
{
n.number = sub(&n1.number,&number);
n.znak='+';
}
}
n.lenght = strlenn(&n.number);
n.binary=binary;
turn(&number);
turn(&n1.number);
turn(&n.number);
if (del != NULL)
free(del);
}
else
{
n.number = summb(&number,&n1.number,lenght,n1.lenght,&n.lenght);
n.binary=binary;
}
return n;
}
unsigned char *stepenb(unsigned char **numberOne,unsigned char **numberTwo,int lenghtFirst,int lenghtSecond,int *lenghtSumm)
{
int i,lenght,lenghtSt;
unsigned char *firstNumber,*st,*incr;
firstNumber = (unsigned char*)malloc(lenghtFirst+2);
st = (unsigned char*)malloc(block);
incr = (unsigned char*)malloc(4);
st[0]=1;
incr[0]=1;
lenghtSt=1;
for (i=0;i<lenghtFirst;i++)
firstNumber[i]=(*numberOne)[i];
lenght=lenghtFirst;
while(1)
{
if (cmpb(&st,&(*numberTwo),lenghtSt,lenghtSecond) == 2)
break;
firstNumber = mulb(&firstNumber,&(*numberOne),lenght,lenghtFirst,&lenght);
st=summb(&st,&incr,lenghtSt,1,&lenghtSt);
}
*lenghtSumm=lenght;
return firstNumber;
}
unsigned char *divvb(unsigned char **numberOne,unsigned char **numberTwo,int lenghtFirst,int lenghtSecond,int *lenghtSumm,unsigned char **ostatok,int *lenghtOst)
{
int i,j,k,q,lenghtDelitel,c;
unsigned char *delimoe,*delitel,*answer;
delimoe = (unsigned char*)malloc(2*lenghtFirst);
delitel = (unsigned char*)malloc(2*lenghtSecond);
answer = (unsigned char*)malloc(2*lenghtFirst);
q=0;
i=0;j=0;
while(1)
{
if (i == lenghtFirst)
break;
if ((j != 0) || ((*numberOne)[i] != 0))
delimoe[j]=(*numberOne)[i];
else
j--;
j++;
if (cmpb(&delimoe,&(*numberTwo),j,lenghtSecond) > 0)
{
for (k=0;k<lenghtSecond;k++)
delitel[k]=(*numberTwo)[k];
lenghtDelitel=k;
k=1;
while(1)
{
c=cmpb(&delitel,&delimoe,lenghtDelitel,j);
if (c >0)
{
if (c == 1)
{
if (lenghtDelitel != 1)
turnb(&delitel,lenghtDelitel);
if (lenghtSecond != 1)
turnb(&(*numberTwo),lenghtSecond);
delitel = subb(&delitel,&(*numberTwo),lenghtDelitel,lenghtSecond,&lenghtDelitel);
if (lenghtDelitel != 1)
turnb(&delitel,lenghtDelitel);
if (lenghtSecond != 1)
turnb(&(*numberTwo),lenghtSecond);
k--;
}
answer[q]=k;
q++;
break;
}
else
{
if (lenghtDelitel != 1)
turnb(&delitel,lenghtDelitel);
if (lenghtSecond != 1)
turnb(&(*numberTwo),lenghtSecond);
delitel=summb(&delitel,&(*numberTwo),lenghtDelitel,lenghtSecond,&lenghtDelitel);
if (lenghtDelitel != 1)
turnb(&delitel,lenghtDelitel);
if (lenghtSecond != 1)
turnb(&(*numberTwo),lenghtSecond);
k++;
}
}
if (j != 1)
turnb(&delimoe,j);
if (lenghtDelitel != 1)
turnb(&delitel,lenghtDelitel);
delimoe = subb(&delimoe,&delitel,j,lenghtDelitel,&j);
if (j != 1)
turnb(&delimoe,j);
if (lenghtDelitel != 1)
turnb(&delitel,lenghtDelitel);;
if ((j == 1) && (delimoe[0]==0))
j=0;
i++;
}
else
{
if (q != 0)
{
answer[q]=0;
q++;
}
i++;
}
}
if (q == 0)
{
answer[0]='0';
q++;
}
*lenghtSumm=q;
if (j != 0)
{
(*ostatok)=delimoe;
*lenghtOst=j;
}
else
{
(*ostatok)=delimoe;
*lenghtOst=1;
}
return answer;
}
int main(int argc, char *argv[])
{
char *inputFirst,*inputSecond,*inputThird;
FILE *output;
int lenghtFirst,lenghtSecond,i,binary,module,lenghtModule;
unsigned char *numberOne,*numberTwo,*ostatok,*numModule;
unsigned char znak1,znak2,znak3;
char znak;
if (argc < 5 )
{
printf("\nEnter correct parameters\n");
return 0;
}
if (argc == 7)
{
binary=1;
module=1;
inputThird=argv[6];
lenghtModule = readb(&numModule,inputThird);
}
if (argc == 6)
{
if (strcmp(argv[5],"-b") == 0)
{
binary=1;
module=0;
}
else
{
binary=0;
module=1;
inputThird=argv[5];
lenghtModule = readd(&numModule,inputThird,&znak3);
}
}
if (argc < 6)
{
binary=0;
module=0;
}
inputFirst =argv[1];
inputSecond=argv[3];
if(!binary)
{
output = fopen(argv[4],"w");
}
else
{
output = fopen(argv[4],"wb");
}
znak=argv[2][0];
switch(znak)
{
case '+' :
if (!binary)
{
lenghtFirst = readd(&numberOne,inputFirst,&znak1);
lenghtSecond = readd(&numberTwo,inputSecond,&znak2);
turn(&numberOne);
turn(&numberTwo);
if ((znak1=='+')&&(znak2=='+'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
break;
}
if ((znak1=='-')&&(znak2=='-'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
break;
}
if ((znak1=='+')&&(znak2=='-'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
break;
}
if ((znak1=='-')&&(znak2=='+'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
break;
}
}
else
{
lenghtFirst = readb(&numberOne,inputFirst);
lenghtSecond = readb(&numberTwo,inputSecond);
numberOne=summb(&numberOne,&numberTwo,lenghtFirst,lenghtSecond,&lenghtFirst);
fwrite(numberOne,lenghtFirst,1,output);
}
break;
case '-' :
if (!binary)
{
lenghtFirst = readd(&numberOne,inputFirst,&znak1);
lenghtSecond = readd(&numberTwo,inputSecond,&znak2);
turn(&numberOne);
turn(&numberTwo);
if ((znak1=='+')&&(znak2=='+'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
break;
}
if ((znak1=='-')&&(znak2=='-'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
break;
}
if ((znak1=='+')&&(znak2=='-'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
break;
}
if ((znak1=='-')&&(znak2=='+'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
break;
}
}
else
{
lenghtFirst = readb(&numberOne,inputFirst);
lenghtSecond = readb(&numberTwo,inputSecond);
numberOne=subb(&numberOne,&numberTwo,lenghtFirst,lenghtSecond,&lenghtFirst);
fwrite(numberOne,lenghtFirst,1,output);
}
break;
case '*' :
if (!binary)
{
lenghtFirst = readd(&numberOne,inputFirst,&znak1);
lenghtSecond = readd(&numberTwo,inputSecond,&znak2);
turn(&numberOne);
turn(&numberTwo);
if (((znak1=='+')&&(znak2=='+'))||((znak1=='-')&&(znak2=='-')))
{
numberOne=mul(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
else
{
numberOne=mul(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
}
else
{
lenghtFirst = readb(&numberOne,inputFirst);
lenghtSecond = readb(&numberTwo,inputSecond);
numberOne=mulb(&numberOne,&numberTwo,lenghtFirst,lenghtSecond,&lenghtFirst);
fwrite(numberOne,lenghtFirst,1,output);
}
break;
case '/' :
if (!binary)
{
lenghtFirst = readd(&numberOne,inputFirst,&znak1);
lenghtSecond = readd(&numberTwo,inputSecond,&znak2);
if (((znak1=='+')&&(znak2=='+'))||((znak1=='-')&&(znak2=='-')))
{
fprintf(output,"%s",divv(&numberOne,&numberTwo,&ostatok));
}
else
{
fprintf(output,"-%s",divv(&numberOne,&numberTwo,&ostatok));
}
}
else
{
lenghtFirst = readb(&numberOne,inputFirst);
lenghtSecond = readb(&numberTwo,inputSecond);
turnb(&numberOne,lenghtFirst);
turnb(&numberTwo,lenghtSecond);
numberOne=divvb(&numberOne,&numberTwo,lenghtFirst,lenghtSecond,&lenghtFirst,&ostatok,&lenghtSecond);
turnb(&numberOne,lenghtFirst);
fwrite(numberOne,lenghtFirst,1,output);
}
break;
case '%' :
if (!binary)
{
lenghtFirst = readd(&numberOne,inputFirst,&znak1);
lenghtSecond = readd(&numberTwo,inputSecond,&znak2);
divv(&numberOne,&numberTwo,&ostatok);
fprintf(output,"%s",ostatok);
}
else
{
lenghtFirst = readb(&numberOne,inputFirst);
lenghtSecond = readb(&numberTwo,inputSecond);
turnb(&numberOne,lenghtFirst);
turnb(&numberTwo,lenghtSecond);
divvb(&numberOne,&numberTwo,lenghtFirst,lenghtSecond,&lenghtFirst,&ostatok,&lenghtSecond);
turnb(&ostatok,lenghtSecond);
fwrite(ostatok,lenghtSecond,1,output);
free(ostatok);
}
break;
case '^' :
if (!binary)
{
lenghtFirst = readd(&numberOne,inputFirst,&znak1);
lenghtSecond = readd(&numberTwo,inputSecond,&znak2);
turn(&numberOne);
turn(&numberTwo);
numberOne=stepen(&numberOne,&numberTwo,&znak1);
turn(&numberOne);
if (znak1=='+')
fprintf(output,"%s",numberOne);
else
fprintf(output,"-%s",numberOne);
}
else
{
lenghtFirst = readb(&numberOne,inputFirst);
lenghtSecond = readb(&numberTwo,inputSecond);
numberOne=stepenb(&numberOne,&numberTwo,lenghtFirst,lenghtSecond,&lenghtFirst);
fwrite(numberOne,lenghtFirst,1,output);
}
break;
default:
break;
}
fclose(output);
if (module)
{
if(!binary)
{
output = fopen(argv[4],"w");
divv(&numberOne,&numModule,&ostatok);
fprintf(output,"%s",ostatok);
}
else
{
output = fopen(argv[4],"wb");
turnb(&numberOne,lenghtFirst);
turnb(&numModule,lenghtModule);
divvb(&numberOne,&numModule,lenghtFirst,lenghtModule,&lenghtFirst,&ostatok,&lenghtModule);
turnb(&ostatok,lenghtModule);
fwrite(ostatok,lenghtModule,1,output);
}
fclose(output);
}
return 0;
}
unsigned char *divvb(unsigned char **numberOne,unsigned char **numberTwo,int lengthFirst,int lengthSecond,int *lengthSumm,unsigned char **remainder,int *lengthOst)
{
int i,j,k,q,lengthdivisor,c,z=0;
unsigned char *dividend,*divisor,*answer,*helpdivisor;
dividend = (unsigned char*)malloc(lengthFirst);
divisor = (unsigned char*)malloc(lengthSecond+lengthSecond/2);
answer = (unsigned char*)malloc(lengthFirst);
q=0;
i=0;j=0;
while(1)
{
if ((*numberTwo)[i] == 0)
{
answer[i]=0;
z++;
i++;
}
else break;
}
i=0;
while(1)
{
if ((*numberOne)[i] == 0)
{
answer[i]=0;
z++;
i++;
}
else
{
answer[i]=0;
z++;
break;
}
}
q=z;
while(1)
{
if (i == lengthFirst)
break;
if ((j != 0) || ((*numberOne)[i] != 0))
dividend[j]=(*numberOne)[i];
else
j--;
j++;
if (cmpb(÷nd,&(*numberTwo),j,lengthSecond) > 0)
{
for (k=0;k<lengthSecond;k++)
divisor[k]=(*numberTwo)[k];
lengthdivisor=k;
k=1;
if (lengthSecond != 1)
turnb(&(*numberTwo),lengthSecond);
while(1)
{
c=cmpb(&divisor,÷nd,lengthdivisor,j);
if (c >0)
{
if (c == 1)
{
if (lengthdivisor != 1)
turnb(&divisor,lengthdivisor);
//if (lengthSecond != 1)
//turnb(&(*numberTwo),lengthSecond);
helpdivisor = subb(&divisor,&(*numberTwo),lengthdivisor,lengthSecond,&lengthdivisor);
free(divisor);
divisor=helpdivisor;
if (lengthdivisor != 1)
turnb(&divisor,lengthdivisor);
//if (lengthSecond != 1)
//turnb(&(*numberTwo),lengthSecond);
k--;
}
answer[q]=k;
q++;
break;
}
else
{
if (lengthdivisor != 1)
turnb(&divisor,lengthdivisor);
//if (lengthSecond != 1)
//turnb(&(*numberTwo),lengthSecond);
helpdivisor=summb(&divisor,&(*numberTwo),lengthdivisor,lengthSecond,&lengthdivisor);
free(divisor);
divisor=helpdivisor;
if (lengthdivisor != 1)
turnb(&divisor,lengthdivisor);
//if (lengthSecond != 1)
//turnb(&(*numberTwo),lengthSecond);
k++;
}
}
if (lengthSecond != 1)
turnb(&(*numberTwo),lengthSecond);
if (j != 1)
turnb(÷nd,j);
if (lengthdivisor != 1)
turnb(&divisor,lengthdivisor);
dividend = subb(÷nd,&divisor,j,lengthdivisor,&j);
if (j != 1)
turnb(÷nd,j);
if (lengthdivisor != 1)
turnb(&divisor,lengthdivisor);;
if ((j == 1) && (dividend[0]==0))
j=0;
i++;
}
else
{
if (q != z)
{
answer[q]=0;
q++;
}
i++;
}
}
if (q == 0)
{
answer[0]='0';
q++;
}
*lengthSumm=q;
if (j != 0)
{
(*remainder)=dividend;
*lengthOst=j;
}
else
{
(*remainder)=dividend;
*lengthOst=1;
}
return answer;
}
int main(int argc, char *argv[])
{
FILE *output;
char *inputFirst,*inputSecond,*inputThird;
int lengthFirst,lengthSecond,i,binary,module,lengthModule;
unsigned char *numberOne,*numberTwo,*remainder,*numModule;
unsigned char sign1,sign2,sign3;
char sign;
if (argc < 5 )
{
printf("\nEnter correct parameters\n");
return 0;
}
if (argc < 6)
{
binary=0;
module=0;
}
if (argc == 6)
{
if (strcmp(argv[5],"-b") == 0)
{
binary=1;
module=0;
}
else
{
binary=0;
module=1;
inputThird=argv[5];
lengthModule = readd(&numModule,inputThird,&sign3);
}
}
if (argc == 7)
{
binary=1;
module=1;
inputThird=argv[6];
lengthModule = readb(&numModule,inputThird);
}
inputFirst =argv[1];
inputSecond=argv[3];
if(!binary)
{
output = fopen(argv[4],"w");
}
else
{
output = fopen(argv[4],"wb");
}
sign=argv[2][0];
switch(sign)
{
case '+' :
if (!binary)
{
lengthFirst = readd(&numberOne,inputFirst,&sign1);
lengthSecond = readd(&numberTwo,inputSecond,&sign2);
turn(&numberOne);
turn(&numberTwo);
if ((sign1=='+')&&(sign2=='+'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
break;
}
if ((sign1=='-')&&(sign2=='-'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
break;
}
if ((sign1=='+')&&(sign2=='-'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
break;
}
if ((sign1=='-')&&(sign2=='+'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
break;
}
}
else
{
lengthFirst = readb(&numberOne,inputFirst);
lengthSecond = readb(&numberTwo,inputSecond);
numberOne=summb(&numberOne,&numberTwo,lengthFirst,lengthSecond,&lengthFirst);
fwrite(numberOne,lengthFirst,1,output);
}
break;
case '-' :
if (!binary)
{
lengthFirst = readd(&numberOne,inputFirst,&sign1);
lengthSecond = readd(&numberTwo,inputSecond,&sign2);
turn(&numberOne);
turn(&numberTwo);
if ((sign1=='+')&&(sign2=='+'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
break;
}
if ((sign1=='-')&&(sign2=='-'))
{
if (cmp(&numberOne,&numberTwo) == 1)
{
numberOne = sub(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
else
{
numberOne = sub(&numberTwo,&numberOne);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
break;
}
if ((sign1=='+')&&(sign2=='-'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
break;
}
if ((sign1=='-')&&(sign2=='+'))
{
numberOne = summ(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
break;
}
}
else
{
lengthFirst = readb(&numberOne,inputFirst);
lengthSecond = readb(&numberTwo,inputSecond);
numberOne=subb(&numberOne,&numberTwo,lengthFirst,lengthSecond,&lengthFirst);
fwrite(numberOne,lengthFirst,1,output);
}
break;
case '*' :
if (!binary)
{
lengthFirst = readd(&numberOne,inputFirst,&sign1);
lengthSecond = readd(&numberTwo,inputSecond,&sign2);
turn(&numberOne);
turn(&numberTwo);
if (((sign1=='+')&&(sign2=='+'))||((sign1=='-')&&(sign2=='-')))
{
numberOne=mul(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"%s",numberOne);
}
else
{
numberOne=mul(&numberOne,&numberTwo);
turn(&numberOne);
fprintf(output,"-%s",numberOne);
}
}
else
{
lengthFirst = readb(&numberOne,inputFirst);
lengthSecond = readb(&numberTwo,inputSecond);
numberOne=mulb(&numberOne,&numberTwo,lengthFirst,lengthSecond,&lengthFirst);
fwrite(numberOne,lengthFirst,1,output);
}
break;
case '/' :
if (!binary)
{
lengthFirst = readd(&numberOne,inputFirst,&sign1);
lengthSecond = readd(&numberTwo,inputSecond,&sign2);
if (((sign1=='+')&&(sign2=='+'))||((sign1=='-')&&(sign2=='-')))
{
fprintf(output,"%s",divv(&numberOne,&numberTwo,&remainder));
}
else
{
fprintf(output,"-%s",divv(&numberOne,&numberTwo,&remainder));
}
}
else
{
lengthFirst = readb(&numberOne,inputFirst);
lengthSecond = readb(&numberTwo,inputSecond);
turnb(&numberOne,lengthFirst);
turnb(&numberTwo,lengthSecond);
numberOne=divvb(&numberOne,&numberTwo,lengthFirst,lengthSecond,&lengthFirst,&remainder,&lengthSecond);
turnb(&numberOne,lengthFirst);
fwrite(numberOne,lengthFirst,1,output);
}
break;
case '%' :
if (!binary)
{
lengthFirst = readd(&numberOne,inputFirst,&sign1);
lengthSecond = readd(&numberTwo,inputSecond,&sign2);
divv(&numberOne,&numberTwo,&remainder);
fprintf(output,"%s",remainder);
}
else
{
lengthFirst = readb(&numberOne,inputFirst);
lengthSecond = readb(&numberTwo,inputSecond);
turnb(&numberOne,lengthFirst);
turnb(&numberTwo,lengthSecond);
divvb(&numberOne,&numberTwo,lengthFirst,lengthSecond,&lengthFirst,&remainder,&lengthSecond);
turnb(&remainder,lengthSecond);
fwrite(remainder,lengthSecond,1,output);
free(remainder);
}
break;
case '^' :
if (!binary)
{
lengthFirst = readd(&numberOne,inputFirst,&sign1);
lengthSecond = readd(&numberTwo,inputSecond,&sign2);
turn(&numberOne);
turn(&numberTwo);
numberOne=degree(&numberOne,&numberTwo,&sign1);
turn(&numberOne);
if (sign1=='+')
fprintf(output,"%s",numberOne);
else
fprintf(output,"-%s",numberOne);
}
else
{
lengthFirst = readb(&numberOne,inputFirst);
lengthSecond = readb(&numberTwo,inputSecond);
numberOne=degreeb(&numberOne,&numberTwo,lengthFirst,lengthSecond,&lengthFirst);
fwrite(numberOne,lengthFirst,1,output);
}
break;
default:
break;
}
fclose(output);
if (module)
{
if(!binary)
{
output = fopen(argv[4],"w");
divv(&numberOne,&numModule,&remainder);
fprintf(output,"%s",remainder);
}
else
{
output = fopen(argv[4],"wb");
turnb(&numberOne,lengthFirst);
turnb(&numModule,lengthModule);
divvb(&numberOne,&numModule,lengthFirst,lengthModule,&lengthFirst,&remainder,&lengthModule);
turnb(&remainder,lengthModule);
fwrite(remainder,lengthModule,1,output);
}
fclose(output);
}
return 0;
}
