void EnteredWorldState::runCommand(const std::string &command, const std::string &args)
{
if (Say == command) {
mAdapter.say(args);
} else if (SayTo == command) {
Tokeniser tokeniser(args);
std::string entityIdsString = tokeniser.nextToken();
std::vector<std::string> entityIds = Tokeniser::split(entityIdsString, ",");
std::string message = tokeniser.remainingTokens();
mAdapter.sayTo(message, entityIds);
} else if (Emote == command) {
mAdapter.emote(args);
} else if (Delete == command) {
Tokeniser tokeniser(args);
std::string entityId = tokeniser.nextToken();
if (!entityId.empty()) {
Eris::Entity* entity = getView().getEntity(entityId);
if (entity) {
mAdapter.deleteEntity(entity);
}
}
/* // Touch Command
} else if (command==TOUCH) {
// TODO: make this switch call the touch method
// TODO: polish this rough check
S_LOG_VERBOSE("Touching");
if(!mAvatar) {
S_LOG_WARNING("No avatar.");
return;
}
Atlas::Objects::Operation::Touch touch;
Atlas::Message::MapType opargs;
opargs["id"] = args;
touch->setFrom(mAvatar->getId());
touch->setArgsAsList(Atlas::Message::ListType(1, opargs));
mConn->send(touch);*/
} else if (AdminTell == command) {
Tokeniser tokeniser(args);
std::string entityId = tokeniser.nextToken();
if (!entityId.empty()) {
std::string key = tokeniser.nextToken();
if (!key.empty()) {
std::string value = tokeniser.nextToken();
if (!value.empty()) {
mAdapter.adminTell(entityId, key, value);
}
}
}
}
}
malValuePtr readStr(const String& input)
{
Tokeniser tokeniser(input);
if (tokeniser.eof()) {
throw malEmptyInputException();
}
return readForm(tokeniser);
}
/* Parses through the shader file and processes the tokens delivered by
* DefTokeniser.
*/
void ShaderFileLoader::parseShaderFile(std::istream& inStr,
const std::string& filename)
{
// Parse the file with a blocktokeniser, the actual block contents
// will be parsed separately.
parser::BasicDefBlockTokeniser<std::istream> tokeniser(inStr);
while (tokeniser.hasMoreBlocks())
{
// Get the next block
parser::BlockTokeniser::Block block = tokeniser.nextBlock();
// Skip tables
if (block.name.substr(0, 5) == "table")
{
std::string tableName = block.name.substr(6);
if (tableName.empty())
{
rError() << "[shaders] " << filename << ": Missing table name." << std::endl;
continue;
}
TableDefinitionPtr table(new TableDefinition(tableName, block.contents));
if (!GetShaderSystem()->addTableDefinition(table))
{
rError() << "[shaders] " << filename
<< ": table " << tableName << " already defined." << std::endl;
}
continue;
}
else if (block.name.substr(0, 5) == "skin ")
{
continue; // skip skin definition
}
else if (block.name.substr(0, 9) == "particle ")
{
continue; // skip particle definition
}
boost::algorithm::replace_all(block.name, "\\", "/"); // use forward slashes
ShaderTemplatePtr shaderTemplate(new ShaderTemplate(block.name, block.contents));
// Construct the ShaderDefinition wrapper class
ShaderDefinition def(shaderTemplate, filename);
// Insert into the definitions map, if not already present
if (!GetShaderLibrary().addDefinition(block.name, def))
{
rError() << "[shaders] " << filename
<< ": shader " << block.name << " already defined." << std::endl;
}
}
}
void CaelumSky::Config_CloudSpeed(const std::string& section, const std::string& key, varconf::Variable& variable)
{
if (variable.is_string() && mCaelumSystem->getCloudSystem()) {
Ogre::Vector2 vector;
Tokeniser tokeniser(variable);
vector.x = atof(tokeniser.nextToken().c_str());
vector.y = atof(tokeniser.nextToken().c_str());
mCaelumSystem->getCloudSystem()->getLayer(0)->setCloudSpeed(vector);
}
}
bool CaelumSun::parse(varconf::Variable& variable, Ogre::ColourValue& colour)
{
if (variable.is_string()) {
Tokeniser tokeniser(variable);
colour.r = atof(tokeniser.nextToken().c_str());
colour.g = atof(tokeniser.nextToken().c_str());
colour.b = atof(tokeniser.nextToken().c_str());
colour.a = atof(tokeniser.nextToken().c_str());
return true;
}
return false;
}
std::string MaterialSystem::getBlock (const std::string& texture)
{
if (texture.empty())
return "";
const std::string textureDir = GlobalTexturePrefix_get();
std::string skippedTextureDirectory = texture.substr(textureDir.length());
if (skippedTextureDirectory.empty())
return "";
MaterialBlockMap::iterator i = _blocks.find(skippedTextureDirectory);
if (i != _blocks.end())
return i->second;
if (!_materialLoaded)
loadMaterials();
if (!_materialLoaded)
return "";
StringOutputStream outputStream;
StringInputStream inputStream(_material);
AutoPtr<Tokeniser> tokeniser(GlobalScriptLibrary().createSimpleTokeniser(inputStream));
int depth = 0;
bool found = false;
std::string token = tokeniser->getToken();
while (token.length()) {
if (token == "{") {
depth++;
} else if (token == "}") {
depth--;
}
if (depth >= 1) {
if (depth == 1 && token == "material") {
token = tokeniser->getToken();
if (token == skippedTextureDirectory) {
found = true;
outputStream << "{ material ";
}
}
if (found)
outputStream << token << " ";
} else if (found) {
outputStream << "}";
break;
}
token = tokeniser->getToken();
}
return outputStream.toString();
}
void ShadowCameraSetup::Config_ShadowOptimalAdjustFactors(const std::string& section, const std::string& key, varconf::Variable& variable)
{
try {
if (variable.is_string()) {
S_LOG_VERBOSE("Setting shadow optimal adjust factor: " << static_cast<std::string>(variable));
Tokeniser tokeniser(variable);
mPssmSetup->setOptimalAdjustFactor(0, atof(tokeniser.nextToken().c_str()));
mPssmSetup->setOptimalAdjustFactor(1, atof(tokeniser.nextToken().c_str()));
mPssmSetup->setOptimalAdjustFactor(2, atof(tokeniser.nextToken().c_str()));
}
} catch (const std::exception& ex) {
S_LOG_FAILURE("Error when setting shadow optimal adjust factors." << ex);
}
}
FixupMap::Result FixupMap::perform()
{
UndoableCommand cmd("performFixup");
// Load contents
loadFixupFile();
// Load deprecated entities
loadDeprecatedEntities();
// Instantiate a line tokeniser
parser::BasicStringTokeniser tokeniser(_contents, "\n\r");
_curLineNumber = 0;
std::size_t parsedSize = 0;
while (tokeniser.hasMoreTokens())
{
_curLineNumber++;
std::string line = tokeniser.nextToken();
performFixup(line);
// Approximate the progress
parsedSize += line.size();
try
{
double fraction = static_cast<double>(parsedSize) / _contents.size();
_progress.setTextAndFraction(
(boost::format(_("Processing line %d...")) % _curLineNumber).str(),
fraction);
}
catch (gtkutil::ModalProgressDialog::OperationAbortedException& ex)
{
gtkutil::MessageBox box(_("Fixup cancelled"), ex.what(), ui::IDialog::MESSAGE_ERROR);
box.run();
return _result;
}
}
_progress.setTextAndFraction(_("Completed"), 1.0);
return _result;
}
void ShadowCameraSetup::Config_ShadowSplitPoints(const std::string& section, const std::string& key, varconf::Variable& variable)
{
try {
if (variable.is_string()) {
Ogre::PSSMShadowCameraSetup::SplitPointList splitPointList = mPssmSetup->getSplitPoints();
Tokeniser tokeniser(variable);
splitPointList[0] = atof(tokeniser.nextToken().c_str());
splitPointList[1] = atof(tokeniser.nextToken().c_str());
splitPointList[2] = atof(tokeniser.nextToken().c_str());
splitPointList[3] = atof(tokeniser.nextToken().c_str());
S_LOG_VERBOSE("Setting shadow split points: " << splitPointList[0] << " " << splitPointList[1] << " " << splitPointList[2] << " " << splitPointList[3]);
mPssmSetup->setSplitPoints(splitPointList);
}
} catch (const std::exception& ex) {
S_LOG_FAILURE("Error when setting shadow split points." << ex);
}
}
void LicenseParser::openLicenseFile (const std::string& filename)
{
clearLicenses();
std::string fullpath;
if (os::isAbsolute(filename)) {
fullpath = filename;
} else {
const std::string& appPath = GlobalRegistry().get(RKEY_APP_PATH);
fullpath = appPath + filename;
}
AutoPtr<ArchiveTextFile> file(GlobalFileSystem().openTextFile(fullpath));
if (file) {
AutoPtr<Tokeniser> tokeniser(GlobalScriptLibrary().createScriptTokeniser(file->getInputStream()));
parseLicensesFile(*tokeniser, fullpath);
}
}
model::IModelPtr MD5ModelLoader::loadModelFromPath(const std::string& name)
{
// Open an ArchiveFile to load
ArchiveFilePtr file = GlobalFileSystem().openFile(name);
if (file != NULL)
{
// Construct a new MD5Model container
MD5ModelPtr model(new MD5Model);
// Store the VFS path in this model
model->setModelPath(name);
// Set the filename this model was loaded from
model->setFilename(os::getFilename(file->getName()));
// greebo: Get the Inputstream from the given file
BinaryToTextInputStream<InputStream> inputStream(file->getInputStream());
// Construct a Tokeniser object and start reading the file
try
{
std::istream is(&inputStream);
parser::BasicDefTokeniser<std::istream> tokeniser(is);
// Invoke the parser routine (might throw)
model->parseFromTokens(tokeniser);
}
catch (parser::ParseException& e)
{
rError() << "[md5model] Parse failure. Exception was:" << std::endl
<< e.what() << std::endl;
// Return an empty model on error
return model::IModelPtr();
}
// Load was successful, return the model
return model;
}
else
{
rError() << "Failed to load model " << name << std::endl;
return model::IModelPtr(); // delete the model
}
}
GuiPtr GuiManager::loadGui(const std::string& guiPath)
{
// Insert a new entry in the map, if necessary
std::pair<GuiInfoMap::iterator, bool> result = _guis.insert(
GuiInfoMap::value_type(guiPath, GuiInfo())
);
GuiInfo& info = result.first->second;
ArchiveTextFilePtr file = GlobalFileSystem().openTextFile(guiPath);
if (file == NULL)
{
std::string errMSG = "Could not open file: " + guiPath + "\n";
_errorList.push_back(errMSG);
rError() << errMSG;
info.type = FILE_NOT_FOUND;
return GuiPtr();
}
// Construct a Code Tokeniser, which is able to handle #includes
try
{
std::string whiteSpace = std::string(parser::WHITESPACE) + ",";
parser::CodeTokeniser tokeniser(file, whiteSpace.c_str(), "{}(),;");
info.gui = Gui::createFromTokens(tokeniser);
info.type = UNDETERMINED;
return info.gui;
}
catch (parser::ParseException& p)
{
std::string errMSG = "Error while parsing " + guiPath + ": " + p.what() + "\n";
_errorList.push_back(errMSG);
rError() << errMSG;
info.type = IMPORT_FAILURE;
return GuiPtr();
}
}
void EntityMaker::runCommand(const std::string& command, const std::string& args) {
if (CreateEntity == command || Make == command || MakeMe == command) {
Tokeniser tokeniser(args);
if (tokeniser.hasRemainingTokens()) {
std::string typeName = tokeniser.nextToken();
Eris::TypeService* typeService = mConnection.getTypeService();
Eris::TypeInfo* typeinfo = typeService->getTypeByName(typeName);
if (typeinfo) {
std::string parentEntityId = mAvatar.getEntity()->getLocation()->getId();
if (MakeMe == command) {
parentEntityId = mAvatar.getEntity()->getId();
} else {
if (tokeniser.hasRemainingTokens()) {
parentEntityId = tokeniser.nextToken();
}
}
createEntityOfType(typeinfo, parentEntityId);
}
}
}
}
void MainCamera::Config_ClipDistances(const std::string& section, const std::string& key, varconf::Variable& variable)
{
Tokeniser tokeniser(variable);
float nearDistance = atof(tokeniser.nextToken().c_str());
float farDistance = atof(tokeniser.nextToken().c_str());
S_LOG_INFO("Setting main camera clip distances to near: " << nearDistance << " far: " << farDistance);
mCamera.setNearClipDistance(nearDistance);
//set the far clip distance high to make sure that the sky is completely shown
if (Ogre::Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(Ogre::RSC_INFINITE_FAR_PLANE))
{
/* //NOTE: this won't currently work with the sky
mCamera.setFarClipDistance(0);*/
mCamera.setFarClipDistance(farDistance);
} else {
mCamera.setFarClipDistance(farDistance);
}
}
// Parse the provided stream containing the contents of a single .def file.
// Extract all entitydefs and create objects accordingly.
void EClassManager::parse(TextInputStream& inStr, const std::string& modDir)
{
// Construct a tokeniser for the stream
std::istream is(&inStr);
parser::BasicDefTokeniser<std::istream> tokeniser(is);
while (tokeniser.hasMoreTokens())
{
std::string blockType = tokeniser.nextToken();
boost::algorithm::to_lower(blockType);
if (blockType == "entitydef")
{
// Get the (lowercase) entity name
const std::string sName =
boost::algorithm::to_lower_copy(tokeniser.nextToken());
// Ensure that an Entity class with this name already exists
// When reloading entityDef declarations, most names will already be registered
EntityClasses::iterator i = _entityClasses.find(sName);
if (i == _entityClasses.end())
{
// Not existing yet, allocate a new class
Doom3EntityClassPtr entityClass(new eclass::Doom3EntityClass(sName));
std::pair<EntityClasses::iterator, bool> result = _entityClasses.insert(
EntityClasses::value_type(sName, entityClass)
);
i = result.first;
}
else
{
// EntityDef already exists, compare the parse stamp
if (i->second->getParseStamp() == _curParseStamp)
{
rWarning() << "[eclassmgr]: EntityDef "
<< sName << " redefined" << std::endl;
}
}
// At this point, i is pointing to a valid entityclass
i->second->setParseStamp(_curParseStamp);
// Parse the contents of the eclass (excluding name)
i->second->parseFromTokens(tokeniser);
// Set the mod directory
i->second->setModName(modDir);
}
else if (blockType == "model")
{
// Read the name
std::string modelDefName = tokeniser.nextToken();
// Ensure that an Entity class with this name already exists
// When reloading entityDef declarations, most names will already be registered
Models::iterator i = _models.find(modelDefName);
if (i == _models.end())
{
// Does not exist yet, allocate a new one
// Allocate an empty ModelDef
Doom3ModelDefPtr model(new Doom3ModelDef(modelDefName));
std::pair<Models::iterator, bool> result = _models.insert(
Models::value_type(modelDefName, model)
);
i = result.first;
}
else
{
// Model already exists, compare the parse stamp
if (i->second->getParseStamp() == _curParseStamp)
{
rWarning() << "[eclassmgr]: Model "
<< modelDefName << " redefined" << std::endl;
}
}
// Model structure is allocated and in the map,
// invoke the parser routine
i->second->setParseStamp(_curParseStamp);
i->second->parseFromTokens(tokeniser);
i->second->setModName(modDir);
}
}
}
int main(int argc, char **argv)
{
int exitStatus(0);
bool exit_program = false;
std::string prefix("");
std::string homeDir("");
Ember::Application::ConfigMap configMap;
#ifndef __WIN32__
if (argc > 1)
{
(argv)++;
argc--;
while (argc > 0)
{
std::string arg = std::string((char *) argv[0]);
argv++;
argc--;
if (arg == "-v" || arg == "--version")
{
std::cout << "Ember version: " << VERSION << std::endl;
exit_program = true;
}
else if (arg == "-h" || arg == "--help")
{
std::cout << "-h, --help - display this message" << std::endl;
std::cout << "-v, --version - display version info" << std::endl;
std::cout << "--home <path> - sets the home directory to something different than the default (~/.ember on *NIX systems, $APPDATA\\Ember on win32 systems)" << std::endl;
std::cout << "-p <path>, --prefix <path> - sets the prefix to something else than the one set at compilation (only valid on *NIX systems)" << std::endl;
std::cout << "--config <section>:<key> <value> - allows you to override config file settings. See the ember.conf file for examples. (~/.ember/ember.conf on *NIX systems)" << std::endl;
exit_program = true;
break;
}
else if (arg == "-p" || arg == "--prefix")
{
if (!argc)
{
std::cout << "You didn't supply a prefix.";
exit_program = true;
}
else
{
prefix = std::string((char *) argv[0]);
argv++;
argc--;
}
}
else if (arg == "--home")
{
if (!argc)
{
std::cout << "You didn't supply a home directory.";
exit_program = true;
}
else
{
homeDir = std::string((char *) argv[0]);
argv++;
argc--;
}
}
else if (arg == "--config")
{
if (argc < 2)
{
std::cout << "You didn't supply any config arguments.";
}
else
{
std::string fullkey(argv[0]);
std::string value(argv[1]);
Ember::Tokeniser tokeniser(fullkey, ":");
if (tokeniser.remainingTokens() != "")
{
std::string category(tokeniser.nextToken());
if (tokeniser.remainingTokens() != "")
{
std::string key(tokeniser.nextToken());
configMap[category][key] = value;
}
}
}
}
}
}
#if !defined(__WIN32__) && !defined(__APPLE__)
if (exit_program)
{
return 0;
}
#endif
#ifdef ENABLE_BINRELOC
if (prefix == "")
{
BrInitError error;
if (br_init (&error) == 0 && error != BR_INIT_ERROR_DISABLED)
{
printf ("Warning: BinReloc failed to initialize (error code %d)\n", error);
printf ("Will fallback to hardcoded default path.\n");
}
char* br_prefixdir = br_find_prefix(PREFIX);
const std::string prefixDir(br_prefixdir);
free(br_prefixdir);
prefix = prefixDir;
}
#endif
// if (prefix == "") {
// prefix = PREFIX;
// }
#else
// char tmp[64];
// unsigned int floatSetting = _controlfp( 0, 0 );
//sprintf(tmp, "Original: 0x%.4x\n", floatSetting );
// MessageBox( 0, tmp, "floating point control", MB_OK | MB_ICONERROR | MB_TASKMODAL);
//_fpreset();
//_controlfp(_PC_64, _MCW_PC);
//_controlfp(_RC_NEAR , _MCW_RC);
//floatSetting = _controlfp( 0, 0 );
//sprintf(tmp, "New: 0x%.4x\n", floatSetting );
// MessageBox( 0, tmp, "floating point control", MB_OK | MB_ICONERROR | MB_TASKMODAL);
#endif
try
{
//put the application object in its own scope so it gets destroyed before we signal all clear
{
// Create application object
Ember::Application app(prefix, homeDir, configMap);
//Ember::OgreView::EmberOgre app;
std::cout << "Starting Ember version " << VERSION << std::endl;
app.registerComponents();
// Initialize all Ember services needed for this application
app.prepareComponents();
app.initializeServices();
app.start();
}
} catch (const std::exception& ex)
{
std::cerr << "Unexpected error, aborting.\n\r\t" << ex.what() << std::endl;
exitStatus = 1;
}
std::cout << "Ember shut down successfully." << std::endl;
return exitStatus;
}
void TableDefinition::parseDefinition()
{
// consider ourselves parsed from now on
_parsed = true;
try
{
// Use a tokeniser to read the values
parser::BasicDefTokeniser<std::string> tokeniser(_blockContents, " \n\t\r,");
std::size_t level = 0;
while (tokeniser.hasMoreTokens())
{
std::string token = tokeniser.nextToken();
if (token == "{")
{
++level;
if (level > 1)
{
throw parser::ParseException("Too many opening braces.");
}
}
else if (token == "}")
{
if (level == 0)
{
throw parser::ParseException("Too many closing braces.");
}
--level;
}
else if (token == "clamp")
{
if (level != 0)
{
throw parser::ParseException("The 'clamp' keyword cannot be used at this scope/position.");
}
_clamp = true;
}
else if (token == "snap")
{
if (level != 0)
{
throw parser::ParseException("The 'snap' keyword cannot be used at this scope/position.");
}
_snap = true;
}
else
{
// Expect a numeric value at this point
try
{
_values.push_back(boost::lexical_cast<float>(token));
}
catch (boost::bad_lexical_cast& ex)
{
throw parser::ParseException("Invalid token '" + token +
"' encountered: " + ex.what());
}
}
}
}
catch (parser::ParseException& ex)
{
rError() << "[shaders] Error parsing table '" << _name << "': " << ex.what() << std::endl;
}
}
void TextField2::parseRawText()
{
TextTokeniser tokeniser(mRawText.c_str());
const char *token = tokeniser.nextToken();
mText = "";
mNewLinePositions.clear();
mNewLinePositions.push_back(0);
mNewLineDirty = true;
bool firstLine = true;
enum ParseState {
BASE, START_FORMAT, END_FORMAT, IN_FORMAT_ATTR, IN_FORMAT_OP, IN_FORMAT_VALUE, POP_FORMAT
};
ParseState state = BASE;
Handle<Node> currentNode = mRootNode;
mRootNode->clear();
mTextHitboxes->clear();
string attrName = "";
while (token != NULL)
{
if (state == BASE && token[0] == '<')
{
state = START_FORMAT;
}
else if (state != BASE && token[0] == '>')
{
state = BASE;
}
else if (state == START_FORMAT)
{
if (token[0] == '/')
{
state = POP_FORMAT;
}
else
{
string lower = Utils::toLowerCase(token);
Node *newNode = new Node(lower.c_str());
currentNode->addChild(newNode);
currentNode = newNode;
state = IN_FORMAT_ATTR;
}
}
else if (state == IN_FORMAT_ATTR)
{
if (token[0] == '>')
{
state = END_FORMAT;
}
attrName = Utils::toLowerCase(token);
state = IN_FORMAT_OP;
}
else if (state == IN_FORMAT_OP)
{
if (token[0] == '>')
{
state = END_FORMAT;
}
else if (token[0] != '=')
{
currentNode->setAttribute(attrName.c_str(), "true");
state = IN_FORMAT_ATTR;
}
else
{
state = IN_FORMAT_VALUE;
}
}
else if (state == IN_FORMAT_VALUE)
{
if (token[0] == '>')
{
stringstream ss;
ss << "Error parsing node '" << attrName << "', = operator had not value";
am_log("TEXT", ss);
}
else
{
currentNode->setAttribute(attrName.c_str(), token);
state = IN_FORMAT_ATTR;
}
}
else if (state == END_FORMAT)
{
while (token != NULL && token[0] != '>')
{
token = tokeniser.nextToken();
}
state = BASE;
}
else if (state == POP_FORMAT)
{
string lower = Utils::toLowerCase(token);
if (currentNode->getParent() == NULL)
{
am_log("NODE", "Pop format to NULL parent");
}
else
{
currentNode = currentNode->getParent();
}
state = END_FORMAT;
}
else if (state == BASE)
{
currentNode->appendText(token);
mText += token;
}
if (state != END_FORMAT)
{
token = tokeniser.nextToken();
}
}
setTextDirty(false);
}
void CSoftUninstall::GetPinYin(const std::wstring &name, std::wstring &whole, std::wstring &acronym)
{
typedef list<string> str_list;
typedef str_list::iterator str_iter;
typedef string_tokeniser<string, char> string_tokeniser_a;
typedef void (string::*PFPushback)(char);
typedef string& (string::*PFAppend)(const char*);
PFAppend pfAppend = &string::append;
PFPushback pfPushback = &string::push_back;
char mbcs[5];
str_list wholeList, acronymList;
wholeList.push_back(string());
acronymList.push_back(string());
for(wstring::size_type i = 0; i < name.size(); ++i)
{
if(iswascii(name[i]) == 0)
{ // 非ASCII码
int ret;
if(wctomb_s(&ret, mbcs, sizeof(mbcs), name[i]) != 0) continue;
mbcs[ret] = '\0';
PinYinCIter itPinYin = _hashPinYin.find(mbcs);
if(itPinYin != _hashPinYin.end())
{
const PinYin &pinyin = itPinYin->second;
// M X N组合
{
string_tokeniser_a tokeniser(pinyin._whole, ' ');
str_list resultList;
string_tokeniser_a::const_iterator end = tokeniser.end();
for(string_tokeniser_a::const_iterator it = tokeniser.begin(); it != end; ++it)
{
str_iter endList = wholeList.end();
for(str_iter itList = wholeList.begin(); itList != endList; ++itList)
resultList.push_back(*itList + *it);
}
wholeList.swap(resultList);
}
{
string_tokeniser_a tokeniser(pinyin._acronym, ' ');
str_list resultList;
string_tokeniser_a::const_iterator end = tokeniser.end();
for(string_tokeniser_a::const_iterator it = tokeniser.begin(); it != end; ++it)
{
str_iter endList = acronymList.end();
for(str_iter itList = acronymList.begin(); itList != endList; ++itList)
resultList.push_back(*itList + *it);
}
acronymList.swap(resultList);
}
}
else
{
for_each(wholeList.begin(), wholeList.end(), bind2nd(mem_fun1_ref(pfAppend), mbcs));
for_each(acronymList.begin(), acronymList.end(), bind2nd(mem_fun1_ref(pfAppend), mbcs));
}
}
else
{
// ASCII码直接组合
for_each(wholeList.begin(), wholeList.end(), bind2nd(mem_fun1_ref(pfPushback), (char)towlower(name[i])));
for_each(acronymList.begin(), acronymList.end(), bind2nd(mem_fun1_ref(pfPushback), (char)tolower(name[i])));
}
}
// 合并结果
{
ostringstream os;
copy(wholeList.begin(), wholeList.end(), ostream_iterator<string>(os, " "));
whole = CA2W(os.str().c_str());
trim_right(whole);
}
{
ostringstream os;
copy(acronymList.begin(), acronymList.end(), ostream_iterator<string>(os, " "));
acronym = CA2W(os.str().c_str());
trim_right(acronym);
}
}
int CPUstats::getCpuStats(int cpu_no, trio *previous, int *usage)
{
int pos = 0;
int busy = 0;
int idle = 0;
int total = 0;
// Init file stream
*usage = -1;
std::ifstream stat("/proc/stat");
if (stat.fail()) return FAILURE;
// See procps/proc/sysinfo.c for inspiration (or comparison)...
char buf[BUFFSIZE];
buf[BUFFSIZE-1] = 0;
stat.read(buf, BUFFSIZE-1);
// Convenient Containers(TM)
std::string content(buf);
std::istringstream tokeniser(content);
// Look for CPU entry
while ((pos < content.length()) && tokeniser.good()) {
pos = content.find("cpu", pos);
// Check for potential match
if ((pos + 5) < content.length()) {
pos = pos + 3;
// Check for CPU number as opposed to whitespace
if (content[pos] != ' ') {
int CPU = atoi(content.substr(pos, 2).c_str());
pos = pos + 2;
// Check for CPU number match
if (CPU == cpu_no) {
if (content[pos] == ' ') pos++;
tokeniser.seekg(pos);
// Extract user, nice and system times
for (int i = 0; i < 3; i++) {
tokeniser >> total;
busy = busy + total;
}
// Extract idle time
tokeniser >> idle;
// Extract other times for total busy time
for (int i = 0; i < 3; i++) {
tokeniser >> total;
busy = busy + total;
}
total = busy + idle;
// Convert to percentage, save ticks
*usage = 100 * (busy - previous->busy) / (total - previous->total);
previous->busy = busy;
previous->idle = idle;
previous->total = total;
return SUCCESS;
}
}
}
Ogre::Root* OgreSetup::createOgreSystem()
{
ConfigService& configSrv(EmberServices::getSingleton().getConfigService());
if (configSrv.getPrefix() != "") {
//We need to set the current directory to the prefix before trying to load Ogre.
//The reason for this is that Ogre loads a lot of dynamic modules, and in some build configuration
//(like AppImage) the lookup path for some of these are based on the installation directory of Ember.
if (chdir(configSrv.getPrefix().c_str())) {
S_LOG_WARNING("Failed to change to the prefix directory '" << configSrv.getPrefix() << "'. Ogre loading might fail.");
}
}
std::string pluginExtension = ".so";
mRoot = new Ogre::Root("", "ogre.cfg", "");
//we will try to load the plugins from series of different location, with the hope of getting at least one right
std::vector<std::string> pluginLocations;
if (configSrv.itemExists("ogre", "plugins")) {
std::string plugins(configSrv.getValue("ogre", "plugins"));
//if it's defined in the config, use that location first
if (configSrv.itemExists("ogre", "plugindir")) {
std::string pluginDir(configSrv.getValue("ogre", "plugindir"));
pluginLocations.push_back(pluginDir);
}
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
pluginExtension = ".dll";
pluginLocations.push_back("."); //on windows we'll bundle the dll files in the same directory as the executable
#elif OGRE_PLATFORM == OGRE_PLATFORM_LINUX
pluginExtension = ".so";
std::string pluginDir = configSrv.getPrefix();
pluginDir += "/lib/OGRE";
pluginLocations.push_back(pluginDir);
#ifdef ENABLE_BINRELOC
//binreloc might be used
char* br_libdir = br_find_lib_dir(br_strcat(PREFIX, "/lib"));
std::string libDir(br_libdir);
free(br_libdir);
pluginLocations.push_back(libDir + "/OGRE");
#endif
#ifdef OGRE_PLUGINDIR
//also try with the plugindir defined for Ogre
pluginLocations.push_back(OGRE_PLUGINDIR);
#endif
//enter the usual locations if Ogre is installed system wide, with local installations taking precedence
pluginLocations.push_back("/usr/local/lib/OGRE");
pluginLocations.push_back("/usr/lib/OGRE");
#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE
// On Mac, plugins are found in Resources in the Main (Application) bundle, then in the Ogre framework bundle
pluginExtension = "";
std::string pluginDir = configSrv.getSharedDataDirectory();
pluginLocations.push_back(pluginDir);
pluginDir += "/../Plugins";
pluginLocations.push_back(pluginDir);
pluginLocations.push_back("");
#endif
Tokeniser tokeniser(plugins, ",");
std::string token = tokeniser.nextToken();
while (token != "") {
std::string pluginPath;
bool pluginLoaded = false;
for (std::vector<std::string>::iterator I = pluginLocations.begin(); I != pluginLocations.end(); ++I) {
pluginPath = (*I) + "/" + token + pluginExtension;
S_LOG_INFO("Trying to load the plugin '" << pluginPath << "'.");
try {
mRoot->loadPlugin(pluginPath);
pluginLoaded = true;
break;
} catch (...) {
pluginPath = (*I) + "/" + token + "_d" + pluginExtension;
S_LOG_INFO("Trying to load the plugin '" << pluginPath << "'.");
try {
mRoot->loadPlugin(pluginPath);
pluginLoaded = true;
break;
} catch (...) {
}
}
}
if (pluginLoaded) {
S_LOG_INFO("Successfully loaded the plugin '" << token << "' from '" << pluginPath << "'.");
} else {
S_LOG_FAILURE("Failed to load the plugin '" << token << "'!");
}
token = tokeniser.nextToken();
}
}
if (chdir(configSrv.getEmberDataDirectory().c_str())) {
S_LOG_WARNING("Failed to change to the data directory '" << configSrv.getEmberDataDirectory() << "'.");
}
return mRoot;
}
/*
This is the main method which is invoked to assemble an IMPS assembly file.
This method carries sets up the tables and then carries out the two pass
assembly and then writes the 32-bit binary representations of the instructions
into the file specified.
@param argc : specifies the number of arguments providied to the program at
run time
@param argv : specifes the arguments provided to the program to the run time
@return : returns 1 when the program suceeds without a failure.
*/
int main(int argc, char **argv) {
assert("Wrong Number of arguments" && argc==3);
struct Data *data = malloc(sizeof(struct Data));
memset(data->b_instruction,0 , 65536);
struct Table *opcodeTable = malloc(sizeof(struct Table));
opcodeTable = initialiseOpcodeTable();
struct Table *labelTable = malloc(sizeof(struct Table));
labelTable = initialiseEmptyTable();
uint32_t address = 0;
data->number_of_instructions = 0;
char *readFP = argv[1];
char *writeFP = argv[2];
FILE *fRead = fopen(readFP,"r");
if (fRead==NULL) {
perror("Error is reading from file");
exit(EXIT_FAILURE);
}
do {
data->a_instruction = NULL;
readFromFile(fRead,data);
if (strlen(data->a_instruction)==1) goto endOfPass1While;
pass1(data->a_instruction,address,labelTable);
address += 4;
data->number_of_instructions++;
endOfPass1While: ;
free(data->a_instruction);
} while(feof(fRead)==0);
rewind(fRead);
int i = 0;
address = 0;
while(feof(fRead)==0) {
data->a_instruction = NULL;
readFromFile(fRead,data);
if (strlen(data->a_instruction)==1) goto endOfWhilePass2;
char *tokens[5];
tokeniser(data->a_instruction,tokens);
if (strcmp(".skip",tokens[1])==0) {
printBits(0);
printf("\t%s", data->a_instruction);
int j = atoi(tokens[2]) - 1;
while (j>=1) {
printBits(0);
printf("\n");
--j;
}
i += atoi(tokens[2]);
address = i*4;
} else {
data->b_instruction[i] = pass2(tokens,labelTable,opcodeTable,address);
printBits(data->b_instruction[i]);
printf("\t%s\n", data->a_instruction);
address += 4;
i++;
}
endOfWhilePass2: ;
free(data->a_instruction);
}
data->number_of_instructions = i;
writeToFile(writeFP,data);
fclose(fRead);
}
uint32_t transfer(char **arguments, assembler *instState,table_t *t){
int P_Bit;
char *Rd = arguments[0];
char *address = arguments[1];
uint32_t rd = getConst(Rd);
int addrlen = strlen(address);
if(*address == '='){
//numeric constant;
int val = getConst(address);
if(val <= 0xFF){
//mov instruction;
isMov = 1;
char **inst = malloc(sizeof(char*)*3);
for(int i=0; i<3; i++){
inst[i] = malloc(sizeof(char)*20);
}
strcpy(inst[0],"mov");
strcpy(inst[1],Rd);
strcpy(inst[2],(address+1));
inst[2] = prepend(inst[2],'#');
return ass_data_process(inst,t);
}else{
strip(arguments[1]);
insertExpression(instState->BigVals,arguments[1],val,instState->counter);
rd <<= 12;
uint32_t val_mask = 0xE59F0000;
return val_mask | rd;
}
}
char **splitAddress = tokeniser(address,",");
if(address[0] == '[' && address[4] != ']' && address[3] != ']'){
//PRE instruction;
P_Bit = 1;
char *pre_address = removeBrackets(address);
char **expression = tokeniser(pre_address,".");
uint32_t rn = getConst(expression[0]);
uint32_t transfer_mask1 = 0xE5900000;
uint32_t incVal = getConst(expression[1]);
uint32_t offset = incVal; //TODO: ONCE MOV is fixed replace this with the val generated by mov
rn <<= 16;
rd <<= 12;
return transfer_mask1 | rn | rd | offset;
}else if(addrlen <= 5){
//PRE instruction;
P_Bit = 1;
char *Rn = removeBrackets(splitAddress[0]);
uint32_t rn = getConst(Rn);
uint32_t transfer_mask2 = 0xE5900000;
rn <<= 16;
rd <<= 12;
return transfer_mask2 | rn | rd;
}else{
//Post instruction;
P_Bit = 0;
uint32_t transfer_mask3 = 0xE6900000;
char **expression = tokeniser(address,".");
uint32_t rn = getConst(removeBrackets(expression[0]));
uint32_t offset = getConst(expression[1]);
rn <<= 16;
rd <<= 12;
return transfer_mask3 | rn | rd | offset;
}
}
void EnteredWorldState::runCommand(const std::string &command, const std::string &args)
{
if (Say == command) {
mAdapter.say(args);
} else if (SayTo == command) {
Tokeniser tokeniser(args);
std::string entityIdsString = tokeniser.nextToken();
std::vector < std::string > entityIds = Tokeniser::split(entityIdsString, ",");
std::vector<const Eris::Entity*> entities;
for (std::vector<std::string>::const_iterator I = entityIds.begin(); I != entityIds.end(); ++I) {
Eris::Entity* entity = getView().getEntity(*I);
if (entity) {
entities.push_back(entity);
} else {
S_LOG_WARNING("Tried to send message addressed to entity with id " << *I <<" which doesn't exist.");
}
}
std::string message = tokeniser.remainingTokens();
mAdapter.sayTo(message, entities);
} else if (Emote == command) {
mAdapter.emote(args);
} else if (Delete == command) {
Tokeniser tokeniser(args);
std::string entityId = tokeniser.nextToken();
if (entityId != "") {
Eris::Entity* entity = getView().getEntity(entityId);
if (entity) {
mAdapter.deleteEntity(entity);
}
}
/* // Touch Command
} else if (command==TOUCH) {
// TODO: make this switch call the touch method
// TODO: polish this rough check
S_LOG_VERBOSE("Touching");
if(!mAvatar) {
S_LOG_WARNING("No avatar.");
return;
}
Atlas::Objects::Operation::Touch touch;
Atlas::Message::MapType opargs;
opargs["id"] = args;
touch->setFrom(mAvatar->getId());
touch->setArgsAsList(Atlas::Message::ListType(1, opargs));
mConn->send(touch);*/
} else if (AdminTell == command) {
Tokeniser tokeniser(args);
std::string entityId = tokeniser.nextToken();
if (entityId != "") {
std::string key = tokeniser.nextToken();
if (key != "") {
std::string value = tokeniser.nextToken();
if (value != "") {
mAdapter.adminTell(entityId, key, value);
}
}
}
}
}
