static int makeQuotedToken(EcCompiler *cp, EcToken *tp, int c)
{
EcStream *stream;
int quoteType;
stream = cp->stream;
quoteType = c;
for (c = getNextChar(stream); c && c != quoteType; c = getNextChar(stream)) {
if (c == 0) {
return makeToken(tp, 0, T_ERR, 0);
}
if (c == '\\') {
c = getNextChar(stream);
switch (c) {
// TBD -- others
case '\\':
break;
case '\'':
case '\"':
break;
case 'b':
c = '\b';
break;
case 'f':
c = '\f';
break;
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'u':
c = decodeNumber(cp, 16, 4);
break;
case 'x':
c = decodeNumber(cp, 16, 2);
break;
case 'v':
c = '\v';
break;
case '0':
c = decodeNumber(cp, 8, 3);
break;
default:
break;
}
}
addCharToToken(tp, c);
}
assert(tp->text);
setTokenID(tp, T_STRING, -1, 0);
return finalizeToken(tp);
}
// TODO - handle triple quoting
static int getQuotedToken(EcInput *input, EcToken *tp, int c)
{
EcStream *stream;
int quoteType;
stream = input->stream;
quoteType = c;
for (c = getNextChar(stream); c && c != quoteType; c = getNextChar(stream)) {
if (c == 0) {
return makeToken(tp, 0, T_ERR, 0);
}
if (c == '\\') {
c = getNextChar(stream);
switch (c) {
// TBD -- others
case '\\':
break;
case '\'':
case '\"':
break;
case 'b':
c = '\b';
break;
case 'f':
c = '\f';
break;
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case 'u':
case 'x':
c = decodeNumber(input, 16, 4);
break;
case '0':
c = decodeNumber(input, 8, 3);
break;
default:
break;
}
}
addCharToToken(tp, c);
}
return finishToken(tp, T_STRING, -1, 0);
}
static int makeAlphaToken(EcCompiler *cp, EcToken *tp, int c)
{
ReservedWord *rp;
EcStream *stream;
/*
We know that c is an alpha already
*/
stream = cp->stream;
while (isalnum((uchar) c) || c == '_' || c == '$' || c == '\\') {
if (c == '\\') {
c = getNextChar(stream);
if (c == '\n' || c == '\r') {
break;
} else if (c == 'u') {
c = decodeNumber(cp, 16, 4);
// TODO - for now, mask back to 8 bits.
c = c & 0xff;
}
}
addCharToToken(tp, c);
c = getNextChar(stream);
}
if (c) {
putBackChar(stream, c);
}
rp = (ReservedWord*) mprLookupKey(cp->keywords, tp->text);
if (rp) {
setTokenID(tp, rp->tokenId, rp->subId, rp->groupMask);
} else {
setTokenID(tp, T_ID, -1, 0);
}
return finalizeToken(tp);
}
QPpsAttribute QPpsObjectPrivate::decodeData(pps_decoder_t *decoder)
{
pps_node_type_t nodeType = pps_decoder_type(decoder, 0);
switch (nodeType) {
case PPS_TYPE_BOOL:
return decodeBool(decoder);
case PPS_TYPE_NUMBER:
return decodeNumber(decoder);
case PPS_TYPE_STRING:
return decodeString(decoder);
case PPS_TYPE_ARRAY:
return decodeNestedData(&QPpsObjectPrivate::decodeArray, decoder);
case PPS_TYPE_OBJECT:
return decodeNestedData(&QPpsObjectPrivate::decodeObject, decoder);
case PPS_TYPE_DELETED: {
// This should create an attribute with the flags set to PpsAttribute::Deleted.
// However, we need to create a valid QPpsAttribute while doing so. To do this,
// I'll create an empty map as a sentinel. Note that the readFlags() call with produce
// the correct set of flags. While I suspect that there will never be any other flags
// set in conjunction with this one, I'd rather not be surprised later.
QPpsAttributeMap emptyMap;
QPpsAttribute::Flags flags = readFlags(decoder);
QPpsAttribute returnVal = QPpsAttributePrivate::createPpsAttribute(emptyMap, flags);
return returnVal;
}
case PPS_TYPE_NULL:
case PPS_TYPE_NONE:
case PPS_TYPE_UNKNOWN:
default:
qWarning() << "QPpsObjectPrivate::decodeData: invalid pps_node_type";
return QPpsAttribute();
}
}
ReturnCode decodeNumber(Number &number, IInput &input)
{
MSS_BEGIN(ReturnCode);
unsigned long v;
MSS(decodeNumber(v, input));
number = v;
MSS_END();
}
bool Reader::decodeNumber(Token& token) {
Value decoded;
if (!decodeNumber(token, decoded))
return false;
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return true;
}
bool Reader::readObject(Token& tokenStart) {
Token tokenName;
std::string name;
Value init(objectValue);
currentValue().swapPayload(init);
currentValue().setOffsetStart(tokenStart.start_ - begin_);
while (readToken(tokenName)) {
bool initialTokenOk = true;
while (tokenName.type_ == tokenComment && initialTokenOk)
initialTokenOk = readToken(tokenName);
if (!initialTokenOk)
break;
if (tokenName.type_ == tokenObjectEnd && name.empty()) // empty object
return true;
name = "";
if (tokenName.type_ == tokenString) {
if (!decodeString(tokenName, name))
return recoverFromError(tokenObjectEnd);
} else if (tokenName.type_ == tokenNumber && features_.allowNumericKeys_) {
Value numberName;
if (!decodeNumber(tokenName, numberName))
return recoverFromError(tokenObjectEnd);
name = numberName.asString();
} else {
break;
}
Token colon;
if (!readToken(colon) || colon.type_ != tokenMemberSeparator) {
return addErrorAndRecover(
"Missing ':' after object member name", colon, tokenObjectEnd);
}
Value& value = currentValue()[name];
nodes_.push(&value);
bool ok = readValue();
nodes_.pop();
if (!ok) // error already set
return recoverFromError(tokenObjectEnd);
Token comma;
if (!readToken(comma) ||
(comma.type_ != tokenObjectEnd && comma.type_ != tokenArraySeparator &&
comma.type_ != tokenComment)) {
return addErrorAndRecover(
"Missing ',' or '}' in object declaration", comma, tokenObjectEnd);
}
bool finalizeTokenOk = true;
while (comma.type_ == tokenComment && finalizeTokenOk)
finalizeTokenOk = readToken(comma);
if (comma.type_ == tokenObjectEnd)
return true;
}
return addErrorAndRecover(
"Missing '}' or object member name", tokenName, tokenObjectEnd);
}
/**
* Initialize the game state
*/
Common::ErrorCode MortevielleEngine::initialize() {
// Initialize graphics mode
initGraphics(SCREEN_WIDTH, SCREEN_HEIGHT, true);
// Set debug channels
DebugMan.addDebugChannel(kMortevielleCore, "core", "Core debugging");
DebugMan.addDebugChannel(kMortevielleGraphics, "graphics", "Graphics debugging");
// Set up an intermediate screen surface
_screenSurface.create(SCREEN_WIDTH, SCREEN_HEIGHT, Graphics::PixelFormat::createFormatCLUT8());
_txxFileFl = false;
// Load texts from TXX files
loadTexts();
// Load the mort.dat resource
Common::ErrorCode result = loadMortDat();
if (result != Common::kNoError) {
_screenSurface.free();
return result;
}
// Load some error messages (was previously in chartex())
_hintPctMessage = getString(580); // You should have noticed %d hints
// Set default EGA palette
_paletteManager.setDefaultPalette();
// Setup the mouse cursor
initMouse();
loadPalette();
loadCFIPH();
loadCFIEC();
decodeNumber(&_cfiecBuffer[161 * 16], (_cfiecBufferSize - (161 * 16)) / 64);
_x26KeyCount = 1;
initMaxAnswer();
initMouse();
loadPlaces();
_soundOff = false;
_largestClearScreen = false;
testKeyboard();
showConfigScreen();
testKeyboard();
clearScreen();
_soundManager.loadNoise();
_soundManager.loadAmbiantSounds();
return Common::kNoError;
}
bool
Reader::readValue()
{
Token token;
skipCommentTokens( token );
bool successful = true;
if ( collectComments_ && !commentsBefore_.empty() )
{
currentValue().setComment( commentsBefore_, commentBefore );
commentsBefore_ = "";
}
switch ( token.type_ )
{
case tokenObjectBegin:
successful = readObject( token );
break;
case tokenArrayBegin:
successful = readArray( token );
break;
case tokenNumber:
successful = decodeNumber( token );
break;
case tokenString:
successful = decodeString( token );
break;
case tokenTrue:
currentValue() = true;
break;
case tokenFalse:
currentValue() = false;
break;
case tokenNull:
currentValue() = Value();
break;
default:
return addError( "Syntax error: value, object or array expected.", token );
}
if ( collectComments_ )
{
lastValueEnd_ = current_;
lastValue_ = ¤tValue();
}
return successful;
}
/**
* Main game loop. Handles potentially playing the game multiple times, such as if the player
* loses, and chooses to start playing the game again.
*/
void MortevielleEngine::mainGame() {
if (_reloadCFIEC)
loadCFIEC();
for (_crep = 1; _crep <= _x26KeyCount; ++_crep)
decodeNumber(&_cfiecBuffer[161 * 16], (_cfiecBufferSize - (161 * 16)) / 64);
_menu->initMenu();
charToHour();
initGame();
clearScreen();
drawRightFrame();
_mouse->showMouse();
// Loop to play the game
do {
playGame();
if (shouldQuit())
return;
} while (!_quitGame);
}
bool
Reader::readValue ()
{
Token token;
do
readToken (token);
while (token.type_ == tokenComment);
bool successful = true;
switch (token.type_)
{
case tokenObjectBegin:
successful = readObject ();
break;
case tokenArrayBegin:
successful = readArray ();
break;
case tokenNumber:
successful = decodeNumber (token);
break;
case tokenString:
successful = decodeString (token);
break;
case tokenTrue:
currentValue () = true;
break;
case tokenFalse:
currentValue () = false;
break;
case tokenNull:
currentValue () = Value ();
break;
default:
return addError ("Syntax error: value, object or array expected.", token);
}
return successful;
}
static int getAlphaToken(EcInput *input, EcToken *tp, int c)
{
ReservedWord *rp;
EcStream *stream;
/*
* We know that c is an alpha already
*/
// TBD -- does ES4 allow $
stream = input->stream;
while (isalnum(c) || c == '_' || c == '$' || c == '\\') {
if (c == '\\') {
c = getNextChar(stream);
if (c == '\n' || c == '\r') {
break;
} else if (c == 'u') {
c = decodeNumber(input, 16, 4);
}
}
addCharToToken(tp, c);
c = getNextChar(stream);
}
if (c) {
putBackChar(stream, c);
}
// TODO - need to take into account contextually reserved and
// full reserved words.
rp = (ReservedWord*) mprLookupHash(input->lexer->keywords, (char*) tp->text);
if (rp) {
return finishToken(tp, rp->tokenId, rp->subId, rp->groupMask);
} else {
return finishToken(tp, T_ID, -1, 0);
}
}
bool Reader::readValue() {
Token token;
skipCommentTokens(token);
bool successful = true;
if (collectComments_ && !commentsBefore_.empty()) {
currentValue().setComment(commentsBefore_, commentBefore);
commentsBefore_ = "";
}
switch (token.type_) {
case tokenObjectBegin:
successful = readObject(token);
currentValue().setOffsetLimit(current_ - begin_);
break;
case tokenArrayBegin:
successful = readArray(token);
currentValue().setOffsetLimit(current_ - begin_);
break;
case tokenNumber:
successful = decodeNumber(token);
break;
case tokenString:
successful = decodeString(token);
break;
case tokenTrue:
{
Value v(true);
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
}
break;
case tokenFalse:
{
Value v(false);
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
}
break;
case tokenNull:
{
Value v;
currentValue().swapPayload(v);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
}
break;
case tokenArraySeparator:
if (features_.allowDroppedNullPlaceholders_) {
// "Un-read" the current token and mark the current value as a null
// token.
current_--;
Value v;
currentValue().swapPayload(v);
currentValue().setOffsetStart(current_ - begin_ - 1);
currentValue().setOffsetLimit(current_ - begin_);
break;
}
// Else, fall through...
default:
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return addError("Syntax error: value, object or array expected.", token);
}
if (collectComments_) {
lastValueEnd_ = current_;
lastValue_ = ¤tValue();
}
return successful;
}
bool Reader::readValue() {
Token token;
skipCommentTokens(token);
bool successful = true;
if (collectComments_ && !commentsBefore_.empty()) {
// Remove newline characters at the end of the comments
size_t lastNonNewline = commentsBefore_.find_last_not_of("\r\n");
if (lastNonNewline != std::string::npos) {
commentsBefore_.erase(lastNonNewline + 1);
} else {
commentsBefore_.clear();
}
currentValue().setComment(commentsBefore_, commentBefore);
commentsBefore_ = "";
}
switch (token.type_) {
case tokenObjectBegin:
successful = readObject(token);
currentValue().setOffsetLimit(current_ - begin_);
break;
case tokenArrayBegin:
successful = readArray(token);
currentValue().setOffsetLimit(current_ - begin_);
break;
case tokenNumber:
successful = decodeNumber(token);
break;
case tokenString:
successful = decodeString(token);
break;
case tokenTrue:
currentValue() = true;
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
break;
case tokenFalse:
currentValue() = false;
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
break;
case tokenNull:
currentValue() = Value();
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
break;
case tokenArraySeparator:
if (features_.allowDroppedNullPlaceholders_) {
// "Un-read" the current token and mark the current value as a null
// token.
current_--;
currentValue() = Value();
currentValue().setOffsetStart(current_ - begin_ - 1);
currentValue().setOffsetLimit(current_ - begin_);
break;
}
// Else, fall through...
default:
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
return addError("Syntax error: value, object or array expected.", token);
}
if (collectComments_) {
lastValueEnd_ = current_;
lastValue_ = ¤tValue();
}
return successful;
}
Limbs::Limbs(Encoding &g)
:genome(g)
{
//create Traits
Trait spindly(1, -3, 3, "spindly");
Trait thin(1, -2, 1, "thin");
Trait thick(-2, 3, 0, "thick");
Trait round(3, -1, -1, "round");
Trait zero(0, 0, 3, "0");
Trait one(1, 1, 3, "1");
Trait two(3, 1, -3, "2");
Trait three(-1, 1, 3, "3");
Trait four(3, 1, -3, "4");
Trait five(-1, 1, 3, "5");
Trait six(2, 1, -3, "6");
Trait seven(-2, 2, 3, "7");
Trait eight(0, 3, 2, "8");
Trait nine(-3, 2, 3, "9");
Trait ten(-2, 3, 2, "10");
Trait eleven(-3, 2, 3, "11");
Trait twelve(-3, 3, 2, "12");
Trait thirteen(-3, 2, 3, "13");
Trait fourteen(-3, 3, 3, "14");
Trait fifteen(-3, 2, 3, "15");
//create all maps
if (thicknessK.empty() ) {
thicknessK["spindly"] = 0;
thicknessK["thin"] = 1;
thicknessK["thick"] = 2;
thicknessK["round"] = 3;
thicknessM[0] = spindly;
thicknessM[1] = thin;
thicknessM[2] = thick;
thicknessM[3] = round;
numM[0] = zero;
numM[1] = one;
numM[2] = two;
numM[3] = three;
numM[4] = four;
numM[5] = five;
numM[6] = six;
numM[7] = seven;
numM[8] = eight;
numM[9] = nine;
numM[10] = ten;
numM[11] = eleven;
numM[12] = twelve;
numM[13] = thirteen;
numM[14] = fourteen;
numM[15] = fifteen;
}
//decode the number of limbs so that there can
//only be a non-zero even number of them
number = decodeNumber();
int numValue = std::stoi(number);
if (numValue % 2 != 0) {
encodeNumber(numValue + 1);
number = decodeNumber();
}
if (numValue == 0) {
encodeNumber(2);
number = decodeNumber();
}
thickness = decodeThickness();
}
//decode the limbs into readable strings
string Limbs::decodeLimbs() {
string answer = "has "+ decodeNumber()
+ " " + decodeThickness() + " limbs.";
return answer;
}
