/*
* Copyright (c) 2017, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/

#include "cm_include.h"
#include "cm_printf_host.h"
#include "cm_debug.h"
#include "cm_mem.h"

void PFParser::getToken(void)
{
    m_prevToken = m_currToken;
    m_currToken = Token();

    // This is a lexer that has 2 modes
    // Inside a conversion specification and outside
    while (*m_currLoc != '\0')
    {
        if (!m_inSpec)
        {
            // We're just picking off characters until we see a %
            m_currToken.tokenType = Token::String;

            while (*m_currLoc != '\0')
            {
                if (*m_currLoc == '%')
                {
                    // Peek to check for %%
                    if (*(m_currLoc+1) != '\0' && *(m_currLoc+1) != '%')
                    {
                        // This is definitely a directive, not a %%
                        break;
                    }
                    // This IS %% so take another character off the input
                    m_currToken.tokenString += *m_currLoc++;
                }
                m_currToken.tokenString += *m_currLoc++;
            }

            if (*m_currLoc == '%')
                m_inSpec = true;

            if (m_currToken.tokenString.length() > 0)
                return;
        }

        if (m_inSpec)
        {
            char currChar = *m_currLoc++;
            switch(currChar)
            {
            default:
                // We've had an unexpected character
                m_currToken.tokenType = Token::Error;
                m_currToken.tokenString += currChar; // Preserve the error char
                m_inSpec = false; // End of the format spec
                return;
            case '%':
                m_currToken.tokenType = Token::Percent;
                return;
            case '-':
                m_currToken.tokenType = Token::Minus;
                return;
            case '+':
                m_currToken.tokenType = Token::Plus;
                return;
            case ' ':
                m_currToken.tokenType = Token::Space;
                return;
            case '.':
                m_currToken.tokenType = Token::Period;
                return;
            case '#':
                m_currToken.tokenType = Token::Hash;
                return;
            case '*':
                m_currToken.tokenType = Token::Star;
                return;
            case 'h':
                // Have to deal with 'hh'
                if (*m_currLoc == 'h')
                {
                    m_currLoc++;
                    m_currToken.tokenType = Token::hh_Mod;
                    return;
                }
                m_currToken.tokenType = Token::h_Mod;
                return;
            case 'l':
                // Have to deal with 'll'
                if (*m_currLoc == 'l')
                {
                    m_currLoc++;
                    m_currToken.tokenType = Token::ll_Mod;
                    return;
                }
                m_currToken.tokenType = Token::l_Mod;
                return;
            case 'j':
                m_currToken.tokenType = Token::j_Mod;
                return;
            case 'z':
                m_currToken.tokenType = Token::z_Mod;
                return;
            case 't':
                m_currToken.tokenType = Token::t_Mod;
                return;
            case 'L':
                m_currToken.tokenType = Token::L_Mod;
                return;
            case 'c':
                m_currToken.tokenType = Token::c_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 's':
                m_currToken.tokenType = Token::s_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'd':
                m_currToken.tokenType = Token::d_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'i':
                m_currToken.tokenType = Token::i_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'o':
                m_currToken.tokenType = Token::o_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'x':
                m_currToken.tokenType = Token::x_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'X':
                m_currToken.tokenType = Token::X_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'u':
                m_currToken.tokenType = Token::u_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'f':
                m_currToken.tokenType = Token::f_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'F':
                m_currToken.tokenType = Token::F_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'e':
                m_currToken.tokenType = Token::e_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'E':
                m_currToken.tokenType = Token::E_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'a':
                m_currToken.tokenType = Token::a_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'A':
                m_currToken.tokenType = Token::A_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'g':
                m_currToken.tokenType = Token::g_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'G':
                m_currToken.tokenType = Token::G_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'n':
                m_currToken.tokenType = Token::n_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case 'p':
                m_currToken.tokenType = Token::p_Conv;
                m_inSpec = false; // End of the format spec
                return;
            case '0':
                if (*m_currLoc < '1' || *m_currLoc > '9')
                {
                    // Next character not part of a larger integer
                    m_currToken.tokenType = Token::Zero;
                    return;
                }
                // Deliberately drop through
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                m_currToken.tokenString += currChar;
                while (*m_currLoc >= '0' && *m_currLoc <= '9')
                {
                    m_currToken.tokenString += *m_currLoc++;
                }
                // Create integer
                // Since we've created this integer string and we know it is simple we can use
                // atoi knowing that it won't throw an error
                m_currToken.tokenString = atoi(m_currToken.tokenString.c_str());
                m_currToken.tokenType = Token::Integer;
                return;
            }
        }
    }

    m_currToken.tokenType = Token::End;
}

bool PFParser::accept(PFParser::Token::TokenType s)
{
    if (m_currToken == s)
    {
        getToken();
        return true;
    }
    return false;
}

bool PFParser::expect(Token::TokenType s)
{
    if (accept(s))
        return true;
    error();
    return false;
}

int PFParser::format(void)
{
    if (m_currToken == Token::_None_)
    {
        getToken();
    }
    while(m_currToken != Token::End && m_currToken != Token::Error)
    {
        if (accept(Token::String))
        {
        }
        else if (accept(Token::Percent))
        {
            return directive();
        }
    }
    return 0;
}

int PFParser::directive(void)
{
    int numArgs = 0;
    flags();
    numArgs += width();
    numArgs += precision();
    length_modifier();

    int numConvArgs = conversion();
    if (numConvArgs == 0)
    {
        // Not expecting ANY arguments
        // Ignore any previous directives (width, precision etc.)
        numArgs = 0;
    }
    else
    {
        numArgs += numConvArgs;
    }

    return numArgs;
}

void PFParser::flags(void)
{
    if (accept(Token::Minus))
    {
    }

    if (accept(Token::Plus))
    {
    }

    if (accept(Token::Space))
    {
    }

    if (accept(Token::Zero))
    {
    }

    if (accept(Token::Hash))
    {
    }
}

int PFParser::width(void)
{
    if (accept(Token::Integer))
    {
        return 0;
    }
    else if (accept(Token::Star))
    {
        return 1;
    }
    return 0;
}

int PFParser::precision(void)
{
    if (accept(Token::Period))
    {
        if (accept(Token::Integer))
        {
            return 0;
        }
        else if (expect(Token::Star))
        {
            return 1;
        }
        return 0;
    }
    return 0;
}

void PFParser::length_modifier(void)
{
    if (accept(Token::hh_Mod))
    {
    }
    else if (accept(Token::h_Mod))
    {
    }
    else if (accept(Token::l_Mod))
    {
    }
    else if (accept(Token::ll_Mod))
    {
    }
    else if (accept(Token::j_Mod))
    {
        m_unsupported = true;
    }
    else if (accept(Token::t_Mod))
    {
        m_unsupported = true;
    }
    else if (accept(Token::z_Mod))
    {
        m_unsupported = true;
    }
    else if (accept(Token::L_Mod))
    {
    }
}

int PFParser::conversion(void)
{
    int numArgs = 1;
    if (accept(Token::Percent))
    {
        numArgs = 0;
    }
    else if (accept(Token::c_Conv))
    {
    }
    else if (accept(Token::s_Conv))
    {
    }
    else if (accept(Token::d_Conv))
    {
    }
    else if (accept(Token::i_Conv))
    {
    }
    else if (accept(Token::o_Conv))
    {
    }
    else if (accept(Token::x_Conv))
    {
    }
    else if (accept(Token::X_Conv))
    {
    }
    else if (accept(Token::u_Conv))
    {
    }
    else if (accept(Token::f_Conv))
    {
    }
    else if (accept(Token::F_Conv))
    {
    }
    else if (accept(Token::e_Conv))
    {
    }
    else if (accept(Token::E_Conv))
    {
    }
    else if (accept(Token::a_Conv))
    {
    }
    else if (accept(Token::A_Conv))
    {
    }
    else if (accept(Token::g_Conv))
    {
    }
    else if (accept(Token::G_Conv))
    {
    }
    else if (accept(Token::n_Conv))
    {
        m_unsupported = true;
    }
    else if (expect(Token::p_Conv))
    {
    }
    else
    {
        // Expect must have failed
        numArgs = 0;
    }
    return numArgs;
}

int CalcSizeFromHeader(unsigned char * memory)
{
    PCM_PRINT_HEADER header = (PCM_PRINT_HEADER)memory;

    if((header->objectType == CM_PRINT_OBJECT_TYPE_MATRIX) ||
       (header->objectType == CM_PRINT_OBJECT_TYPE_VECTOR))
    {
        switch (header->dataType)
        {
            case CM_PRINT_DATA_TYPE_CHAR:
                return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(char           ));

            case CM_PRINT_DATA_TYPE_UCHAR:
                return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(unsigned char  ));

            case CM_PRINT_DATA_TYPE_INT:
                return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(int            ));

            case CM_PRINT_DATA_TYPE_UINT:
                return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(unsigned int   ));

            case CM_PRINT_DATA_TYPE_FLOAT:
                return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(float          ));

            case CM_PRINT_DATA_TYPE_SHORT:
                return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(short          ));

            case CM_PRINT_DATA_TYPE_USHORT:
                return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(unsigned short ));

            case CM_PRINT_DATA_TYPE_QWORD:
                return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(long long      ));

            case CM_PRINT_DATA_TYPE_UQWORD:
                return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(unsigned long long ));

            case CM_PRINT_DATA_TYPE_DOUBLE:
                return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(double         ));

            default:
                CmAssert(0);
        }
        return PRINT_HEADER_SIZE;
    }
    else if(header->objectType == CM_PRINT_OBJECT_TYPE_STRING ||
            header->objectType == CM_PRINT_OBJECT_TYPE_FORMAT)
    {
        return PRINT_HEADER_SIZE + PRINT_FORMAT_STRING_SIZE;
    }
    else if(header->objectType == CM_PRINT_OBJECT_TYPE_SCALAR)
    {
        if(!((header->dataType == CM_PRINT_DATA_TYPE_CHAR)   ||
             (header->dataType == CM_PRINT_DATA_TYPE_UCHAR)  ||
             (header->dataType == CM_PRINT_DATA_TYPE_UINT)   ||
             (header->dataType == CM_PRINT_DATA_TYPE_INT)    ||
             (header->dataType == CM_PRINT_DATA_TYPE_USHORT) ||
             (header->dataType == CM_PRINT_DATA_TYPE_SHORT)  ||
             (header->dataType == CM_PRINT_DATA_TYPE_DOUBLE) ||
             (header->dataType == CM_PRINT_DATA_TYPE_QWORD)  ||
             (header->dataType == CM_PRINT_DATA_TYPE_UQWORD) ||
             (header->dataType == CM_PRINT_DATA_TYPE_FLOAT)))
        {
            CmAssert(0);
        }
        return PRINT_HEADER_SIZE;
    }
    else
    {
        CmAssert(0);
        return PRINT_HEADER_SIZE;
    }
}

void PFParser::Flush(void)
{
    if (m_inputStart && m_currLoc)
    {
        if (m_currToken != Token::End &&
            m_currToken != Token::_None_)
        {
            // Tidy up any remaining characters
            // Any characters that remain to be flushed need to be check for illegal directives (e.g. %n
            // will cause an exception if attempted to be printed with no argument)
            int numArgs = format();
            if (m_unsupported)
            {
                CM_PRINTF(m_streamOut,"Unsupported (but valid C++11) format string used : %s", m_inputStart);
                reset();
            }
            else if (m_error)
            {
                CM_PRINTF(m_streamOut,"Error in printf format string : %s", m_inputStart);
                reset();
            }
            else if (numArgs > 0)
            {
                // Not enough arguments provided for remaining directives
                CM_PRINTF(m_streamOut,"Not enough (no) arguments supplied for format string : %s", m_inputStart);
                reset();
            }
            else
            {
                CM_PRINTF(m_streamOut,"%s", m_inputStart);
            }
        }
        reset();
    }
}

PRINT_FMT_STATUS PFParser::GetNextFmtToken(char* tkn, size_t size)
{
    memset(tkn, 0, size);

    if (m_numMultArg)
    {
        if (!m_argsExpected)
        {
            // Copy the whole of the format string into the token
            if ((size_t)(m_currLoc - m_inputStart) <= size)
            {
                CmSafeMemCopy(tkn, m_inputStart, m_currLoc - m_inputStart);
                tkn[m_currLoc - m_inputStart] = '\0';
                return PF_SUCCESS;
            }
            return PF_FAIL;
        }
        // Still processing input arguments
        return PF_SUCCESS;
    }

    int numArgs = format();
    switch (numArgs)
    {
    default:
        return PF_FAIL; // Something has gone wrong
    case 0:
    case 1:
        // Copy the whole of the format string into the token
        if ((size_t)(m_currLoc - m_inputStart) <= size)
        {
            CmSafeMemCopy(tkn, m_inputStart, m_currLoc - m_inputStart);
            tkn[m_currLoc - m_inputStart] = '\0';
            return PF_SUCCESS;
        }
        return PF_FAIL;
    case 2:
    case 3:
        m_numMultArg = numArgs - 1;
        m_argsExpected = numArgs - 1;
        return PF_SUCCESS;
    }
}

bool PFParser::outputToken(const char *tkn, PCM_PRINT_HEADER header)
{
    if (m_numMultArg && m_argsExpected)
    {
        // Processing items for multi-arg directives
        if (header->objectType == CM_PRINT_OBJECT_TYPE_SCALAR &&
            header->dataType != CM_PRINT_DATA_TYPE_FLOAT &&
            header->dataType != CM_PRINT_DATA_TYPE_DOUBLE &&
            header->dataType != CM_PRINT_DATA_TYPE_QWORD &&
            header->dataType != CM_PRINT_DATA_TYPE_UQWORD)
        {
            // Received an int type argument as expected
            switch (header->dataType)
            {
                case CM_PRINT_DATA_TYPE_INT:
                    {
                        int* scalar_int = reinterpret_cast<int*>(&header->scalar64);
                        m_args[m_numMultArg - m_argsExpected] = *scalar_int;
                    }
                    break;
                case CM_PRINT_DATA_TYPE_UINT:
                    {
                        unsigned int* scalar_uint = reinterpret_cast<unsigned int*>(&header->scalar64);
                        m_args[m_numMultArg - m_argsExpected] = *scalar_uint;
                    }
                    break;
                case CM_PRINT_DATA_TYPE_CHAR:
                    m_args[m_numMultArg - m_argsExpected] = *((char*           )&(header->scalar64));
                    break;
                case CM_PRINT_DATA_TYPE_UCHAR:
                    m_args[m_numMultArg - m_argsExpected] = *((unsigned char*  )&(header->scalar64));
                    break;
                case CM_PRINT_DATA_TYPE_SHORT:
                    {
                        short* scalar_short = reinterpret_cast<short*>(&header->scalar64);
                        m_args[m_numMultArg - m_argsExpected] = *scalar_short;
                    }
                    break;
                case CM_PRINT_DATA_TYPE_USHORT:
                    {
                        unsigned short* scalar_ushort = reinterpret_cast<unsigned short*>(&header->scalar64);
                        m_args[m_numMultArg - m_argsExpected] = *scalar_ushort;
                    }
                    break;
            }
            m_argsExpected -= 1;
            return true;
        }
        else
        {
            // Not received the expected argument
            // Dump what is in the format string and attempt to recover as well as possible
            return false;
        }
    }

    // Inform the user that they've used an unsupported format string if that is the case
    // (e.g. %jd, %td etc.)
    if (m_unsupported)
    {
        CM_PRINTF(m_streamOut,"Unsupported (but valid C++11) printf format string : %s", tkn);
        reset();
        return true;
    }
    // Inform the user that they've got an error (illegal format string)
    if (m_error)
    {
        CM_PRINTF(m_streamOut, "Error in printf format string : %s", tkn);
        reset();
        return true;
    }

    // Output as appropriate
    if (!m_numMultArg)
    {
        switch (header->dataType)
        {
        case CM_PRINT_DATA_TYPE_INT:
            {
                int* scalar_int = reinterpret_cast<int*>(&header->scalar64);
                CM_PRINTF(m_streamOut, tkn, *scalar_int);
            }
            break;

        case CM_PRINT_DATA_TYPE_UINT:
            {
                unsigned int* scalar_uint = reinterpret_cast<unsigned int*>(&header->scalar64);
                CM_PRINTF(m_streamOut, tkn, *scalar_uint);
            }
            break;

        case CM_PRINT_DATA_TYPE_CHAR:
            CM_PRINTF(m_streamOut, tkn, *((char*)&(header->scalar64)));
            break;

        case CM_PRINT_DATA_TYPE_UCHAR:
            CM_PRINTF(m_streamOut, tkn, *((unsigned char*)&(header->scalar64)));
            break;

        case CM_PRINT_DATA_TYPE_FLOAT:
            {
                float* scalar_float = reinterpret_cast<float*>(&header->scalar64);
                CM_PRINTF(m_streamOut, tkn, *scalar_float);
            }
            break;

        case CM_PRINT_DATA_TYPE_SHORT:
            {
                short* scalar_short = reinterpret_cast<short*>(&header->scalar64);
                CM_PRINTF(m_streamOut, tkn, *scalar_short);
            }
            break;

        case CM_PRINT_DATA_TYPE_USHORT:
            {
                unsigned short* scalar_ushort = reinterpret_cast<unsigned short*>(&header->scalar64);
                CM_PRINTF(m_streamOut, tkn, *scalar_ushort);
            }
            break;

        case CM_PRINT_DATA_TYPE_DOUBLE:
            {
                double* scalar_double = reinterpret_cast<double*>(&header->scalar64);
                CM_PRINTF(m_streamOut, tkn, *scalar_double);
            }
            break;

        case CM_PRINT_DATA_TYPE_QWORD:
            CM_PRINTF(m_streamOut, tkn, *((long long*)&(header->scalar64)));
            break;

        case CM_PRINT_DATA_TYPE_UQWORD:
            CM_PRINTF(m_streamOut, tkn, *((unsigned long long*)&(header->scalar64)));
            break;
        }
    }
    else if (m_numMultArg == 1)
    {
        switch (header->dataType)
        {
        case CM_PRINT_DATA_TYPE_INT:
            {
                int* scalar_int = reinterpret_cast<int*>(&header->scalar64);
                CM_PRINTF(m_streamOut,tkn, m_args[0], *scalar_int);
            }
            break;

        case CM_PRINT_DATA_TYPE_UINT:
            {
                unsigned int* scalar_uint = reinterpret_cast<unsigned int*>(&header->scalar64);
                CM_PRINTF(m_streamOut,tkn, m_args[0], *scalar_uint);
            }
            break;

        case CM_PRINT_DATA_TYPE_CHAR:
            CM_PRINTF(m_streamOut,tkn, m_args[0], *((char*           )&(header->scalar64)));
            break;

        case CM_PRINT_DATA_TYPE_UCHAR:
            CM_PRINTF(m_streamOut,tkn, m_args[0], *((unsigned char*  )&(header->scalar64)));
            break;

        case CM_PRINT_DATA_TYPE_FLOAT:
            {
                float* scalar_float = reinterpret_cast<float*>(&header->scalar64);
                CM_PRINTF(m_streamOut,tkn, m_args[0], *scalar_float);
            }
            break;

        case CM_PRINT_DATA_TYPE_SHORT:
            {
                short* scalar_short = reinterpret_cast<short*>(&header->scalar64);
                CM_PRINTF(m_streamOut,tkn, m_args[0], *scalar_short);
            }
            break;

        case CM_PRINT_DATA_TYPE_USHORT:
            {
                unsigned short* scalar_ushort = reinterpret_cast<unsigned short*>(&header->scalar64);
                CM_PRINTF(m_streamOut,tkn, m_args[0], *scalar_ushort);
            }
            break;

        case CM_PRINT_DATA_TYPE_DOUBLE:
            {
                double* scalar_double = reinterpret_cast<double*>(&header->scalar64);
                CM_PRINTF(m_streamOut,tkn, m_args[0], *scalar_double);
            }
            break;

        case CM_PRINT_DATA_TYPE_QWORD:
            CM_PRINTF(m_streamOut,tkn, m_args[0], *((long long*          )&(header->scalar64)));
            break;

        case CM_PRINT_DATA_TYPE_UQWORD:
            CM_PRINTF(m_streamOut,tkn, m_args[0], *((unsigned long long* )&(header->scalar64)));
            break;
        }
    }
    else if (m_numMultArg == 2)
    {
        switch (header->dataType)
        {
        case CM_PRINT_DATA_TYPE_INT:
            {
                int* scalar_int = reinterpret_cast<int*>(&header->scalar64);
                CM_PRINTF(m_streamOut,tkn, m_args[0], m_args[1], *scalar_int);
            }
            break;

        case CM_PRINT_DATA_TYPE_UINT:
            {
                unsigned int* scalar_uint = reinterpret_cast<unsigned int*>(&header->scalar64);
                CM_PRINTF(m_streamOut,tkn, m_args[0], m_args[1], *scalar_uint);
            }
            break;

        case CM_PRINT_DATA_TYPE_CHAR:
            CM_PRINTF(m_streamOut,tkn, m_args[0], m_args[1], *((char*           )&(header->scalar64)));
            break;

        case CM_PRINT_DATA_TYPE_UCHAR:
            CM_PRINTF(m_streamOut,tkn, m_args[0], m_args[1], *((unsigned char*  )&(header->scalar64)));
            break;

        case CM_PRINT_DATA_TYPE_FLOAT:
            {
                float* scalar_float = reinterpret_cast<float*>(&header->scalar64);
                CM_PRINTF(m_streamOut,tkn, m_args[0], m_args[1], *scalar_float);
            }
            break;

        case CM_PRINT_DATA_TYPE_SHORT:
            {
                short* scalar_short = reinterpret_cast<short*>(&header->scalar64);
                CM_PRINTF(m_streamOut,tkn, m_args[0], m_args[1], *scalar_short);
            }
            break;

        case CM_PRINT_DATA_TYPE_USHORT:
            {
                unsigned short* scalar_ushort = reinterpret_cast<unsigned short*>(&header->scalar64);
                CM_PRINTF(m_streamOut,tkn, m_args[0], m_args[1], *scalar_ushort);
            }
            break;

        case CM_PRINT_DATA_TYPE_DOUBLE:
            {
                double* scalar_double = reinterpret_cast<double*>(&header->scalar64);
                CM_PRINTF(m_streamOut,tkn, m_args[0], m_args[1], *scalar_double);
            }
            break;

        case CM_PRINT_DATA_TYPE_QWORD:
            CM_PRINTF(m_streamOut,tkn, m_args[0], m_args[1], *((long long*          )&(header->scalar64)));
            break;

        case CM_PRINT_DATA_TYPE_UQWORD:
            CM_PRINTF(m_streamOut,tkn, m_args[0], m_args[1], *((unsigned long long* )&(header->scalar64)));
            break;
        }
    }

    reset();
    return true;
}
void PFParser::DumpMemory(unsigned char * memory)
{
    PCM_PRINT_HEADER header = (PCM_PRINT_HEADER)memory;
    memory += PRINT_HEADER_SIZE;
    int threadid = header->tid;

    if(!m_numMultArg && header->objectType == CM_PRINT_OBJECT_TYPE_MATRIX )
    {
        CM_PRINTF(m_streamOut,"\n Thread id %d, Matrix , Width %d, Height %d \n", threadid, header->width, header->height);
    }
    else if(!m_numMultArg && header->objectType == CM_PRINT_OBJECT_TYPE_VECTOR)
    {
        CM_PRINTF(m_streamOut, " \n Thread id %d, Vector , Width %d\n", threadid, header->width);
    }
    else if(!m_numMultArg && header->objectType == CM_PRINT_OBJECT_TYPE_FORMAT)
    {
        // Flush any remaining characters from existing format string (if any)
        Flush();
        SetStart((char *)memory);
    }
    else if(!m_numMultArg && header->objectType == CM_PRINT_OBJECT_TYPE_STRING)
    {
        char tkn[PRINT_FORMAT_STRING_SIZE];
        PRINT_FMT_STATUS status = GetNextFmtToken(tkn, PRINT_FORMAT_STRING_SIZE);
        if (status == PF_SUCCESS)
        {
            // Inform the user that they've used an unsupported format string if that is the case
            // (e.g. %jd, %td etc.)
            if (m_unsupported)
            {
                CM_PRINTF(m_streamOut, "Unsupported (but valid C++11) format string used : %s", tkn);
            }
            // Inform the user that they've got an error (illegal format string)
            if (m_error)
            {
                CM_PRINTF(m_streamOut, "Error in printf format string : %s", tkn);
            }

            if (m_unsupported || m_error)
            {
                reset();
                return;
            }

            CM_PRINTF(m_streamOut, tkn, (char*)memory);
            reset();
        }

        return;
    }
    else if(header->objectType == CM_PRINT_OBJECT_TYPE_SCALAR)
    {
        char tkn[PRINT_FORMAT_STRING_SIZE];
        PRINT_FMT_STATUS status = GetNextFmtToken(tkn, PRINT_FORMAT_STRING_SIZE);
        if (status == PF_SUCCESS)
        {
            if (!outputToken(tkn, header))
            {
                // Something has gone wrong
                // Reset multi-arg at least
                CM_PRINTF(m_streamOut, "Problem outputting with format string %s\n", tkn);
                m_numMultArg = m_argsExpected = 0;
            }
        }
        return;
    }
    else
    {
        if (m_numMultArg)
        {
            // Something has gone wrong in multi-arg so reset
            CM_PRINTF(m_streamOut, "Error in multi-arg directive\n");
            m_numMultArg = 0;
            m_argsExpected = 0;
        }
        else
        {
            CM_PRINTF(m_streamOut, "Unknown TYPE\n");
        }
        return;
    }
}

void DumpAllThreadOutput(FILE *streamOut, unsigned char * dumpMem, size_t buffersize)
{

    unsigned int offsetFromHeader =   0;
    unsigned int off              =   PRINT_BUFFER_HEADER_SIZE;
    PFParser     pState(streamOut);

    while(1)
    {
        if((off + PRINT_HEADER_SIZE) >= buffersize)
            break;

        if(off >= (*(unsigned int *)dumpMem))
            break;

        offsetFromHeader = CalcSizeFromHeader(dumpMem + off);
        if( (off + offsetFromHeader) >= buffersize )
            break;

        pState.DumpMemory(dumpMem + off);

        off += offsetFromHeader;
    }

    // Flush any remaining characters in the format buffer
    pState.Flush();

}