/*
 * This file is part of the Colobot: Gold Edition source code
 * Copyright (C) 2001-2018, Daniel Roux, EPSITEC SA & TerranovaTeam
 * http://epsitec.ch; http://colobot.info; http://github.com/colobot
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see http://gnu.org/licenses
 */

#include "CBot/CBotStack.h"

#include "CBot/CBotClass.h"

#include "CBot/CBotInstr/CBotFunction.h"

#include "CBot/CBotVar/CBotVarPointer.h"
#include "CBot/CBotVar/CBotVarClass.h"

#include "CBot/CBotUtils.h"
#include "CBot/CBotExternalCall.h"

#include <cassert>
#include <cstdlib>
#include <cstring>


namespace CBot
{

const int DEFAULT_TIMER = 100;

int         CBotStack::m_initimer = DEFAULT_TIMER;
int         CBotStack::m_timer = 0;
CBotVar*    CBotStack::m_retvar = nullptr;
CBotError   CBotStack::m_error = CBotNoErr;
int         CBotStack::m_start = 0;
int         CBotStack::m_end   = 0;
std::string  CBotStack::m_labelBreak="";
void*       CBotStack::m_pUser = nullptr;

////////////////////////////////////////////////////////////////////////////////
CBotStack* CBotStack::AllocateStack()
{
    CBotStack*    p;

    long    size = sizeof(CBotStack);
    size    *= (MAXSTACK+10);

    // request a slice of memory for the stack
    p = static_cast<CBotStack*>(malloc(size));

    // completely empty
    memset(p, 0, size);

    p->m_block = BlockVisibilityType::BLOCK;
    m_timer = m_initimer;                // sets the timer at the beginning

    CBotStack* pp = p;
    pp += MAXSTACK;
    int i;
    for ( i = 0 ; i< 10 ; i++ )
    {
        pp->m_bOver = true;
        pp ++;
    }

    m_error = CBotNoErr;    // avoids deadlocks because m_error is static
    return p;
}

////////////////////////////////////////////////////////////////////////////////
void CBotStack::Delete()
{
    if (m_next != nullptr) m_next->Delete();
    if (m_next2 != nullptr) m_next2->Delete();

    if (m_prev != nullptr)
    {
        if ( m_prev->m_next == this )
            m_prev->m_next = nullptr;        // removes chain

        if ( m_prev->m_next2 == this )
            m_prev->m_next2 = nullptr;        // removes chain
    }

    delete m_var;
    delete m_listVar;

    CBotStack*    p = m_prev;
    bool        bOver = m_bOver;

    // clears the freed block
    memset(this, 0, sizeof(CBotStack));
    m_bOver    = bOver;

    if ( p == nullptr )
        free( this );
}

// routine improved
////////////////////////////////////////////////////////////////////////////////
CBotStack* CBotStack::AddStack(CBotInstr* instr, BlockVisibilityType bBlock)
{
    if (m_next != nullptr)
    {
        return m_next;                // included in an existing stack
    }

    CBotStack*    p = this;
    do
    {
        p ++;
    }
    while ( p->m_prev != nullptr );

    m_next = p;                                    // chain an element
    p->m_block  = bBlock;
    p->m_instr  = instr;
    p->m_prog   = m_prog;
    p->m_step   = 0;
    p->m_prev   = this;
    p->m_state  = 0;
    p->m_call   = nullptr;
    p->m_func   = IsFunction::NO;
    p->m_callFinished = false;
    return p;
}

////////////////////////////////////////////////////////////////////////////////
CBotStack* CBotStack::AddStackExternalCall(CBotExternalCall* instr, BlockVisibilityType bBlock)
{
    assert(!m_callFinished);
    if (m_next != nullptr)
    {
        return m_next;                // included in an existing stack
    }
    CBotStack*    p = AddStack(nullptr, bBlock);
    p->m_call = instr;
    p->m_func = IsFunction::EXTERNAL_CALL;
    return    p;
}

////////////////////////////////////////////////////////////////////////////////
CBotStack* CBotStack::AddStack2(BlockVisibilityType bBlock)
{
    if (m_next2 != nullptr)
    {
        m_next2->m_prog = m_prog;        // special avoids RestoreStack2
        return m_next2;                    // included in an existing stack
    }

    CBotStack*    p = this;
    do
    {
        p ++;
    }
    while ( p->m_prev != nullptr );

    m_next2 = p;                                // chain an element
    p->m_prev = this;
    p->m_block = bBlock;
    p->m_prog = m_prog;
    p->m_step = 0;
    return    p;
}

////////////////////////////////////////////////////////////////////////////////
CBotStack::BlockVisibilityType CBotStack::GetBlock()
{
    return m_block;
}

////////////////////////////////////////////////////////////////////////////////
bool CBotStack::Return(CBotStack* pfils)
{
    if ( pfils == this ) return true;    // special

    if (m_var != nullptr) delete m_var;            // value replaced?
    m_var = pfils->m_var;                        // result transmitted
    pfils->m_var = nullptr;                        // not to destroy the variable

    if (m_next != nullptr)
    {
        // releases the stack above
        m_next->Delete();
        m_next = nullptr;
    }
    if (m_next2 != nullptr)
    {
        // also the second stack (catch)
        m_next2->Delete();
        m_next2 = nullptr;
    }

    return IsOk();                        // interrupted if error
}

////////////////////////////////////////////////////////////////////////////////
bool CBotStack::ReturnKeep(CBotStack* pfils)
{
    if ( pfils == this ) return true;    // special

    if (m_var != nullptr) delete m_var;            // value replaced?
    m_var = pfils->m_var;                        // result transmitted
    pfils->m_var = nullptr;                        // not to destroy the variable

    return IsOk();                        // interrupted if error
}

////////////////////////////////////////////////////////////////////////////////
bool CBotStack::StackOver()
{
    if (!m_bOver) return false;
    m_error = CBotErrStackOver;
    return true;
}

////////////////////////////////////////////////////////////////////////////////
void CBotStack::Reset()
{
    m_timer = m_initimer; // resets the timer
    m_error    = CBotNoErr;
//    m_start = 0;
//    m_end    = 0;
    m_labelBreak.clear();
}

////////////////////////////////////////////////////////////////////////////////
CBotStack* CBotStack::RestoreStack(CBotInstr* instr)
{
    if (m_next != nullptr)
    {
        m_next->m_instr = instr;    // reset (if recovery after )
        m_next->m_prog = m_prog;
        return m_next;                // included in an existing stack
    }
    return    nullptr;
}

////////////////////////////////////////////////////////////////////////////////
CBotStack* CBotStack::RestoreStackEOX(CBotExternalCall* instr)
{
    CBotStack*     p = RestoreStack();
    p->m_call = instr;
    return p;
}

////////////////////////////////////////////////////////////////////////////////
// routine for execution step by step
bool CBotStack::IfStep()
{
    if ( m_initimer > 0 || m_step++ > 0 ) return false;
    return true;
}

////////////////////////////////////////////////////////////////////////////////
bool CBotStack::BreakReturn(CBotStack* pfils, const std::string& name)
{
    if ( m_error>=0 ) return false;                // normal output
    if ( m_error==CBotError(-3) ) return false;            // normal output (return current)

    if (!m_labelBreak.empty() && (name.empty() || m_labelBreak != name))
        return false;                            // it's not for me

    m_error = CBotNoErr;
    m_labelBreak.clear();
    return Return(pfils);
}

////////////////////////////////////////////////////////////////////////////////
bool CBotStack::IfContinue(int state, const std::string& name)
{
    if ( m_error != CBotError(-2) ) return false;

    if (!m_labelBreak.empty() && (name.empty() || m_labelBreak != name))
        return false;                            // it's not for me

    m_state = state;                            // where again?
    m_error = CBotNoErr;
    m_labelBreak.clear();
    if (m_next != nullptr) m_next->Delete();            // purge above stack
    return true;
}

////////////////////////////////////////////////////////////////////////////////
void CBotStack::SetBreak(int val, const std::string& name)
{
    m_error = static_cast<CBotError>(-val);                                // reacts as an Exception
    m_labelBreak = name;
    if (val == 3)    // for a return
    {
        m_retvar = m_var;
        m_var = nullptr;
    }
}

// gives on the stack value calculated by the last CBotReturn
////////////////////////////////////////////////////////////////////////////////
bool CBotStack::GetRetVar(bool bRet)
{
    if (m_error == CBotError(-3))
    {
        if ( m_var ) delete m_var;
        m_var        = m_retvar;
        m_retvar    = nullptr;
        m_error      = CBotNoErr;
        return        true;
    }
    return bRet;                        // interrupted by something other than return
}

////////////////////////////////////////////////////////////////////////////////
CBotVar* CBotStack::FindVar(CBotToken*& pToken, bool bUpdate)
{
    CBotStack*    p = this;
    std::string    name = pToken->GetString();

    while (p != nullptr)
    {
        CBotVar*    pp = p->m_listVar;
        while ( pp != nullptr)
        {
            if (pp->GetName() == name)
            {
                if ( bUpdate )
                    pp->Update(m_pUser);

                return pp;
            }
            pp = pp->m_next;
        }
        p = p->m_prev;
    }
    return nullptr;
}

////////////////////////////////////////////////////////////////////////////////
CBotVar* CBotStack::FindVar(const std::string& name)
{
    CBotStack*    p = this;
    while (p != nullptr)
    {
        CBotVar*    pp = p->m_listVar;
        while ( pp != nullptr)
        {
            if (pp->GetName() == name)
            {
                return pp;
            }
            pp = pp->m_next;
        }
        p = p->m_prev;
    }
    return nullptr;
}

////////////////////////////////////////////////////////////////////////////////
CBotVar* CBotStack::FindVar(long ident, bool bUpdate)
{
    CBotStack*    p = this;
    while (p != nullptr)
    {
        CBotVar*    pp = p->m_listVar;
        while ( pp != nullptr)
        {
            if (pp->GetUniqNum() == ident)
            {
                if ( bUpdate )
                    pp->Update(m_pUser);

                return pp;
            }
            pp = pp->m_next;
        }
        p = p->m_prev;
    }
    return nullptr;
}

////////////////////////////////////////////////////////////////////////////////
CBotVar* CBotStack::FindVar(CBotToken& pToken, bool bUpdate)
{
    CBotToken*    pt = &pToken;
    return FindVar(pt, bUpdate);
}

////////////////////////////////////////////////////////////////////////////////
CBotVar* CBotStack::CopyVar(CBotToken& pToken, bool bUpdate)
{
    CBotVar*    pVar = FindVar(pToken, bUpdate);

    if ( pVar == nullptr) return nullptr;

    CBotVar*    pCopy = CBotVar::Create(pVar);
    pCopy->Copy(pVar);
    return    pCopy;
}

////////////////////////////////////////////////////////////////////////////////
bool CBotStack::SetState(int n, int limite)
{
    m_state = n;

    m_timer--;                                    // decrement the timer
    return ( m_timer > limite );                    // interrupted if timer pass
}

////////////////////////////////////////////////////////////////////////////////
bool CBotStack::IncState(int limite)
{
    m_state++;

    m_timer--;                                    // decrement the timer
    return ( m_timer > limite );                    // interrupted if timer pass
}

////////////////////////////////////////////////////////////////////////////////
void CBotStack::SetError(CBotError n, CBotToken* token)
{
    if (n != CBotNoErr && m_error != CBotNoErr) return;    // does not change existing error
    m_error = n;
    if (token != nullptr)
    {
        m_start = token->GetStart();
        m_end   = token->GetEnd();
    }
}

////////////////////////////////////////////////////////////////////////////////
void CBotStack::ResetError(CBotError n, int start, int end)
{
    m_error = n;
    m_start    = start;
    m_end    = end;
}

////////////////////////////////////////////////////////////////////////////////
void CBotStack::SetPosError(CBotToken* token)
{
    m_start = token->GetStart();
    m_end   = token->GetEnd();
}

////////////////////////////////////////////////////////////////////////////////
void CBotStack::SetTimer(int n)
{
    m_initimer = n;
}

int CBotStack::GetTimer()
{
    return m_initimer;
}

////////////////////////////////////////////////////////////////////////////////
bool CBotStack::Execute()
{
    CBotExternalCall*        instr = nullptr;                        // the most highest instruction
    CBotStack*        pile;

    CBotStack*        p = this;

    while (p != nullptr)
    {
        if ( p->m_next2 != nullptr ) break;
        if ( p->m_call != nullptr )
        {
            instr = p->m_call;
            pile  = p->m_prev ;
        }
        p = p->m_next;
    }

    if ( instr == nullptr ) return true;                // normal execution request

    if (!instr->Run(nullptr, pile)) return false;            // resume interrupted execution

    if (pile->m_next != nullptr) pile->m_next->Delete();

    pile->m_callFinished = true;
    return true;
}

// puts on the stack pointer to a variable
////////////////////////////////////////////////////////////////////////////////
void CBotStack::SetVar( CBotVar* var )
{
    if (m_var) delete m_var;    // replacement of a variable
    m_var = var;
}

// puts on the stack a copy of a variable
////////////////////////////////////////////////////////////////////////////////
void CBotStack::SetCopyVar( CBotVar* var )
{
    if (m_var) delete m_var;    // replacement of a variable

    m_var = CBotVar::Create("", var->GetTypResult(CBotVar::GetTypeMode::CLASS_AS_INTRINSIC));
    m_var->Copy( var );
}

////////////////////////////////////////////////////////////////////////////////
CBotVar* CBotStack::GetVar()
{
    return m_var;
}

////////////////////////////////////////////////////////////////////////////////
long CBotStack::GetVal()
{
    if (m_var == nullptr) return 0;
    return m_var->GetValInt();
}

////////////////////////////////////////////////////////////////////////////////
void CBotStack::AddVar(CBotVar* pVar)
{
    CBotStack*    p = this;

    // returns to the father element
    while (p != nullptr && p->m_block == BlockVisibilityType::INSTRUCTION) p = p->m_prev;

    if ( p == nullptr ) return;

    CBotVar**    pp = &p->m_listVar;
    while ( *pp != nullptr ) pp = &(*pp)->m_next;

    *pp = pVar;                    // added after
}

////////////////////////////////////////////////////////////////////////////////
void CBotStack::SetProgram(CBotProgram* p)
{
    m_prog = p;
    m_func = IsFunction::YES;
}

////////////////////////////////////////////////////////////////////////////////
CBotProgram*  CBotStack::GetProgram(bool bFirst)
{
    if ( ! bFirst )    return m_prog;
    CBotStack*    p = this;
    while ( p->m_prev != nullptr ) p = p->m_prev;
    return p->m_prog;
}

////////////////////////////////////////////////////////////////////////////////
void* CBotStack::GetUserPtr()
{
    return m_pUser;
}

void CBotStack::SetUserPtr(void* user)
{
    m_pUser = user;
}

////////////////////////////////////////////////////////////////////////////////
bool CBotStack::ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, const CBotTypResult& rettype)
{
    int res;

    // first looks by the identifier

    res = m_prog->GetExternalCalls()->DoCall(nullptr, nullptr, ppVar, this, rettype);
    if (res >= 0) return res;

    res = CBotFunction::DoCall(m_prog, m_prog->GetFunctions(), nIdent, "", ppVar, this, token);
    if (res >= 0) return res;

    // if not found (recompile?) seeks by name

    nIdent = 0;
    res = m_prog->GetExternalCalls()->DoCall(token, nullptr, ppVar, this, rettype);
    if (res >= 0) return res;

    res = CBotFunction::DoCall(m_prog, m_prog->GetFunctions(), nIdent, token->GetString(), ppVar, this, token);
    if (res >= 0) return res;

    SetError(CBotErrUndefFunc, token);
    return true;
}

////////////////////////////////////////////////////////////////////////////////
void CBotStack::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar)
{
    if (m_next == nullptr) return;

    if (m_prog->GetExternalCalls()->RestoreCall(token, nullptr, ppVar, this))
        return;

    CBotFunction::RestoreCall(m_prog->GetFunctions(), nIdent, token->GetString(), ppVar, this);
}

////////////////////////////////////////////////////////////////////////////////
void CBotStack::GetRunPos(std::string& functionName, int& start, int& end)
{
    CBotProgram*    prog = m_prog;                        // Current program

    CBotInstr*        funct = nullptr;                        // function found
    CBotInstr*        instr = nullptr;                        // the highest intruction

    CBotStack*        p = this;

    while (p->m_next != nullptr)
    {
        if ( p->m_instr != nullptr ) instr = p->m_instr;
        if (p->m_func == IsFunction::YES && p->m_instr != nullptr ) funct = p->m_instr;
        if ( p->m_next->m_prog != prog ) break ;

        if (p->m_next2 && p->m_next2->m_state != 0) p = p->m_next2 ;
        else                                        p = p->m_next;
    }

    if ( p->m_instr != nullptr ) instr = p->m_instr;
    if (p->m_func == IsFunction::YES && p->m_instr != nullptr ) funct = p->m_instr;

    if ( funct == nullptr ) return;

    CBotToken* t = funct->GetToken();
    functionName = t->GetString();

//    if ( p->m_instr != nullptr ) instr = p->m_instr;

    t = instr->GetToken();
    start = t->GetStart();
    end   = t->GetEnd();
}

////////////////////////////////////////////////////////////////////////////////
CBotVar* CBotStack::GetStackVars(std::string& functionName, int level)
{
    CBotProgram*    prog = m_prog;                        // current program
    functionName = "";

    // back the stack in the current module
    CBotStack*        p = this;

    while (p->m_next != nullptr)
    {
        if ( p->m_next->m_prog != prog ) break ;

        if (p->m_next2 && p->m_next2->m_state != 0) p = p->m_next2 ;
        else                                        p = p->m_next;
    }
    // Now p is the highest element on the stack


    // descends upon the elements of block
    while ( p != nullptr && p->m_block == BlockVisibilityType::INSTRUCTION) p = p->m_prev;
    // Now p is on the beggining of the top block (with local variables)

    while ( p != nullptr && level++ < 0 )
    {
        p = p->m_prev;
        while ( p != nullptr && p->m_block == BlockVisibilityType::INSTRUCTION) p = p->m_prev;
    }
    // Now p is on the block "level"

    if ( p == nullptr ) return nullptr;

    // search the name of the current function
    CBotStack* pp = p;
    while ( pp != nullptr )
    {
        if (pp->m_func == IsFunction::YES) break;
        pp = pp->m_prev;
    }

    if ( pp == nullptr || pp->m_instr == nullptr ) return nullptr;

    CBotToken* t = pp->m_instr->GetToken();
    functionName = t->GetString();

    return p->m_listVar;
}

////////////////////////////////////////////////////////////////////////////////
bool CBotStack::SaveState(std::ostream &ostr)
{
    if (m_next2 != nullptr)
    {
        if (!WriteWord(ostr, 2)) return false; // a marker of type (m_next2)
        if (!m_next2->SaveState(ostr)) return false; // saves the next element
    }
    else
    {
        if (!WriteWord(ostr, 1)) return false; // a marker of type (m_next)
    }
    if (!WriteWord(ostr, static_cast<unsigned short>(m_block))) return false;
    if (!WriteInt(ostr, m_state)) return false;
    if (!WriteWord(ostr, 0)) return false; // for backwards combatibility (m_bDontDelete)
    if (!WriteInt(ostr, m_step)) return false;

    if (!SaveVars(ostr, m_var)) return false;          // current result
    if (!SaveVars(ostr, m_listVar)) return false;      // local variables

    if (m_next != nullptr)
    {
        if (!m_next->SaveState(ostr)) return false; // saves the next element
    }
    else
    {
        if (!WriteWord(ostr, 0)) return false; // 0 - CBotStack::SaveState terminator
    }
    return true;
}

bool SaveVars(std::ostream &ostr, CBotVar* pVar)
{
    while (pVar != nullptr)
    {
        if (!pVar->Save0State(ostr)) return false; // common header
        if (!pVar->Save1State(ostr)) return false; // saves the data

        pVar = pVar->GetNext();
    }
    return WriteWord(ostr, 0); // 0 - CBot::SaveVars terminator
}

////////////////////////////////////////////////////////////////////////////////
bool CBotStack::RestoreState(std::istream &istr, CBotStack* &pStack)
{
    unsigned short w;

    if (pStack != this) pStack = nullptr;
    if (!ReadWord(istr, w)) return false;
    if ( w == 0 ) return true; // 0 - CBotStack::SaveState terminator

    if (pStack == nullptr) pStack = AddStack();

    if ( w == 2 ) // 2 - m_next2
    {
        if (!pStack->RestoreState(istr, pStack->m_next2)) return false;
    }

    if (!ReadWord(istr, w)) return false;
    pStack->m_block = static_cast<BlockVisibilityType>(w);

    int state;
    if (!ReadInt(istr, state)) return false;
    pStack->SetState(state);

    if (!ReadWord(istr, w)) return false; // backwards compatibility (m_bDontDelete)

    if (!ReadInt(istr, state)) return false;
    pStack->m_step = state;

    if (!CBotVar::RestoreState(istr, pStack->m_var)) return false;     // temp variable
    if (!CBotVar::RestoreState(istr, pStack->m_listVar)) return false; // local variables

    return pStack->RestoreState(istr, pStack->m_next);
}

////////////////////////////////////////////////////////////////////////////////
bool CBotVar::Save0State(std::ostream &ostr)
{
    if (!WriteWord(ostr, 100+static_cast<int>(m_mPrivate)))return false; // private variable?
    if (!WriteWord(ostr, m_bStatic))return false;            // static variable?
    if (!WriteWord(ostr, m_type.GetType()))return false;     // saves the type (always non-zero)

    if (m_type.Eq(CBotTypPointer) && GetPointer() != nullptr)
    {
        if (GetPointer()->m_bConstructor)                    // constructor was called?
        {
            if (!WriteWord(ostr, (2000 + static_cast<unsigned short>(m_binit)) )) return false;
            return WriteString(ostr, m_token->GetString());  // and variable name
        }
    }

    if (!WriteWord(ostr, static_cast<unsigned short>(m_binit))) return false;        // variable defined?
    return WriteString(ostr, m_token->GetString());          // and variable name
}

////////////////////////////////////////////////////////////////////////////////
bool CBotVar::RestoreState(std::istream &istr, CBotVar* &pVar)
{
    unsigned short        w, wi, prv, st;

    delete pVar;

                pVar    = nullptr;
    CBotVar*    pNew    = nullptr;
    CBotVar*    pPrev    = nullptr;

    while ( true )            // retrieves a list
    {
        if (!ReadWord(istr, w)) return false;                      // private or type?
        if ( w == 0 ) return true; // 0 - CBot::SaveVars terminator

        std::string defnum;
        if ( w == 200 )
        {
            if (!ReadString(istr, defnum)) return false;          // number with identifier
            if (!ReadWord(istr, w)) return false;                 // type
        }

        prv = 100; st = 0;
        if ( w >= 100 )
        {
            prv = w;
            if (!ReadWord(istr, st)) return false;              // static
            if (!ReadWord(istr, w)) return false;               // type
        }

        if ( w == CBotTypClass ) w = CBotTypIntrinsic;            // necessarily intrinsic

        if (!ReadWord(istr, wi)) return false;                  // init ?
        bool bConstructor = false;
        if (w == CBotTypPointer && wi >= 2000)
        {
            wi -= 2000;
            bConstructor = true;
        }

        CBotVar::InitType initType = static_cast<CBotVar::InitType>(wi);
        std::string varname;
        if (!ReadString(istr, varname)) return false;           // variable name
        CBotToken token(varname, std::string());

        bool isClass = false;

        switch (w)
        {
        case CBotTypBoolean:
            char valBool;
            if (!ReadByte(istr, valBool)) return false;
            pNew = CBotVar::Create(token, w);                        // creates a variable
            pNew->SetValInt(valBool);
            break;
        case CBotTypByte:
            char valByte;
            if (!ReadByte(istr, valByte)) return false;
            pNew = CBotVar::Create(token, w);                        // creates a variable
            pNew->SetValByte(valByte);
            break;
        case CBotTypShort:
            short valShort;
            if (!ReadShort(istr, valShort)) return false;
            pNew = CBotVar::Create(token, w);                        // creates a variable
            pNew->SetValShort(valShort);
            break;
        case CBotTypChar:
            uint32_t valChar;
            if (!ReadUInt32(istr, valChar)) return false;
            pNew = CBotVar::Create(token, w);                        // creates a variable
            pNew->SetValChar(valChar);
            break;
        case CBotTypInt:
            int valInt;
            if (!ReadInt(istr, valInt)) return false;
            pNew = CBotVar::Create(token, w);                        // creates a variable
            pNew->SetValInt(valInt, defnum);
            break;
        case CBotTypLong:
            long valLong;
            if (!ReadLong(istr, valLong)) return false;
            pNew = CBotVar::Create(token, w);                        // creates a variable
            pNew->SetValInt(valLong);
            break;
        case CBotTypFloat:
            float valFloat;
            if (!ReadFloat(istr, valFloat)) return false;
            pNew = CBotVar::Create(token, w);                        // creates a variable
            pNew->SetValFloat(valFloat);
            break;
        case CBotTypDouble:
            double valDouble;
            if (!ReadDouble(istr, valDouble)) return false;
            pNew = CBotVar::Create(token, w);                        // creates a variable
            pNew->SetValDouble(valDouble);
            break;
        case CBotTypString:
            {
                std::string valString;
                if (!ReadString(istr, valString)) return false;
                pNew = CBotVar::Create(token, w);                    // creates a variable
                pNew->SetValString(valString);
                break;
            }
        // returns an intrinsic object or element of an array
        case CBotTypIntrinsic:
            isClass = true;
        case CBotTypArrayBody:
            {
                CBotTypResult    r;
                long            id;
                if (!ReadType(istr, r)) return false;               // complete type
                if (!ReadLong(istr, id)) return false;

                {
                    CBotVar* p = nullptr;
                    if ( id ) p = CBotVarClass::Find(id) ;

                    pNew = new CBotVarClass(token, r);                // directly creates an instance
                                                                    // attention cptuse = 0
                    if (!RestoreState(istr, (static_cast<CBotVarClass*>(pNew))->m_pVar)) return false;
                    pNew->SetIdent(id);

                    if (isClass && p == nullptr) // set id for each item in this instance
                    {
                        CBotVar* pVars = pNew->GetItemList();
                        CBotVar* pv = pNew->GetClass()->GetVar();
                        while (pVars != nullptr && pv != nullptr)
                        {
                            pVars->m_ident = pv->m_ident;
                            pv = pv->GetNext();
                            pVars = pVars->GetNext();
                        }
                    }

                    if ( p != nullptr )
                    {
                        delete pNew;
                        pNew = p;            // resume known element
                    }
                }
            }
            break;

        case CBotTypPointer:
        case CBotTypNullPointer:
        {
            std::string className;
            if (!ReadString(istr, className)) return false; // name of the class
            {
//                CBotVarClass* p = nullptr;
                long id;
                if (!ReadLong(istr, id)) return false;
//                if ( id ) p = CBotVarClass::Find(id);        // found the instance (made by RestoreInstance)

                CBotTypResult ptrType(w, className);
                pNew = CBotVar::Create(token, ptrType);        // creates a variable
                // returns a copy of the original instance
                CBotVar* pInstance = nullptr;
                if (!CBotVar::RestoreState(istr, pInstance)) return false;
                (static_cast<CBotVarPointer*>(pNew))->SetPointer( pInstance );            // and point over

                if (bConstructor) pNew->ConstructorSet(); // constructor was called
                if (ptrType.Eq(CBotTypPointer)) pNew->SetType(ptrType); // keep pointer type

//                if ( p != nullptr ) (static_cast<CBotVarPointer*>(pNew))->SetPointer( p );    // rather this one

            }
            break;
        }
        case CBotTypArrayPointer:
            {
                CBotTypResult    r;
                if (!ReadType(istr, r)) return false;

                pNew = CBotVar::Create(token, r);                        // creates a variable

                // returns a copy of the original instance
                CBotVar* pInstance = nullptr;
                if (!CBotVar::RestoreState(istr, pInstance)) return false;
                (static_cast<CBotVarPointer*>(pNew))->SetPointer( pInstance );            // and point over
            }
            break;
        default:
            return false; // signal error
        }

        if ( pPrev != nullptr ) pPrev->m_next = pNew;
        if ( pVar == nullptr  ) pVar = pNew;

        pNew->m_binit = initType;        //        pNew->SetInit(wi);
        pNew->SetStatic(st);
        pNew->SetPrivate(static_cast<ProtectionLevel>(prv-100));
        pPrev = pNew;
    }
    return true;
}

bool CBotStack::IsCallFinished()
{
    return m_callFinished;
}

} // namespace CBot