Initial commit
This commit is contained in:
233
engines/private/symbol.cpp
Normal file
233
engines/private/symbol.cpp
Normal file
@@ -0,0 +1,233 @@
|
||||
/* ScummVM - Graphic Adventure Engine
|
||||
*
|
||||
* ScummVM is the legal property of its developers, whose names
|
||||
* are too numerous to list here. Please refer to the COPYRIGHT
|
||||
* file distributed with this source distribution.
|
||||
*
|
||||
* 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://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
// Heavily inspired by hoc
|
||||
// Copyright (C) AT&T 1995
|
||||
// All Rights Reserved
|
||||
//
|
||||
// Permission to use, copy, modify, and distribute this software and
|
||||
// its documentation for any purpose and without fee is hereby
|
||||
// granted, provided that the above copyright notice appear in all
|
||||
// copies and that both that the copyright notice and this
|
||||
// permission notice and warranty disclaimer appear in supporting
|
||||
// documentation, and that the name of AT&T or any of its entities
|
||||
// not be used in advertising or publicity pertaining to
|
||||
// distribution of the software without specific, written prior
|
||||
// permission.
|
||||
//
|
||||
// AT&T DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
// INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
|
||||
// IN NO EVENT SHALL AT&T OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
|
||||
// SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
// IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
// ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
|
||||
// THIS SOFTWARE.
|
||||
|
||||
#include "common/str.h"
|
||||
#include "private/grammar.h"
|
||||
#include "private/private.h"
|
||||
#include "private/tokens.h"
|
||||
|
||||
namespace Private {
|
||||
|
||||
SymbolMaps::~SymbolMaps() {
|
||||
freeSymbolMap(settings);
|
||||
freeSymbolMap(variables);
|
||||
freeSymbolMap(cursors);
|
||||
freeSymbolMap(locations);
|
||||
freeSymbolMap(rects);
|
||||
freeSymbolList(constants);
|
||||
freeSymbolList(names);
|
||||
freeStringMap(strings);
|
||||
}
|
||||
|
||||
void SymbolMaps::defineSymbol(const char *n, Common::Rect *r) {
|
||||
Common::String s(n);
|
||||
stringToDefine.push(s);
|
||||
rectToDefine.push(r);
|
||||
}
|
||||
|
||||
/*
|
||||
static void showSymbol(const Symbol *s) {
|
||||
if (s->type == NUM)
|
||||
debugC(1, kPrivateDebugCode, "%s %d",s->name->c_str(), s->u.val);
|
||||
else if (s->type == STRING)
|
||||
debugC(1, kPrivateDebugCode, "%s %s", s->name->c_str(), s->u.str);
|
||||
else if (s->type == NAME)
|
||||
debugC(1, kPrivateDebugCode, "%s %d",s->name->c_str(), s->type);
|
||||
else
|
||||
debugC(1, kPrivateDebugCode, "%s %d", s->name->c_str(), s->type);
|
||||
}
|
||||
*/
|
||||
|
||||
void setSymbol(Symbol *s, int v) {
|
||||
s->u.val = v;
|
||||
}
|
||||
|
||||
/* find s in symbol table symlist */
|
||||
static Symbol *lookup(const Common::String &s, const SymbolMap &symlist) {
|
||||
Symbol *r = symlist.getVal(s);
|
||||
return r;
|
||||
}
|
||||
|
||||
/* install some symbol s in a symbol table */
|
||||
static Symbol *install(const Common::String &n, int t, int d, const char *s, Common::Rect *r, SymbolMap *symlist) {
|
||||
Symbol *sp;
|
||||
sp = (Symbol *)malloc(sizeof(Symbol));
|
||||
sp->name = new Common::String(n);
|
||||
sp->type = t;
|
||||
if (t == NUM) {
|
||||
sp->u.val = d;
|
||||
//debug("install NUM: %s %d", name->c_str(), d);
|
||||
} else if (t == NAME) {
|
||||
sp->u.val = d;
|
||||
//debug("installing NAME: %s %d", name->c_str(), d);
|
||||
} else if (t == STRING)
|
||||
sp->u.str = scumm_strdup(s);
|
||||
else if (t == RECT)
|
||||
sp->u.rect = r;
|
||||
else
|
||||
assert(0);
|
||||
|
||||
symlist->setVal(n, sp);
|
||||
assert(symlist->size() > 0);
|
||||
return sp;
|
||||
}
|
||||
|
||||
void SymbolMaps::freeSymbolMap(SymbolMap &symbols) {
|
||||
for (SymbolMap::iterator it = symbols.begin(); it != symbols.end(); ++it) {
|
||||
Symbol *s = it->_value;
|
||||
delete s->name;
|
||||
if (s->type == STRING) {
|
||||
free(s->u.str);
|
||||
} else if (s->type == RECT) {
|
||||
delete s->u.rect;
|
||||
}
|
||||
free(s);
|
||||
}
|
||||
}
|
||||
|
||||
/* lookup some name in some symbol table */
|
||||
Symbol *SymbolMaps::lookupRect(Common::String *n) {
|
||||
assert(rects.contains(*n));
|
||||
return lookup(*n, rects);
|
||||
}
|
||||
|
||||
Symbol *SymbolMaps::lookupVariable(Common::String *n) {
|
||||
assert(variables.contains(*n));
|
||||
return lookup(*n, variables);
|
||||
}
|
||||
|
||||
Symbol *SymbolMaps::lookupLocation(Common::String *n) {
|
||||
assert(locations.contains(*n));
|
||||
return lookup(*n, locations);
|
||||
}
|
||||
|
||||
Symbol *SymbolMaps::lookupName(const char *n) {
|
||||
Symbol *s = (Symbol *)malloc(sizeof(Symbol));
|
||||
Common::String *name = new Common::String(n);
|
||||
s->name = name;
|
||||
s->type = NAME;
|
||||
s->u.val = 0;
|
||||
|
||||
names.push_back(s);
|
||||
return s;
|
||||
}
|
||||
|
||||
void SymbolMaps::installAll(const char *n) {
|
||||
assert(stringToDefine.size() > 0);
|
||||
|
||||
while (!stringToDefine.empty()) {
|
||||
Common::String s = stringToDefine.pop();
|
||||
Common::Rect *r = rectToDefine.pop();
|
||||
|
||||
//debug("name %s", s.c_str());
|
||||
if (strcmp(n, "settings") == 0) {
|
||||
//debug("new setting %s", n);
|
||||
assert(r == nullptr);
|
||||
install(s, NAME, 0, s.c_str(), r, &settings);
|
||||
} else if (strcmp(n, "variables") == 0) {
|
||||
assert(r == nullptr);
|
||||
install(s, NAME, 0, nullptr, r, &variables);
|
||||
variableList.push_front(s);
|
||||
} else if (strcmp(n, "cursors") == 0) {
|
||||
assert(r == nullptr);
|
||||
install(s, NAME, 0, nullptr, r, &cursors);
|
||||
} else if (strcmp(n, "locations") == 0) {
|
||||
assert(r == nullptr);
|
||||
install(s, NAME, 0, nullptr, r, &locations);
|
||||
locationList.push_front(s);
|
||||
} else if (strcmp(n, "rects") == 0) {
|
||||
assert(r != nullptr);
|
||||
install(s, RECT, 0, nullptr, r, &rects);
|
||||
} else
|
||||
error("invalid symbol type");
|
||||
}
|
||||
}
|
||||
|
||||
Symbol *SymbolMaps::constant(int t, int d, const char *s) {
|
||||
Symbol *sp;
|
||||
Common::String *n = new Common::String("<constant>");
|
||||
|
||||
sp = (Symbol *)malloc(sizeof(Symbol));
|
||||
sp->name = n;
|
||||
sp->type = t;
|
||||
if (t == NUM || t == NAME)
|
||||
sp->u.val = d;
|
||||
else if (t == STRING)
|
||||
sp->u.str = scumm_strdup(s);
|
||||
else
|
||||
assert(0);
|
||||
|
||||
constants.push_front(sp);
|
||||
return sp;
|
||||
}
|
||||
|
||||
void SymbolMaps::freeSymbolList(SymbolList &symbols) {
|
||||
for (SymbolList::iterator it = symbols.begin(); it != symbols.end(); ++it) {
|
||||
Symbol *s = (*it);
|
||||
delete s->name;
|
||||
if (s->type == STRING) {
|
||||
free(s->u.str);
|
||||
}
|
||||
free(s);
|
||||
}
|
||||
}
|
||||
|
||||
char *SymbolMaps::string(const char *in) {
|
||||
Common::String str(in);
|
||||
char *out;
|
||||
if (!strings.tryGetVal(in, out)) {
|
||||
out = scumm_strdup(in);
|
||||
strings[str] = out;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
void SymbolMaps::freeStringMap(StringMap &strings) {
|
||||
for (StringMap::iterator it = strings.begin(); it != strings.end(); ++it) {
|
||||
char *s = it->_value;
|
||||
free(s);
|
||||
}
|
||||
}
|
||||
|
||||
} // End of namespace Private
|
||||
Reference in New Issue
Block a user