CBotVarClass::CBotVarClass( const CBotToken* name, const CBotTypResult& type)
{
/*
// int nIdent = 0;
InitCBotVarClass( name, type ) //, nIdent );
}
CBotVarClass::CBotVarClass( const CBotToken* name, CBotTypResult& type) //, int &nIdent )
{
InitCBotVarClass( name, type ); //, nIdent );
}
void CBotVarClass::InitCBotVarClass( const CBotToken* name, CBotTypResult& type ) //, int &nIdent )
{*/
if ( !type.Eq(CBotTypClass) &&
!type.Eq(CBotTypIntrinsic) && // by convenience there accepts these types
!type.Eq(CBotTypPointer) &&
!type.Eq(CBotTypArrayPointer) &&
!type.Eq(CBotTypArrayBody)) ASM_TRAP();
m_token = new CBotToken(name);
m_next = NULL;
m_pMyThis = NULL;
m_pUserPtr = OBJECTCREATED;//NULL;
m_InitExpr = NULL;
m_LimExpr = NULL;
m_pVar = NULL;
m_type = type;
if ( type.Eq(CBotTypArrayPointer) ) m_type.SetType( CBotTypArrayBody );
else if ( !type.Eq(CBotTypArrayBody) ) m_type.SetType( CBotTypClass );
// officel type for this object
m_pClass = NULL;
m_pParent = NULL;
m_binit = false;
m_bStatic = false;
m_mPrivate = 0;
m_bConstructor = false;
m_CptUse = 0;
m_ItemIdent = type.Eq(CBotTypIntrinsic) ? 0 : CBotVar::NextUniqNum();
// se place tout seul dans la liste
// TODO stands alone in the list (stands only in a list)
if (m_ExClass) m_ExClass->m_ExPrev = this;
m_ExNext = m_ExClass;
m_ExPrev = NULL;
m_ExClass = this;
CBotClass* pClass = type.GetClass();
CBotClass* pClass2 = pClass->GetParent();
if ( pClass2 != NULL )
{
// also creates an instance of the parent class
m_pParent = new CBotVarClass(name, CBotTypResult(type.GetType(),pClass2) ); //, nIdent);
}
SetClass( pClass ); //, nIdent );
}
CBotVarArray::CBotVarArray(const CBotToken& name, CBotTypResult& type) : CBotVar(name)
{
if ( !type.Eq(CBotTypArrayPointer) &&
!type.Eq(CBotTypArrayBody)) assert(0);
m_next = nullptr;
m_pMyThis = nullptr;
m_pUserPtr = nullptr;
m_type = type;
m_type.SetType(CBotTypArrayPointer);
m_binit = CBotVar::InitType::UNDEF;
m_pInstance = nullptr; // the list of the array elements
}
bool CBotListArray::Execute(CBotStack* &pj, CBotVar* pVar)
{
CBotStack* pile1 = pj->AddStack();
CBotVar* pVar2;
CBotInstr* p = m_expr;
int n = 0;
for (; p != nullptr ; n++, p = p->GetNext3b())
{
if (pile1->GetState() > n) continue;
pVar2 = pVar->GetItem(n, true);
if (pVar2 == nullptr)
{
pj->SetError(CBotErrOutArray, p->GetToken());
return false;
}
CBotTypResult type = pVar2->GetTypResult();
if (!p->Execute(pile1, pVar2)) return false; // evaluate expression
if (type.Eq(CBotTypPointer)) pVar2->SetType(type); // keep pointer type
pile1->IncState();
}
return pj->Return(pile1);
}
// compiles a list of parameters
CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack)
{
// mainly not pStack->TokenStack here
// declared variables must remain visible thereafter
pStack->SetStartError(p->GetStart());
if (IsOfType(p, ID_OPENPAR))
{
CBotDefParam* list = NULL;
while (!IsOfType(p, ID_CLOSEPAR))
{
CBotDefParam* param = new CBotDefParam();
if (list == NULL) list = param;
else list->AddNext(param); // added to the list
// CBotClass* pClass = NULL;//= CBotClass::Find(p);
param->m_typename = p->GetString();
CBotTypResult type = param->m_type = TypeParam(p, pStack);
// if ( type == CBotTypPointer ) type = CBotTypClass; // we must create a new object
if (param->m_type.GetType() > 0)
{
CBotToken* pp = p;
param->m_token = *p;
if (pStack->IsOk() && IsOfType(p, TokenTypVar) )
{
// variable already declared?
if (pStack->CheckVarLocal(pp))
{
pStack->SetError(TX_REDEFVAR, pp);
break;
}
if ( type.Eq(CBotTypArrayPointer) ) type.SetType(CBotTypArrayBody);
CBotVar* var = CBotVar::Create(pp->GetString(), type); // creates the variable
// if ( pClass ) var->SetClass(pClass);
var->SetInit(2); // mark initialized
param->m_nIdent = CBotVar::NextUniqNum();
var->SetUniqNum(param->m_nIdent);
pStack->AddVar(var); // place on the stack
if (IsOfType(p, ID_COMMA) || p->GetType() == ID_CLOSEPAR)
continue;
}
pStack->SetError(TX_CLOSEPAR, p->GetStart());
}
pStack->SetError(TX_NOTYP, p);
delete list;
return NULL;
}
return list;
}
pStack->SetError(TX_OPENPAR, p->GetStart());
return NULL;
}
CBotVarPointer::CBotVarPointer(const CBotToken& name, CBotTypResult& type)
{
if ( !type.Eq(CBotTypPointer) &&
!type.Eq(CBotTypNullPointer) &&
!type.Eq(CBotTypClass) && // for convenience accepts Class and Intrinsic
!type.Eq(CBotTypIntrinsic) ) assert(0);
m_token = new CBotToken(name);
m_next = nullptr;
m_pMyThis = nullptr;
m_pUserPtr = nullptr;
m_type = type;
if ( !type.Eq(CBotTypNullPointer) )
m_type.SetType(CBotTypPointer); // anyway, this is a pointer
m_binit = CBotVar::InitType::UNDEF;
m_pClass = nullptr;
m_pVarClass = nullptr; // will be defined by a SetPointer()
SetClass(type.GetClass());
}
CBotTypResult CBotClass::CompileMethode(const char* name,
CBotVar* pThis, CBotVar** ppParams,
CBotCStack* pStack, long& nIdent)
{
nIdent = 0; // forget the previous one if necessary
// find the methods declared by AddFunction
CBotTypResult r = m_pCalls->CompileCall(name, pThis, ppParams, pStack, nIdent);
if ( r.GetType() >= 0) return r;
// find the methods declared by user
r = m_pMethod->CompileCall(name, ppParams, nIdent);
if ( r.Eq(TX_UNDEFCALL) && m_pParent != NULL )
return m_pParent->m_pMethod->CompileCall(name, ppParams, nIdent);
return r;
}
bool CBotClass::AddItem(CBotString name, CBotTypResult type, int mPrivate)
{
CBotToken token(name, CBotString());
CBotClass* pClass = type.GetClass();
CBotVar* pVar = CBotVar::Create( name, type );
/// pVar->SetUniqNum(CBotVar::NextUniqNum());
pVar->SetPrivate( mPrivate );
if ( pClass != NULL )
{
// pVar->SetClass(pClass);
if ( type.Eq(CBotTypClass) )
{
// adds a new statement for the object initialization
pVar->m_InitExpr = new CBotNew() ;
CBotToken nom( pClass->GetName() );
pVar->m_InitExpr->SetToken(&nom);
}
}
return AddItem( pVar );
}
CBotTypResult cSpace(CBotVar* &var, void* user)
{
CBotTypResult ret;
if ( var == 0 ) return CBotTypResult( CBotTypIntrinsic, "point" );
ret = cPoint(var, user);
if ( !ret.Eq(0) ) return ret;
if ( var == 0 ) return CBotTypIntrinsic;
if ( var->GivType() > CBotTypDouble ) return CBotTypResult( CBotErrBadNum );
var = var->GivNext();
if ( var == 0 ) return CBotTypIntrinsic;
if ( var->GivType() > CBotTypDouble ) return CBotTypResult( CBotErrBadNum );
var = var->GivNext();
if ( var == 0 ) return CBotTypIntrinsic;
if ( var->GivType() > CBotTypDouble ) return CBotTypResult( CBotErrBadNum );
var = var->GivNext();
if ( var != 0 ) return CBotErrOverParam;
return CBotTypResult( CBotTypIntrinsic, "point" );
}