src/vapiResult.c

Ir para a documentação deste ficheiro.

#include <stdio.h>
#include "vapiTypes.h"
#include "vapiResult.h"
#include "vapiAux.h"
#include "vapiMacro.h"
vMacroResult *
vapiMacroResultInit ()
{
        vMacroResult *PreviousResult;
        PreviousResult = malloc (sizeof (vMacroResult));
        PreviousResult->Decision = vFALSE;
        PreviousResult->End = vFALSE;
        PreviousResult->JumpTo = -1;
        PreviousResult->intsNumber = 0;
        PreviousResult->floatsNumber = 0;
        PreviousResult->pointsNumber = 0;
        PreviousResult->charsNumber = 0;
        PreviousResult->macroTag = NULL;
        return PreviousResult;

}

void
vapiResultAddInt (vMacroResult * PreviousResult, int value)
{
        int *intsPtr;

        if (PreviousResult->intsNumber == 0)
        {
                PreviousResult->ints =
                        malloc ((++PreviousResult->intsNumber) *
                                sizeof (int));

        }
        else
        {
                intsPtr =
                        realloc (PreviousResult->ints,
                                 (++PreviousResult->intsNumber) *
                                 sizeof (int));

                PreviousResult->ints = intsPtr;
        }
        PreviousResult->ints[PreviousResult->intsNumber - 1] = value;

}

void
vapiResultAddPoint (vMacroResult * PreviousResult, int x, int y)
{
        vPoint *PointPtr;

        if (PreviousResult->pointsNumber == 0)
        {
                PreviousResult->pointsNumber++;

                PreviousResult->points =
                        malloc (PreviousResult->pointsNumber *
                                sizeof (vPoint));

        }
        else
        {
                PointPtr =
                        realloc (PreviousResult->points,
                                 (++PreviousResult->pointsNumber) *
                                 sizeof (vPoint));
                PreviousResult->points = PointPtr;
        }
        PreviousResult->points[PreviousResult->pointsNumber - 1].x = x;
        PreviousResult->points[PreviousResult->pointsNumber - 1].y = y;
}

void
vapiResultAddFloat (vMacroResult * PreviousResult, double value)
{
        double *floatsPtr;

        if (PreviousResult->floatsNumber == 0)
        {
                PreviousResult->floats =
                        malloc ((++PreviousResult->floatsNumber) *
                                sizeof (double));

        }
        else
        {
                floatsPtr =
                        realloc (PreviousResult->floats,
                                 (++PreviousResult->floatsNumber) *
                                 sizeof (double));

                PreviousResult->floats = floatsPtr;
        }
        PreviousResult->floats[PreviousResult->floatsNumber - 1] = value;

}

void
vapiResultAddChar (vMacroResult * PreviousResult, const char *string)
{
        vChar *charsPtr;

        if (PreviousResult->charsNumber == 0)
        {
                PreviousResult->charsNumber++;
                PreviousResult->chars =
                        malloc ((PreviousResult->charsNumber) *
                                sizeof (vChar));

        }
        else
        {
                PreviousResult->charsNumber++;
                charsPtr =
                        realloc (PreviousResult->chars,
                                 (PreviousResult->charsNumber) *
                                 sizeof (vChar));

                PreviousResult->chars = charsPtr;
        }
        PreviousResult->chars[PreviousResult->charsNumber - 1].ch =
                vapiReturnStringPointer (string);

}

char *
vapiResultGetChar (vMacroResult * PreviousResult, int position)
{
        if (PreviousResult->charsNumber > 0
            && position < PreviousResult->charsNumber)
        {
                return PreviousResult->chars[position].ch;
        }
        else
        {
                return " ";
        }
}

int
vapiResultGetInt (vMacroResult * PreviousResult, int position)
{
        if (PreviousResult->intsNumber > 0
            && position < PreviousResult->intsNumber)
        {
                return PreviousResult->ints[position];
        }
        else
        {
                return 0;
        }
}

double
vapiResultGetFloat (vMacroResult * PreviousResult, int position)
{
        if (PreviousResult->floatsNumber > 0
            && position < PreviousResult->floatsNumber)
        {
                return PreviousResult->floats[position];
        }
        else
        {
                return 0.0;
        }
}

vPoint
vapiResultGetPoint (vMacroResult * PreviousResult, int position)
{
        vPoint point = { 0, 0 };

        if (PreviousResult->pointsNumber > 0
            && position < PreviousResult->pointsNumber)
        {
                return PreviousResult->points[position];
        }
        else
        {
                return point;
        }
}

int
vapiResultGetIntsNumber (vMacroResult * PreviousResult)
{
        return PreviousResult->intsNumber;
}

int
vapiResultGetFloatsNumber (vMacroResult * PreviousResult)
{
        return PreviousResult->floatsNumber;
}

int
vapiResultGetCharsNumber (vMacroResult * PreviousResult)
{
        return PreviousResult->charsNumber;
}

int
vapiResultGetPointsNumber (vMacroResult * PreviousResult)
{
        return PreviousResult->pointsNumber;
}

void
vapiResultSetEnd (vMacroResult * PreviousResult)
{
        PreviousResult->End = vTRUE;
}

void
vapiResultSetJumpTo (vMacroResult * PreviousResult, int OperationOrder)
{
        PreviousResult->JumpTo = OperationOrder;
}

int
vapiResultGetJumpTo (vMacroResult * PreviousResult)
{
        return PreviousResult->JumpTo;
}

void
vapiResultSetDecision (vMacroResult * PreviousResult, vBoolean Decision)
{
        PreviousResult->Decision = Decision;
}

vBoolean
vapiResultGetDecision (vMacroResult * PreviousResult)
{
        return PreviousResult->Decision;
}


void
vResultResetInts (vMacroResult * PreviousResult)
{
        if (PreviousResult->intsNumber)
        {
                free (PreviousResult->ints);
                PreviousResult->intsNumber = 0;
        }
}

void
vResultResetChars (vMacroResult * PreviousResult)
{
        int i;
        if (PreviousResult->charsNumber)
        {
                for (i = 0; i < PreviousResult->charsNumber; i++)
                {
                        free (PreviousResult->chars[i].ch);
                }
                free (PreviousResult->chars);
                PreviousResult->charsNumber = 0;
        }
}

void
vResultResetPoints (vMacroResult * PreviousResult)
{
        if (PreviousResult->pointsNumber)
        {
                free (PreviousResult->points);
                PreviousResult->pointsNumber = 0;
        }
}

void
vResultReset (vMacroResult * PreviousResult)
{
        vResultResetInts (PreviousResult);
        vResultResetPoints (PreviousResult);
        vResultResetChars (PreviousResult);
        PreviousResult->Decision = vFALSE;
        PreviousResult->End = vFALSE;
        PreviousResult->JumpTo = -1;
        if (PreviousResult->macroTag != NULL)
        {
                free (PreviousResult->macroTag);
                PreviousResult->macroTag = NULL;
        }
}

void
vResultFree (vMacroResult * PreviousResult)
{
        vResultReset (PreviousResult);
        free (PreviousResult);
}

char *
vapiResultPrintf (const char *inString, vMacroResult * PreviousResult)
{
        int inStringLen, i;
        char parsedString[255], *outString;
        inStringLen = strlen (inString);


        strcpy (parsedString, "");
        for (i = 0; i < inStringLen; i++)
        {
                if (inString[i] == '\\')
                {
                        i++;
                        continue;
                }
                if (inString[i] == '%')
                {
                        switch (inString[++i])
                        {
                        case 'r':
                        {
                                switch (inString[++i])
                                {
                                case 'd':
                                {
                                        if (PreviousResult->intsNumber == 0)
                                        {
                                                ++i;
                                                continue;
                                                break;

                                        }
                                        sprintf (parsedString, "%s%d",
                                                 parsedString,
                                                 PreviousResult->
                                                 ints[atoi (&inString[++i])]);
                                        continue;
                                        break;

                                }
                                case 'p':
                                {
                                        if (PreviousResult->pointsNumber == 0)
                                        {
                                                ++i;
                                                continue;
                                                break;

                                        }
                                        ++i;
                                        sprintf (parsedString,
                                                 "%s (%d,%d)",
                                                 parsedString,
                                                 PreviousResult->
                                                 points[atoi
                                                        (&inString
                                                         [i])].x,
                                                 PreviousResult->
                                                 points[atoi (&inString[i])].
                                                 y);
                                        continue;
                                        break;

                                }
                                case 's':
                                {
                                        if (PreviousResult->charsNumber == 0)
                                        {
                                                ++i;
                                                continue;
                                                break;

                                        }
                                        ++i;
                                        sprintf (parsedString,
                                                 "%s (%d,%s)",
                                                 parsedString,
                                                 PreviousResult->
                                                 points[atoi
                                                        (&inString
                                                         [i])].x,
                                                 PreviousResult->
                                                 chars[atoi (&inString[i])].
                                                 ch);
                                        continue;
                                        break;

                                }

                                }
                        }


                        }
                }
                sprintf (parsedString, "%s%c", parsedString, inString[i]);
        }

        outString = vapiReturnStringPointer (parsedString);

        return outString;
}

char *
vapiResultCheckMacroTag (vMacroResult * PreviousResult)
{
        if (PreviousResult->macroTag == NULL)
        {
                return v_printf ("0");
        }
        else
        {
                return v_printf ("%s", PreviousResult->macroTag);
        }
}

void
vapiResultSetCurrentMacroTag (vMacroResult * PreviousResult,
                              const char *previousMacroTag, int Operation)
{
        if (PreviousResult->macroTag != NULL)
        {
                free (PreviousResult->macroTag);
        }
        PreviousResult->macroTag = vapiMacroTag (previousMacroTag, Operation);
}

---