int FWScript::o2_removeGfxElementType21() {
uint16 a = getNextWord();
uint16 b = getNextWord();
debugC(5, kCineDebugScript, "Line: %d: o2_removeGfxElementType21(%d,%d)", _line, a, b);
removeGfxElement(a, b, 21);
return 0;
}
int FWScript::o2_removeGfxElementType20() {
uint16 idx = getNextWord();
uint16 param = getNextWord();
debugC(5, kCineDebugScript, "Line: %d: o2_removeGfxElementType20(%d,%d)", _line, idx, param);
removeGfxElement(idx, param, 20);
return 0;
}
/*************************************************************************
Return the number of lines the given text would be formatted to.
*************************************************************************/
size_t Font::getFormattedLineCount(const String& text, const Rect& format_area, TextFormatting fmt, float x_scale)
{
// handle simple non-wrapped cases.
if ((fmt == LeftAligned) || (fmt == Centred) || (fmt == RightAligned) || (fmt == Justified))
{
return std::count(text.begin(), text.end(), static_cast<utf8>('\n')) + 1;
}
// handle wraping cases
size_t lineStart = 0, lineEnd = 0;
String sourceLine;
float wrap_width = format_area.getWidth();
String whitespace = TextUtils::DefaultWhitespace;
String thisLine, thisWord;
size_t line_count = 0, currpos = 0;
while (lineEnd < text.length())
{
if ((lineEnd = text.find_first_of('\n', lineStart)) == String::npos)
{
lineEnd = text.length();
}
sourceLine = text.substr(lineStart, lineEnd - lineStart);
lineStart = lineEnd + 1;
// get first word.
currpos = getNextWord(sourceLine, 0, thisLine);
// while there are words left in the string...
while (String::npos != sourceLine.find_first_not_of(whitespace, currpos))
{
// get next word of the string...
currpos += getNextWord(sourceLine, currpos, thisWord);
// if the new word would make the string too long
if ((getTextExtent(thisLine, x_scale) + getTextExtent(thisWord, x_scale)) > wrap_width)
{
// too long, so that's another line of text
line_count++;
// remove whitespace from next word - it will form start of next line
thisWord = thisWord.substr(thisWord.find_first_not_of(whitespace));
// reset for a new line.
thisLine.clear();
}
// add the next word to the line
thisLine += thisWord;
}
// plus one for final line
line_count++;
}
return line_count;
}
int FWScript::o2_addGfxElementType20() {
uint16 param1 = getNextWord();
uint16 param2 = getNextWord();
debugC(5, kCineDebugScript, "Line: %d: o2_addGfxElementType20(%d,%d)", _line, param1, param2);
addGfxElement(param1, param2, 20);
return 0;
}
/**
* @todo Implement this instruction
* @note According to the scripts' opcode usage comparison this opcode isn't used at all.
*/
int FWScript::o2_op9C() {
uint16 a = getNextWord();
uint16 b = getNextWord();
uint16 c = getNextWord();
uint16 d = getNextWord();
warning("STUB: o2_op9C(%x, %x, %x, %x)", a, b, c, d);
return 0;
}
static ssize_t dbgcfgtool_write(struct file *fp, const char __user *buf,
size_t count, loff_t *pos)
{
char* buf_idx;
char szCommand[TEMP_BUF_SIZE * 3];
char szMaskName[TEMP_BUF_SIZE];
int mask;
if(count > (DBGCFG_COMMAND_BUFFER_SIZE - 1))
{
return -EFAULT;
}
write_buf = kmalloc(DBGCFG_COMMAND_BUFFER_SIZE, GFP_KERNEL);
if(write_buf)
{
memset(write_buf, 0, DBGCFG_COMMAND_BUFFER_SIZE);
}
else
{
return 0;
}
if(copy_from_user(write_buf, buf, count))
{
return -EFAULT;
}
write_buf[count] = '\0';
//printk(KERN_INFO "dbgcfgtool_write: write_buf=%s=\n", write_buf);
buf_idx = write_buf;
getNextWord(&buf_idx, szCommand, 30);
if(!strncmp(szCommand, "HANG_LINUX", DBGCFG_COMMAND_BUFFER_SIZE))
{
printk(KERN_INFO "dbgcfgtool_write: hang linux\n");
panic("dbgcfgtool");
}
else if(!strncmp(szCommand, "DALVIK_HEAP_DUMP", DBGCFG_COMMAND_BUFFER_SIZE))
{
getNextWord(&buf_idx, szMaskName, TEMP_BUF_SIZE); //this is pid value.
printk(KERN_INFO "dbgcfgtool_write: %s %s\n", szCommand, szMaskName);
mask = (int)simple_strtol(szMaskName, NULL, TEMP_BUF_SIZE);
printk(KERN_INFO "dbgcfgtool_write: pid=%d sig=%d\n", mask, SIGUSR1);
kill_proc_info(SIGUSR1, SEND_SIG_PRIV, mask);
}
*pos += count;
if(write_buf)
{
kfree(write_buf);
write_buf = NULL;
}
return count;
}
void AGOSEngine_Feeble::off_isAdjNoun() {
// 165: item unk1 unk2 is
Item *item = getNextItemPtr();
int16 a = getNextWord(), b = getNextWord();
if (item->adjective == a && item->noun == b)
setScriptCondition(true);
else if (a == -1 && item->noun == b)
setScriptCondition(true);
else
setScriptCondition(false);
}
int FWScript::o2_modifySeqListElement() {
byte a = getNextByte();
byte b = getNextByte();
uint16 c = getNextWord();
uint16 d = getNextWord();
byte e = getNextByte();
debugC(5, kCineDebugScript, "Line: %d: o2_modifySeqListElement(%d,%d,%d,%d,%d)", _line, a, b, c, d, e);
modifySeqListElement(a, 0, b, c, d, e);
return 0;
}
void AGOSEngine::o_setAdjNoun() {
// 130: set adj noun
uint var = getVarOrByte();
if (var == 1) {
_scriptAdj1 = getNextWord();
_scriptNoun1 = getNextWord();
} else {
_scriptAdj2 = getNextWord();
_scriptNoun2 = getNextWord();
}
}
int FWScript::o2_addSeqListElement() {
byte param1 = getNextByte();
byte param2 = getNextByte();
byte param3 = getNextByte();
byte param4 = getNextByte();
uint16 param5 = getNextWord();
uint16 param6 = getNextWord();
uint16 param7 = getNextWord();
debugC(5, kCineDebugScript, "Line: %d: addSeqListElement(%d,%d,%d,%d,%d,%d,%d)", _line, param1, param2, param3, param4, param5, param6, param7);
addSeqListElement(param1, 0, param2, param3, param4, param5, param6, 0, param7);
return 0;
}
int FWScript::o2_playSample() {
if (g_cine->getPlatform() == Common::kPlatformAmiga || g_cine->getPlatform() == Common::kPlatformAtariST) {
// no-op in these versions
getNextByte();
getNextByte();
getNextWord();
getNextByte();
getNextWord();
getNextWord();
return 0;
}
return o1_playSample();
}
string
WKTReader::getNextEmptyOrOpener(StringTokenizer *tokenizer)
{
string nextWord=getNextWord(tokenizer);
// Skip the Z, M or ZM of an SF1.2 3/4 dim coordinate.
if (nextWord == "Z" || nextWord == "M" || nextWord == "ZM" )
nextWord = getNextWord(tokenizer);
if (nextWord=="EMPTY" || nextWord=="(") {
return nextWord;
}
throw ParseException("Expected 'Z', 'M', 'ZM', 'EMPTY' or '(' but encountered ",nextWord);
}
std::string wordcountmap(std::string inputFile, int64_t startOffset, int64_t endOffset)
{
std::ifstream inFile;
inFile.open(inputFile.c_str(), std::fstream::in);
inFile.seekg (startOffset, inFile.beg); //read all till < endOffset
std::string token;
std::stringstream ss;
uint64_t count =0;
while(inFile.tellg() < endOffset){
getNextWord(inFile,token," ",endOffset); //tokenizer
if(token.size() == 0) continue;
count++;
}
inFile.close();
ss.clear();
ss<<PATH<<getpid()<<fileAppend();
std::string pidstr(ss.str());
std::ofstream outFile;
outFile.open(pidstr.c_str(), std::fstream::out);
outFile<<"count "<<count<<std::endl;
outFile.close();
return ss.str();
}
void AGOSEngine_Elvira2::oe2_isAdjNoun() {
// 179: item unk1 unk2 is
Item *item = getNextItemPtr();
int16 a = getNextWord();
int16 n = getNextWord();
if (getGameType() == GType_ELVIRA2 && item == NULL) {
// WORKAROUND bug #1745996: A NULL item can occur when
// interacting with items in the dinning room
setScriptCondition(false);
return;
}
assert(item);
setScriptCondition(item->adjective == a && item->noun == n);
}
void AGOSEngine_Simon1::os1_screenTextMsg() {
// 162: print string
uint vgaSpriteId = getVarOrByte();
uint color = getVarOrByte();
uint stringId = getNextStringID();
const byte *stringPtr = NULL;
uint speechId = 0;
TextLocation *tl;
if (stringId != 0xFFFF)
stringPtr = getStringPtrByID(stringId);
if (getFeatures() & GF_TALKIE) {
if (getGameType() == GType_FF || getGameType() == GType_PP)
speechId = (uint16)getVarOrWord();
else
speechId = (uint16)getNextWord();
}
if (getGameType() == GType_FF || getGameType() == GType_PP)
vgaSpriteId = 1;
tl = getTextLocation(vgaSpriteId);
if (_speech && speechId != 0)
playSpeech(speechId, vgaSpriteId);
if (((getGameType() == GType_SIMON2 && (getFeatures() & GF_TALKIE)) || getGameType() == GType_FF) &&
speechId == 0) {
stopAnimateSimon2(2, vgaSpriteId + 2);
}
if (stringPtr != NULL && stringPtr[0] != 0 && (speechId == 0 || _subtitles))
printScreenText(vgaSpriteId, color, (const char *)stringPtr, tl->x, tl->y, tl->width);
}
/**
* @brief Extract a global flag implementing a delta function
*
* This function extracts the condition, the sign of the flag and the resets
*/
void xppParser::extractGlobal(void) {
auto line = lines.begin();
while (line != lines.end()) {
std::size_t pos1 = line->first.find("global");
std::size_t pos2 = line->first.find(" ", pos1);
if (pos1 != std::string::npos) {
opts opt(line->second);
/* Parse the sign flag. For simplicity store it in the name slot */
opt.Name = getNextWord(*line, pos1, pos2);
/* Parse flip condition. */
pos1 = line->first.find_first_not_of(" ", pos2);
pos2 = line->first.find("{", pos1);
opt.Expr = line->first.substr(pos1, pos2-pos1-1);
/* The individual resets are separated by a semicolon */
opt.Args = getList(line->first.substr(pos2), opt.Line, "}", ";");
Globals.push_back(opt);
lines.erase(line);
} else {
++line;
}
}
}
void TextRenderer::renderToBox(string text,float width, float height){
int maxChars=width/renderWidth;
int maxLines=height/renderHeight;
int cnt=0;
int begin=0;
int x=0;
int lx=0;
while(x<text.length()){
lx=x;
x=getNextWord(text,x,maxChars);
if(x-begin>maxChars){
renderString(text.substr(begin,lx-begin),-cnt*renderHeight);
cnt++;
if(cnt>maxLines)
break;
begin=lx+1;
}
renderString(text.substr(begin,x-begin),-cnt*renderHeight);
}
}
/**
* @brief Extract a markov process from the parsed lines
*
* This function extracts the definition of markov processes as they constitute
* one of the few multiline statements in an ode file.
*/
void xppParser::extractMarkov(void) {
auto line = lines.begin();
while (line != lines.end()) {
std::size_t pos1 = line->first.find("markov");
std::size_t pos2 = line->first.find(" ", pos1);
if (pos1 != std::string::npos) {
opts opt(line->second);
opt.Name = getNextWord(*line, pos1, pos2);
checkName(opt.Name, *line, pos1);
/* Parse the number of states */
int nstates;
try {
nstates = std::stoi(getNextWord(*line, pos1, pos2));
} catch (std::invalid_argument) {
throw xppParserException(EXPECTED_NUMBER, *line, pos1);
}
opt.Expr = nstates;
/* Parse the transition probabilities */
opt.Args.reserve(nstates*nstates);
for (int i=0; i < nstates; i++) {
auto line2 = std::next(line);
pos2 = 0;
for (int j=0; j < nstates; j++) {
pos1 = line2->first.find("{", pos2);
pos2 = line2->first.find("}", pos1);
if (pos1 == std::string::npos) {
throw xppParserException(MISSING_MARKOV_ASSIGNMENT,
*line2, pos2);
}
opt.Args.push_back(line2->first.substr(pos1+1, pos2-pos1-1));
}
if (pos2 != line2->first.size()-1) {
throw xppParserException(WRONG_MARKOV_ASSIGNMENT,
*line2, line2->first.size());
}
lines.erase(line2);
}
Markovs.push_back(opt);
lines.erase(line);
} else {
++line;
}
}
}
/*************************************************************************
draws wrapped text
*************************************************************************/
size_t Font::drawWrappedText(const String& text, const Rect& draw_area, float z, const Rect& clip_rect, TextFormatting fmt, const ColourRect& colours, float x_scale, float y_scale)
{
size_t line_count = 0;
Rect dest_area(draw_area);
float wrap_width = draw_area.getWidth();
String whitespace = TextUtils::DefaultWhitespace;
String thisLine, thisWord;
size_t currpos = 0;
// get first word.
currpos += getNextWord(text, currpos, thisLine);
// while there are words left in the string...
while (String::npos != text.find_first_not_of(whitespace, currpos))
{
// get next word of the string...
currpos += getNextWord(text, currpos, thisWord);
// if the new word would make the string too long
if ((getTextExtent(thisLine, x_scale) + getTextExtent(thisWord, x_scale)) > wrap_width)
{
// output what we had until this new word
line_count += drawText(thisLine, dest_area, z, clip_rect, fmt, colours, x_scale, y_scale);
// remove whitespace from next word - it will form start of next line
thisWord = thisWord.substr(thisWord.find_first_not_of(whitespace));
// reset for a new line.
thisLine.clear();
// update y co-ordinate for next line
dest_area.d_top += getLineSpacing(y_scale);
}
// add the next word to the line
thisLine += thisWord;
}
// Last line is left aligned
TextFormatting last_fmt = (fmt == Justified ? LeftAligned : fmt);
// output last bit of string
line_count += drawText(thisLine, dest_area, z, clip_rect, last_fmt, colours, x_scale, y_scale);
return line_count;
}
void AGOSEngine_PuzzlePack::opp_iconifyWindow() {
// 30
getNextWord();
if (_clockStopped != 0)
_gameTime += getTime() - _clockStopped;
_clockStopped = 0;
_system->setFeatureState(OSystem::kFeatureIconifyWindow, true);
}
/**
* @brief Parser::attachWords Attachs the words to the leaves of the tree
* @param S the tree
*/
void Parser::attachWords(SyntaxTree& S){
TNpair::TNvector L = S.getLeaves();
for(std::size_t i = 0; i < L.size(); ++i){
Word W = getNextWord(i);
removeAllOtherTypes(W,GPtoWT[L[i]->data()._d.first]);
L[i]->data()._d.second.setWord(W);
}
}
string
WKTReader::getNextCloser(StringTokenizer *tokenizer)
{
string nextWord=getNextWord(tokenizer);
if (nextWord==")") {
return nextWord;
}
throw ParseException("Expected ')' but encountered",nextWord);
}
string
WKTReader::getNextEmptyOrOpener(StringTokenizer *tokenizer)
{
string nextWord=getNextWord(tokenizer);
if (nextWord=="EMPTY" || nextWord=="(") {
return nextWord;
}
throw ParseException("Expected 'EMPTY' or '(' but encountered ",nextWord);
}
int getNextInt(char **buf)
{char word[50];
int i;
getNextWord(buf,word);
i=(uint32)strtoul(word,0,10); // nao .. entao le o valor corrente
return i;
}
/**
* @todo Implement this instruction
* @note According to the scripts' opcode usage comparison this opcode isn't used at all.
*/
int FWScript::o2_op9B() {
uint16 a = getNextWord();
uint16 b = getNextWord();
uint16 c = getNextWord();
uint16 d = getNextWord();
uint16 e = getNextWord();
uint16 f = getNextWord();
uint16 g = getNextWord();
uint16 h = getNextWord();
warning("STUB: o2_op9B(%x, %x, %x, %x, %x, %x, %x, %x)", a, b, c, d, e, f, g, h);
return 0;
}
char * getNextStr(char **buf)
{char word[100];
char *str;
getNextWord(buf,word);
str=mymalloc(strlen(word)+1);
strcpy(str,word);
return str;
}
/*************************************************************************
returns extent of widest line of wrapped text.
*************************************************************************/
float Font::getWrappedTextExtent(const String& text, float wrapWidth, float x_scale)
{
String whitespace = TextUtils::DefaultWhitespace;
String thisWord;
size_t currpos;
float lineWidth, wordWidth;
float widest = 0;
// get first word.
currpos = getNextWord (text, 0, thisWord);
lineWidth = getTextExtent (thisWord, x_scale);
// while there are words left in the string...
while (String::npos != text.find_first_not_of (whitespace, currpos))
{
// get next word of the string...
currpos += getNextWord (text, currpos, thisWord);
wordWidth = getTextExtent (thisWord, x_scale);
// if the new word would make the string too long
if ((lineWidth + wordWidth) > wrapWidth)
{
if (lineWidth > widest)
widest = lineWidth;
// remove whitespace from next word - it will form start of next line
thisWord = thisWord.substr (thisWord.find_first_not_of (whitespace));
wordWidth = getTextExtent (thisWord, x_scale);
// reset for a new line.
lineWidth = 0;
}
// add the next word to the line
lineWidth += wordWidth;
}
if (lineWidth > widest)
widest = lineWidth;
return widest;
}
/**
* @brief Extract exports to link to procompiled C routines inside xppaut
*
* This function extracts the in and out arguments of the respective function.
* To keep with the other structures the Args vector contains both the input and
* the output. Therefore the Expr string contains the number of input arguments.
*/
void xppParser::extractExport(void) {
auto line = lines.begin();
while (line != lines.end()) {
std::size_t pos1 = line->first.find("export");
std::size_t pos2 = line->first.find(" ", pos1);
if (pos1 != std::string::npos) {
opts opt(line->second);
opt.Args = getList(getNextWord(*line, pos1, pos2), opt.Line, "}", ",");;
opt.Expr = std::to_string(opt.Args.size());
stringList temp = getList(getNextWord(*line, pos1, pos2), opt.Line, "}", ",");
opt.Args.insert(opt.Args.end(), temp.begin(), temp.end());
Exports.push_back(opt);
lines.erase(line);
} else {
++line;
}
}
}
void AGOSEngine_PuzzlePack::opp_restoreOopsPosition() {
// 32: restore oops position
uint i;
getNextWord();
getNextWord();
if (_oopsValid) {
for (i = 0; i < _numVars; i++) {
_variableArray[i] = _variableArray2[i];
}
i = _variableArray[999] * 100 + 11;
setWindowImage(4,i);
_gameTime += 10;
// Swampy adventures
if (!getBitFlag(110))
_gameTime += 20;
_oopsValid = false;
}
}
bool DBMS::parseCreateTable() {
if (getNextWord(tableName, 32) == -1)
return false;
this->pos++; // skip '('
// 生成链表
Data *p = new Data;
data = p; // head
p->next = p;
//TODO 没有检查返回值是-1的情况
while (!endOfSql()) {
p = p->next;
getNextWord(p->name, 32);
p->num = getNextWord(p->value, 32); // 如果是char，返回值是char的长度，否则为0
p->next = new Data;
}
delete p->next;
p->next = NULL;
return true;
}
