// alle zum Erzeuger gehörenden Abfälle locken
int CAbfSet::LockReckord (BOOL bLock, CWnd *pWnd, const char *pNummer)
{
int iRes = LockFailed; // noch nichts getan
COleVariant varOldPos;
try
{
CMutex mt;
if (!m_bCanUpDate) // war durch anderen Nutzer
return NothingToLock; // gesperrt
if (m_RecordInfoList.IsEmpty ())
return Locked;
ASSERT (IsOpen ());
CWaitCursor wc;
// ak. Satz immer zuerst behandeln
iRes = CDaoRecordsetExt :: LockReckord (bLock, pWnd, pNummer);
if ((LockFailed == iRes) || // wenn Fehler beim Locken oder
(bLock && (NothingToLock == iRes))) // durch anderen Nutzer gesperrt
return iRes;
varOldPos = GetBookmark (); // alte Pos. speichern
CRecordInfo *pInfo = NULL;
// jetzt durch alle Sätze bewegen
POSITION pos = m_RecordInfoList.GetHeadPosition ();
while (NULL != pos)
{
pInfo = m_RecordInfoList.GetNext (pos);
ASSERT (NULL != pInfo);
if (pInfo -> m_varBookMark == varOldPos) // diesen Satz nicht noch mal
continue;
SetBookmark (pInfo -> m_varBookMark); // akt. Satz setzen
iRes = CDaoRecordsetExt :: LockReckord (bLock, NULL, pNummer);
if ((LockFailed == iRes) || // wenn Fehler beim Locken oder
(bLock && (NothingToLock == iRes))) // durch anderen Nutzer gesperrt
break;
}
}
catch (CDaoException *e)
{
:: DisplayDaoException (e);
e -> Delete ();
}
catch (CException *e)
{
e -> ReportError ();
e -> Delete ();
}
if (varOldPos.vt != VT_EMPTY)
SetBookmark (varOldPos); // wieder auf alte Position
return iRes;
}
// 1 oder alle Sätze der Liste löschen
// Sätze sind gelockt !
void CAbfSet::Delete()
{
ASSERT_VALID (this);
ASSERT (IsOpen ());
// wenn nur akt. Satz löschen
if (!m_bDeleteAll)
{
CDaoRecordset::Delete ();
return;
}
CString strOldNummer (m_Nummer);
CRecordInfo *pInfo = NULL;
POSITION pos = m_RecordInfoList.GetHeadPosition();
while (pos != NULL)
{
pInfo = (CRecordInfo *) m_RecordInfoList.GetNext(pos);
ASSERT (NULL != pInfo);
SetBookmark (pInfo -> m_varBookMark); // auf Satz positionieren
CDaoRecordset::Delete(); // Satz löschen
}
m_RecordInfoList.RemoveAll (); // Liste wird geleert
m_Nummer = strOldNummer; // für Seek notwendig
}
Type * ParseTypeInline()
/*
Syntax: "+" full_type | "(" full_type ")" | normal_type | identifier | int ".." exp | "-" int ".." exp
*/{
Type * type = NULL;
Var * var;
UInt16 bookmark;
BigInt * bi;
PARSE_INLINE = true;
if (TOK == TOKEN_OPEN_P || TOK == TOKEN_PLUS) {
type = ParseType2(INSTR_TYPE);
} else {
type = ParseType3();
if (!TOK) return NULL;
if (type != NULL) return type;
if (ParseArg(&var)) {
type = TypeAllocVar(var);
} else if (TOK == TOKEN_ID) {
bookmark = SetBookmark();
var = ParseVariable();
if (TOK) {
if (var->mode == INSTR_TYPE) {
type = var->type;
} else if (var->mode == INSTR_VAR && var->type->variant == TYPE_TYPE) {
type = var->type_value;
} else {
ErrArg(var);
SyntaxErrorBmk("Variable [A] does not define type.", bookmark);
}
}
} else if (TOK == TOKEN_INT || TOK == TOKEN_MINUS) {
type = TypeAlloc(TYPE_INT);
bi = ParseIntConstExpression(NULL);
if (TOK) {
IntModify(&type->range.min, bi);
if (NextIs(TOKEN_DOTDOT)) {
bi = ParseIntConstExpression(NULL);
if (TOK) {
IntModify(&type->range.max, bi);
}
} else {
IntModify(&type->range.max, &type->range.min);
}
}
}
}
return type;
}
void COXNotesEditView::OnLButtonDblClk(UINT nFlags, CPoint point)
{
CRect rct;
GetNotesRect(&rct);
if (rct.PtInRect(point))
{
int n=HIWORD(GetEditCtrl().CharFromPos(point));
int nChar=GetEditCtrl().LineIndex(n);
if (IsMarked(nChar))
RemoveBookmarks(nChar,nChar);
else
SetBookmark(nChar);
}
CEditView::OnLButtonDblClk(nFlags, point);
}
//
// Execute a block of commands
//
void Cineractive::ExecBlock(FScope *fScope)
{
FScope *sScope;
while ((sScope = fScope->NextFunction()) != NULL)
{
LOG_VIEWER(("Exec: [%s]", sScope->NameStr()))
switch (sScope->NameCrc())
{
case 0x9D71F205: // "Movie"
{
// Disable movies in multiplayer campaigns
if (!MultiPlayer::Data::Online())
{
if (moviePrim)
{
delete moviePrim;
}
moviePrim = new Movie(this, sScope);
}
break;
}
case 0x0DA67726: // "AlphaNear"
Vid::renderState.status.alphaNear = alphaNear = sScope->NextArgInteger();
break;
case 0x70600744: // "DisableIFace"
{
DisableIFace(sScope->NextArgInteger());
break;
}
case 0x72C1779F: // "DisableHUD"
{
DisableHUD(sScope->NextArgInteger());
break;
}
case 0x288F19CB: // "DisableInput"
{
DisableInput(sScope->NextArgInteger());
break;
}
case 0xAA268B85: // "DisableShroud"
{
DisableShroud(sScope->NextArgInteger());
break;
}
case 0x47518EE4: // "EndCineractive"
{
Terminate();
break;
}
case 0x7E8E3E05: // "SkipPoint"
{
RestoreDisplay();
break;
}
case 0xEA4227E1: // "SetBookmark"
{
SetBookmark(sScope);
break;
}
case 0xDDD6437A: // "DefaultCamera"
{
LOG_VIEWER(("DefaultCamera"))
if (Demo::IsPlaying())
{
SetCurrent("Playback0", StdLoad::TypeU32(sScope, U32(FALSE), Range<U32>::flag), sScope);
}
else
{
SetCurrent("default", StdLoad::TypeU32(sScope, U32(FALSE), Range<U32>::flag), sScope);
}
break;
}
case 0xF4356EC8: // "SetCamera"
{
SetCurrent(sScope->NextArgString(), FALSE, sScope);
break;
}
case 0x9805A0A6: // "Mesh"
{
AddPrim(primitiveList, new Mesh(this, sScope));
break;
}
case 0x16556EBC: // "Letterbox"
{
AddPrim(primitiveList, new Letterbox(this, sScope));
break;
}
case 0x10A95B64: // "Fade"
{
AddPrim(primitiveList, new Fade(this, sScope));
break;
}
case 0x76802A4E: // "Image"
{
AddPrim(primitiveList, new Image(this, sScope));
break;
}
case 0x64DD3931: // "Wallpaper"
{
AddPrim(primitiveList, new Wallpaper(this, sScope));
break;
}
case 0xCB28D32D: // "Text"
{
AddPrim(primitiveList, new Text(this, sScope));
break;
}
case 0x8E18DC65: // "Subtitle"
{
AddPrim(primitiveList, new Subtitle(this, sScope));
break;
}
case 0x37345010: // "Pause"
{
if (!GameTime::Paused())
{
GameTime::Pause(FALSE);
}
break;
}
case 0x0642D599: // "Unpause"
{
if (GameTime::Paused())
{
GameTime::Pause(FALSE);
}
break;
}
case 0x3F159CC9: // "DefineDebriefing"
{
debriefings.Add(Crc::CalcStr(sScope->NextArgString()), sScope);
break;
}
case 0x311D74EF: // "Debrief"
{
ProcessDebrief(sScope);
break;
}
case 0x06A3B1BA: // "Action"
{
// Execute an objective action block
::Action::Execute(team, sScope);
break;
}
default:
{
LOG_WARN(("Unknown function [%s] in Cineractive", sScope->NameStr()))
break;
}
}
}
}
BOOL CAbfSet::SearchNummer (const char *pNummer, BOOL bOutErrMsg /*=TRUE*/)
{
// wenn der Erzset noch leer ist ist alles getan
if (NULL == g_pErzSet)
return TRUE;
// JG den default Parameter handeln
if (NULL == pNummer)
pNummer = (g_pErzSet->m_Nummer);
ASSERT (pNummer != NULL && AfxIsValidString (pNummer));
BOOL bOk = FALSE; // noch nichts getan
try
{
// Satz bereits geladen ?
// das will ich ja gerade provozieren
// if (!*pNummer || (m_Nummer == pNummer))
// return TRUE;
CMutex mt;
CWaitCursor wc;
COutputLockError le (this);
// akt. Satz entriegeln und speichern
if (!LockReckord (FALSE))
return FALSE;
// akt. Pos. merken
COleVariant BookMark = GetBookmark ();
bOutErrMsg = false;
// neue Nummer suchen
if (MoveExt ("=", AFX_DAO_NEXT, pNummer))
{
bOk = TRUE;
}
else
{
if (bOutErrMsg)
{
CGakApp *pApp = (CGakApp *) AfxGetApp ();
ASSERT (pApp != NULL);
CString strInfo;
AfxFormatString1 (strInfo, IDS_ABF_NOT_FOUND, pNummer);
pApp -> OutputMessage (strInfo); // Nachricht an Nutzer ausgeben
}
SetBookmark (BookMark); // alten Satz einstell.
}
// akt. Satz sperren
return LockReckord();
}
catch (CException *e)
{
// e -> ReportError (); // bereits ausgegeben
e -> Delete ();
}
return bOk;
}
// überlagerte MoveNext-Funktion
// die Funktion geht davon aus, daß der Index "Nummer" gesetzt ist
BOOL CAbfSet::MoveExt (const char *pS, int iDir, const char *pErzNr /* = NULL */)
{
ASSERT_VALID (this);
ASSERT (IsOpen ());
ASSERT (NULL != pS && AfxIsValidString (pS));
ASSERT ((0 == strcmp (pS, ">")) || (0 == strcmp (pS, "<")) || (0 == strcmp (pS, "=")));
ASSERT ((AFX_DAO_NEXT == iDir) || (AFX_DAO_PREV == iDir) ||
(AFX_DAO_FIRST == iDir) || (AFX_DAO_LAST == iDir));
COleVariant varOldErz; // alter Erzeuger
BOOL bResOp = FALSE; // noch nichts getan
try
{
CMutex mt; // dieses Codestück thread sicher machen
CWaitCursor wc;
varOldErz = GetBookmark (); // Marke von altem Erzeuger
// zur nächsten Abfallgruppe
BOOL bFirstOp = FALSE;
switch (iDir)
{
case AFX_DAO_NEXT:
case AFX_DAO_PREV:
{
// JG einfach den synchronen DS finden
if (NULL == pErzNr && NULL != g_pErzSet)
pErzNr = (g_pErzSet->m_Nummer);
ASSERT ((NULL != pErzNr && *pErzNr) || !m_Nummer.IsEmpty ());
#pragma MSG("JG Clean up this")
// Das wäre die Version mit Abfrage
/* // m_strFilter strFilter;
m_strFilter = "[Nummer] = """;
m_strFilter +=
pErzNr && *pErzNr ? pErzNr : m_Nummer;
m_strFilter += """";
Requery();
*/
COleVariant VarNr (pErzNr && *pErzNr ? pErzNr : m_Nummer, VT_BSTRT);
bFirstOp = Seek (pS, &VarNr);
}
break;
case AFX_DAO_FIRST:
case AFX_DAO_LAST:
{
CDaoRecordset :: Move (iDir);
if (AFX_DAO_FIRST == iDir)
iDir = AFX_DAO_NEXT;
else
iDir = AFX_DAO_PREV;
bFirstOp = TRUE;
}
break;
default:
ASSERT (FALSE);
}
// 1. Satz gefunden ?
if (bFirstOp)
{
// Buchmarken sammeln
CRecordInfoList NewList; // neue Liste anlegen
CRecordInfo *pInfo = NULL; // Zeiger int.
CString strNummer (m_Nummer);
do
{
// Infos speichern
CRecordInfo *pInfo = new CRecordInfo (m_Abfallnummer, GetBookmark ());
NewList.AddTail (pInfo);
try
{
CDaoRecordset :: Move (iDir);
}
catch (CDaoException *e)
{
:: DisplayDaoException (e);
e -> Delete ();
break;
}
catch (CException *e)
{
e -> Delete ();
break;
}
}
while ((m_Nummer == strNummer) && !IsEOF () && !IsBOF ());
// ggf. Lockmeldung ausgeben
OutputLockErrorMessage ();
// jetzt auf 1. Erzeuger gehen
POSITION pos;
if (AFX_DAO_NEXT == iDir)
pInfo = NewList.GetHead ();
else
{
// letzter Satz soll 1. werden
pos = NewList.FindIndex (NewList.GetCount () - 1);
pInfo = NewList.GetAt (pos);
}
ASSERT (NULL != pInfo);
SetBookmark (pInfo -> m_varBookMark);
pInfo -> m_bFirst = TRUE;
// jetzt Liste umkopieren
m_RecordInfoList.RemoveAll (); // alte Liste zuvor löschen
pos = NewList.GetHeadPosition ();
while (NULL != pos)
m_RecordInfoList.AddTail (NewList.GetNext (pos));
NewList.CPtrList::RemoveAll ();
bResOp = TRUE;
// JG
#pragma MSG("m_bValid accessing function")
// m_bValid = TRUE;
// alles OK
} // Seek failed
else
{
// hier wird zu dem alten Satz gegangen
SetBookmark (varOldErz); // es wurde kein weiterer Erzeuger gefunden
}
}
catch (CException *e)
{
if (e -> IsKindOf (RUNTIME_CLASS(CDaoException)))
::DisplayDaoException ((CDaoException*) e);
else
e -> ReportError ();
if (varOldErz.vt != VT_EMPTY)
SetBookmark (varOldErz);
throw; // Exception weiterleiten
}
return bResOp; // Operationflag setzen
}
Type * ParseIntType()
{
Type * type = TUNDEFINED;
Var * var;
Bookmark bookmark;
UInt8 arg_no = 0;
BigInt * bi;
// When parsing rule, type may be preceded by %name:
if (ParsingPattern()) {
arg_no = ParseArgNo();
if (arg_no > 0) {
if (TOK == TOKEN_COLON) {
NextToken();
} else {
SyntaxError("Argument name must be followed by :");
}
}
}
bookmark = SetBookmark();
ExpectExpression(NULL);
if (TOK) {
var = BufPop();
// If we parsed rule argument
if (var->mode == INSTR_ELEMENT || VarIsRuleArg(var)) {
type = TypeAllocVar(var);
goto done;
// Integer type may be defined using predefined type definition or be defined as type of other variable
} else if (var->mode == INSTR_TYPE || var->mode == INSTR_VAR) {
type = var->type;
if (type->variant == TYPE_TYPE) {
type = var->type_value;
SetFlagOn(var->submode, SUBMODE_USED_AS_TYPE);
}
if (type->variant != TYPE_INT) {
SyntaxErrorBmk("Expected integer type", bookmark);
}
goto done;
} else if (var->mode == INSTR_INT) {
type = TypeAllocConst(&var->n);
} else {
//TODO: If simple integer variable, use it as type range
SyntaxErrorBmk("expected type or constant expression", bookmark);
}
if (TOK == TOKEN_DOTDOT) {
NextToken();
bookmark = SetBookmark();
ExpectExpression(NULL);
if (TOK) {
var = BufPop();
bi = VarIntConst(var);
if (bi != NULL) {
IntModify(&type->range.max, bi);
} else {
SyntaxErrorBmk("expected constant expression", bookmark);
}
}
} else {
type->range.max = type->range.min;
type->range.min = 0;
}
if (type->range.min > type->range.max) {
SyntaxErrorBmk("range minimum bigger than maximum", bookmark);
}
}
done:
if (TOK) {
if (arg_no != 0) {
type = TypeAllocArg(arg_no, type);
}
}
/*
if (TOK == TOKEN_INT) {
type = TypeAlloc(TYPE_INT);
type->range.min = LEX.n;
NextToken();
if (TOK == TOKEN_DOTDOT) {
NextToken();
if (TOK == TOKEN_INT) {
type->range.max = LEX.n;
NextToken();
}
} else {
type->range.max = type->range.min;
type->range.min = 0;
}
if (type->range.min > type->range.max) {
SyntaxError("range minimum bigger than maximum");
}
// Sme variable
} else if (TOK == TOKEN_ID) {
var = VarFind2(NAME);
if (var != NULL) {
if (var->mode == INSTR_INT) {
if (var->type->variant == TYPE_INT) {
type = TypeAlloc(TYPE_INT);
type->range.min = 0;
type->range.max = var->n;
} else {
SyntaxError("Expected integer constant");
}
} else {
type = var->type;
}
NextToken();
} else {
SyntaxError("$unknown variable");
}
} else {
SyntaxError("Expected definition of integer type");
}
*/
return type;
}
/*
Type * ParseIntRange(Type * type)
{
Var * min, * max;
Bookmark bookmark;
bookmark = SetBookmark();
ParseExpressionType(TypeType(NULL));
if (TOK && TOP != 0) {
min = BufPop();
max = NULL;
if (NextIs(TOKEN_DOTDOT)) {
ExpectExpression(NULL);
if (TOK) {
max = BufPop();
type = TypeDerive(type);
}
}
if (VarIsIntConst(min) && VarIsIntConst(max)) {
type = TypeAllocRange(min, max);
if (type->range.min > type->range.max) {
SyntaxErrorBmk("range minimum bigger than maximum", bookmark);
}
} else {
SyntaxErrorBmk("expected type constant expression", bookmark);
}
}
return type;
}
*/
Type * ParseType2(InstrOp mode)
/*
Purpose:
Parse: <int> [".." <int>] | <var> | proc <VarList>
Input:
mode Type of variable for which we parse.
*/
{
Var * var;
Type * type = NULL, * variant_type = NULL;
Var * min, * max;
Bookmark bookmark;
next:
type = ParseType3();
if (!TOK) return NULL;
if (type == NULL) {
bookmark = SetBookmark();
ParseExpressionType(TypeType(NULL));
if (TOK && TOP != 0) {
min = BufPop();
max = NULL;
if (NextIs(TOKEN_DOTDOT)) {
ExpectExpression(NULL);
if (TOK) {
max = BufPop();
}
}
type = NULL;
if (max == NULL) {
var = min;
if (var->mode == INSTR_TYPE) {
type = var->type;
} else if (var->mode == INSTR_VAR && var->type->variant == TYPE_TYPE) {
type = var->type_value;
SetFlagOn(var->submode, SUBMODE_USED_AS_TYPE);
}
// This is directly type
if (type != NULL) {
// For integer type, constants may be defined
if (type->variant == TYPE_INT) {
// type = ParseIntRange(type);
goto const_list;
}
goto done;
}
max = var;
}
if (VarIsIntConst(min) && VarIsIntConst(max)) {
type = TypeAllocRange(min, max);
if (type->range.min > type->range.max) {
SyntaxErrorBmk("range minimum bigger than maximum", bookmark);
}
} else {
SyntaxErrorBmk("expected type constant expression", bookmark);
}
} else if (TOK == TOKEN_STRING) {
type = TypeAlloc(TYPE_VAR);
type->typevar = VarNewStr(NAME);
NextToken();
}
}
const_list:
// Parse type specific constants
// There can be list of constants specified in block.
// First thing in the block must be an identifier, so we try to open the block with this in mind.
// We try to parse constants only for integer types (in future, we may try other numberic or string types)
if (type != NULL && type->variant == TYPE_INT && !type->is_enum) {
if (TOK != TOKEN_OR) {
type = ParseConstList(type);
}
}
done:
if (TOK) {
if (variant_type != NULL) {
variant_type->right = type;
type = variant_type;
}
if (NextIs(TOKEN_OR)) {
variant_type = TypeAlloc(TYPE_VARIANT);
variant_type->left = type;
goto next;
}
}
return type;
}
