BRAINFUCK_ASCII_ART_CONVERTER

/* BF:BRAINFUCK_ASCII_ART_CONVERTER 2013-12-23 v1.0      *
 * file:main.c                                           *
 * Compile:gcc -o BFConverter main.c                     *
 * gcc(1):http://gcc.gnu.org/releases.html               *
 * gcc(2):http://www.bloodshed.net/download.html         *
 * BF generator:http://brainfuck.tk/                     *
 * Credits:w2ch.org-Anon                                 */


#include <stdio.h> //FILE, fopen(), fprintf(), fclose(), perror()


void CalculateSmallesValueToGetNumber(char*, char*, char*, char unsigned);


char unsigned strASCIITable[256]; /* all ASCII char */ //this is global because all need to be 0 in the str
//NOTE:Shall it not be '+' instead of "+"???
//fputc('>', fpOutput); - ???????


int main(int argc, char **argv)
{
    if(argc!=3)
    {
        fprintf(stderr, "Usage:%s output.txt input.txt\n", argv[0]);
        return 0;
    }


    FILE *fpOutput, *fpInput;

    fpOutput = fopen(argv[1],"a");
    if(fpOutput==NULL)
    {
        perror("Error opening file"); //fprintf(stderr, "ERORR0!:output.txt(%s) could not be open\n", argv[1]);
        return 1;
    }
    fpInput = fopen(argv[2],"r");
    if(fpInput==NULL)
    {
        if(fclose(fpOutput)==EOF) fprintf(stderr, "ERORR2!:fclose(%s) failed\n", argv[1]); //perror ?
        perror("Error opening file"); //fprintf(stderr, "ERORR1!:input.txt(%s) could not be open\n", argv[2]);
        return 1;
    }

    /* ---------------------------------------------------------------------- */
    char unsigned cBrainFuckInputCharecter;
    char unsigned cX, cY;
    char signed cOverflow;

    char unsigned cPosision=0;

    //Extra for displaying values for debuging
    //for(cBrainFuckInputCharecter=1; cBrainFuckInputCharecter!=75; ++cBrainFuckInputCharecter) CalculateSmallesValueToGetNumber(&cX, &cY, &cOverflow, cBrainFuckInputCharecter);
    //CalculateSmallesValueToGetNumber(&cX, &cY, &cOverflow, cBrainFuckInputCharecter);

    while((cBrainFuckInputCharecter=(char unsigned)fgetc(fpInput))!=(char unsigned)EOF)
    {
        for(cOverflow=0; strASCIITable[cOverflow]!=cBrainFuckInputCharecter && strASCIITable[cOverflow]!=0; ++cOverflow);

        if(strASCIITable[cOverflow])
        {
            if(cPosision!=cOverflow)
            {
                if(cPosision>cOverflow) for (;cPosision>cOverflow; --cPosision) fprintf(fpOutput, "<");
                else for(;cPosision<cOverflow; ++cPosision) fprintf(fpOutput, ">");
            }
        }
        else
        {
            for(;cPosision<cOverflow; ++cPosision) fprintf(fpOutput, ">");
            strASCIITable[cOverflow]=cBrainFuckInputCharecter;

            CalculateSmallesValueToGetNumber(&cX, &cY, &cOverflow, cBrainFuckInputCharecter);
            if(cX)
            {
                fprintf(fpOutput, ">"); //e.g:>+++[<+++++>-]<+
                while(cX--) fprintf(fpOutput, "+");
                fprintf(fpOutput, "[<");
                while(cY--) fprintf(fpOutput, "+");
                fprintf(fpOutput, ">-]<"); //NOTE:I never counted on that last '<'!
            }
            if(cOverflow>=0) while(cOverflow--) fprintf(fpOutput, "+");
            else while(cOverflow++) fprintf(fpOutput, "-");
        }

        fprintf(fpOutput, ".");
    }

    /* ---------------------------------------------------------------------- */

    if(fclose(fpOutput)==EOF || fclose(fpInput)==EOF) fprintf(stderr, "ERORR3!:fclose(%s) or fclose(%s) failed\n", argv[1], argv[2]);
    return 0;
}


void CalculateSmallesValueToGetNumber(char *cX, char *cY, char *cRest, char unsigned cNumberToCalculate) //NOTE:This function you can make better like value 57(+1 instead of +2) but that I will do later version!
{
    char unsigned cXMax=0, cYMax=0;
    char unsigned cXMaxOneDown=0, cYMaxOneDown=0;
    char signed cOverflow=0; //need not to be unsigned as it must be minus to say how many steps we need to "walk" to get to cNumberToCalculate, NOTE:This must be from range -16 to +16(32 numbers in tottal) as the max value of cXMax is 16. More info you find in math!

    //Extra for displaying values for debuging
    //fprintf(stdout, "cNumberToCalculate:%d\n", (int)cNumberToCalculate);

    if(cNumberToCalculate>14) // step0:Is it bigger then 14?
    {
        //step1:What range is it max?
        for(cXMax=8; ((cYMax=(cXMax/2))*(cXMax-cYMax)) < cNumberToCalculate; cXMax++); //need to start at 8 as 7 is below(14-6/2=7/2) making it go faster! NOTE:cYMax is being handeled like overflow!
        cXMax=cXMax-cYMax;

        //step1.5:Adjust cXMax and cYMax rang and add cXMaxOneDown and cYMaxOneDown range
        for(;(((cXMax*cYMax)-cNumberToCalculate) > 0); cXMax+=1, cYMax-=1);
        cXMaxOneDown=cXMax-1; //2nd time to "adjust"
        cYMaxOneDown=cYMax+1;

        //step2:Minus or Plus for overflow
        if(!((cXMax*cYMax)-cNumberToCalculate)) ;
        else
        {
            if((((cXMax*cYMax)-cNumberToCalculate) < (cNumberToCalculate-(cXMaxOneDown*cYMaxOneDown)))) cOverflow=cNumberToCalculate-(cXMaxOneDown*cYMaxOneDown);
            else cOverflow=cNumberToCalculate-(cXMax*cYMax);
        }

        //Extra for displaying values for debuging nothing more here!
        //fprintf(stdout, "Start:%d\tcXMax(%d)*cYMax(%d)=%d\nStart:%d\tcXMaxOneDown(%d)*cYMaxOneDown(%d)=%d\n", (int)(cXMax+cYMax), (int)cXMax, (int)cYMax, (int)(cXMax*cYMax), (int)(cXMaxOneDown+cYMaxOneDown), (int)cXMaxOneDown, (int)cYMaxOneDown, (int)(cXMaxOneDown*cYMaxOneDown));
    }
    else cOverflow=cNumberToCalculate;

    //Extra for displaying values for debuging
    //fprintf(stdout, "cOverflow:%d\n", (int)cOverflow);

    if(cNumberToCalculate==((cXMaxOneDown*cYMaxOneDown)+cOverflow)) //return value for function
    {
        *cX=cXMaxOneDown;
        *cY=cYMaxOneDown;
    }
    else
    {
        *cX=cXMax;
        *cY=cYMax;
    }
    *cRest=cOverflow;
}