Tokens get_tokens( const String& s ) {
Tokens res;
char prev = ' ';
String tmp;
for ( auto c : s ) {
if ( prev != ' ' && prev != c ) {
res.push_back(tmp);
prev = c;
tmp = "";
tmp += c;
} else {
prev = c;
tmp += c;
}
}
if ( tmp != "" )
res.push_back(tmp);
return res;
}
Tokens StrSplit(const std::string& src, const std::string& sep)
{
Tokens r;
std::string s;
for (char i : src)
{
if (sep.find(i) != std::string::npos)
{
if (s.length()) r.push_back(s);
s.clear();
}
else
{
s += i;
}
}
if (s.length()) r.push_back(s);
return r;
}
Tokens StrSplit(const std::string& src, const std::string& sep)
{
Tokens r;
std::string s;
for (std::string::const_iterator i = src.begin(); i != src.end(); ++i)
{
if (sep.find(*i) != std::string::npos)
{
if (s.length()) r.push_back(s);
s = "";
}
else
{
s += *i;
}
}
if (s.length()) r.push_back(s);
return r;
}
static void AddChildren(Tokens& tok, TreeNode* parent)
{
TreeNode* cur = 0;
while (tok.Good())
{
std::string str;
tok >> str;
if (!tok.Good() || str.at(0) == '}')
return;
if (str.at(0) == '{')
{
if (!cur)
cur = parent->AddChild(TreeNode::strdup(""));
AddChildren(tok, cur);
continue;
}
cur = parent->AddChild(TreeNode::strdup(str));
}
}
//static
void Command::parseDump( Tokens& tokens, bool helpMode, Command*& result )
{
if (tokens.size() < 3 && !helpMode) THROW( CWDB_ERR_PARSER, "Bad syntax: missing options in \"dump\" command" );
switch( checkAngen( tokens, 1) ) {
case ANGEN_COLLECTION: result = new DumpCollectionCommand; break;
default: THROW( CWDB_ERR_PARSER, "Bad syntax: unrecognized option in \"dump\" command" );
}
if (result != 0 && !helpMode) result->parse( tokens );
}
void Editor::autoComplete(const QString& item)
{
if (!m_isAutoCompletionEnabled || item.isEmpty())
return;
const int currentPosition = textCursor().position();
const QString subtext = text().left(currentPosition);
const Tokens tokens = m_evaluator->scan(subtext);
if (!tokens.valid() || tokens.count() < 1)
return;
const Token lastToken = tokens.at(tokens.count() - 1);
if (!lastToken.isIdentifier())
return;
const QStringList str = item.split(':');
blockSignals(true);
QTextCursor cursor = textCursor();
cursor.setPosition(lastToken.pos());
cursor.setPosition(lastToken.pos() + lastToken.text().length(), QTextCursor::KeepAnchor);
setTextCursor(cursor);
insert(str.at(0));
blockSignals(false);
cursor = textCursor();
bool hasParensAlready;
if ((hasParensAlready = cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor))) {
QString nextChar = cursor.selectedText();
hasParensAlready = (nextChar == "(");
}
bool shouldAutoInsertParens = (FunctionRepo::instance()->find(str.at(0))
|| m_evaluator->hasUserFunction(str.at(0)))
&& !hasParensAlready;
if (shouldAutoInsertParens) {
insert(QString::fromLatin1("()"));
cursor = textCursor();
cursor.movePosition(QTextCursor::PreviousCharacter);
setTextCursor(cursor);
}
}
void RenameMetricCommand::parse(Tokens& tokens)
{
if (tokens.size() != 5) THROW("Invalid RENAME METRIC command");
if (tokens[2].m_angen != ANGEN_IDENT) THROW("Expected existing metric name");
m_oldName = tokens[2].m_val.m_str;
if (!checkString(tokens[3], "to")) THROW("Expected key word TO");
if (tokens[4].m_angen != ANGEN_IDENT) THROW("Expected new metric name");
m_newName = tokens[4].m_val.m_str;
}
void RenameDataspaceCommand::parse(Tokens& tokens)
{
if (tokens.size() != 5) THROW("Invalid RENAME DATASPACE command");
if (tokens[2].m_angen != ANGEN_IDENT) THROW("Expected existing dataspace name");
m_oldName = tokens[2].m_val.m_str;
if (!checkString(tokens[3], "to")) THROW("Expected key word TO");
if (tokens[4].m_angen != ANGEN_IDENT) THROW("Expected new dataspace name");
m_newName = tokens[4].m_val.m_str;
}
StringUtils::Tokens StringUtils::tokenize(const std::string& str, const std::string& delimiters)
{
Tokens tokens;
std::string::size_type delimPos = 0, tokenPos = 0, pos = 0;
if(str.length()<1) return tokens;
while(1)
{
delimPos = str.find_first_of(delimiters, pos);
tokenPos = str.find_first_not_of(delimiters, pos);
if (tokenPos != std::string::npos && str[tokenPos]=='\"')
{
delimPos = str.find_first_of("\"", tokenPos+1);
pos++;
}
if(std::string::npos != delimPos)
{
if(std::string::npos != tokenPos)
{
if(tokenPos<delimPos)
{
std::string token = str.substr(pos,delimPos-pos);
if (token.length()) tokens.push_back(token);
}
}
pos = delimPos+1;
}
else
{
if(std::string::npos != tokenPos)
{
std::string token = str.substr(pos);
if (token.length()) tokens.push_back(token);
}
break;
}
}
return tokens;
}
int main()
{
Code code("//bla bli blo\nflap");
CodeRange cr(code);
Tokens tokens;
tokens.push_back(Token::Ptr(new Symbol(reduce(cr, 1))));
tokens.push_back(Token::Ptr(new Symbol(reduce(cr, 1))));
tokens.push_back(Token::Ptr(new Name(reduce(cr, 3))));
tokens.push_back(Token::Ptr(new Whitespace(reduce(cr, 1))));
tokens.push_back(Token::Ptr(new Name(reduce(cr, 3))));
tokens.push_back(Token::Ptr(new Whitespace(reduce(cr, 1))));
tokens.push_back(Token::Ptr(new Name(reduce(cr, 3))));
tokens.push_back(Token::Ptr(new Newline(reduce(cr, 1))));
tokens.push_back(Token::Ptr(new Name(reduce(cr, 4))));
TokenRange tr(tokens);
auto comment = Comment::construct(tr);
return 0;
}
inline void spansToTokens(std::string const& str, TokenSpans const& spans, Tokens &tokens) {
if (str.empty()) return;
char const* s = &str[0];
unsigned i = 0, n = spans.size();
tokens.resize(n);
for (; i < n; ++i) {
TokenSpan const& span = spans[i];
assert(span.first < str.size());
assert(span.second <= str.size());
tokens[i].assign(s + span.first, s + span.second);
}
}
void RealmList::UpdateRealm( uint32 ID, const std::string& name, const std::string& address, uint32 port, uint8 icon, RealmFlags realmflags, uint8 timezone, AccountTypes allowedSecurityLevel, float popu, const char* builds)
{
// Create new if not exist or update existed
Realm& realm = m_realms[name];
realm.m_ID = ID;
realm.icon = icon;
realm.realmflags = realmflags;
realm.timezone = timezone;
realm.allowedSecurityLevel = allowedSecurityLevel;
realm.populationLevel = popu;
Tokens tokens = StrSplit(builds, " ");
Tokens::iterator iter;
for (iter = tokens.begin(); iter != tokens.end(); ++iter)
{
uint32 build = atol((*iter).c_str());
realm.realmbuilds.insert(build);
}
uint16 first_build = !realm.realmbuilds.empty() ? *realm.realmbuilds.begin() : 0;
realm.realmBuildInfo.build = first_build;
realm.realmBuildInfo.major_version = 0;
realm.realmBuildInfo.minor_version = 0;
realm.realmBuildInfo.bugfix_version = 0;
realm.realmBuildInfo.hotfix_version = ' ';
if (first_build)
if (RealmBuildInfo const* bInfo = FindBuildInfo(first_build))
if (bInfo->build == first_build)
realm.realmBuildInfo = *bInfo;
// Append port to IP address.
std::ostringstream ss;
ss << address << ":" << port;
realm.address = ss.str();
}
//static
void Command::parseDrop( Tokens& tokens, bool helpMode, Command*& result )
{
if (tokens.size() < 3 && !helpMode) THROW( CWDB_ERR_PARSER, "Bad syntax: missing options in \"drop\" command" );
switch( checkAngen( tokens, 1) ) {
case ANGEN_DATASPACE: result = new DropDataspaceCommand; break;
case ANGEN_COLLECTION: result = new DropCollectionCommand; break;
case ANGEN_METRIC: result = new DropMetricCommand; break;
default: THROW( CWDB_ERR_PARSER, "Bad syntax: unrecongized option in \"drop\" command" );
}
if (result != 0 && !helpMode) result->parse( tokens );
}
void Editor::autoCalcSelection()
{
if (!m_isAutoCalcEnabled)
return;
const QString str = m_evaluator->autoFix(textCursor().selectedText());
if (str.isEmpty())
return;
// Very short (just one token) and still no calculation, then skip.
if (!m_isAnsAvailable) {
const Tokens tokens = m_evaluator->scan(text());
if (tokens.count() < 2)
return;
}
// Too short even after autofix? Don't bother either.
const Tokens tokens = m_evaluator->scan(str);
if (tokens.count() < 2)
return;
// Same reason as above, do not update "ans".
m_evaluator->setExpression(str);
const HNumber num = m_evaluator->evalNoAssign();
if (m_evaluator->error().isEmpty()) {
if (num.isNan() && m_evaluator->isUserFunctionAssign()) {
// Result is not always available when assigning a user function.
const QString message = tr("Selection result: n/a");
emit autoCalcEnabled(message);
} else {
const QString message = tr("Selection result: <b>%1</b>").arg(NumberFormatter::format(num));
emit autoCalcEnabled(message);
}
} else
emit autoCalcEnabled(m_evaluator->error());
}
void ShowMetricCommand::parse(Tokens& tokens)
{
if (tokens.size() < 3 || tokens[2].m_angen != ANGEN_IDENT) THROW("Invalid SHOW METRIC command");
m_name = tokens[2].m_val.m_str;
if (tokens.size() <= 3) return;
map< string, int > attrs;
parseAttributesIndex(tokens, 3, attrs);
map< string, int >::iterator iter = attrs.begin();
for ( ; iter != attrs.end(); ++iter) {
int index = iter->second;
if (boost::iequals(iter->first, "format")) {
if (tokens[index].m_angen != ANGEN_IDENT) THROW("Expected time format identifier");
if (checkString(tokens[index], "epoch"))
m_epochTime = 1;
else if (checkString(tokens[index], "iso"))
m_epochTime = -1;
else
THROW(string("Invalid value for format. Epxected epoch or iso"));
}
else if (boost::iequals(iter->first, "local")) {
if (tokens[index].m_angen != ANGEN_IDENT) THROW("Expected time local true/false");
if (checkString(tokens[index], "true"))
m_localTime = 1;
else if (checkString(tokens[index], "false"))
m_localTime = -1;
else
THROW(string("Invalid value for local. Expected true or false"));
}
else {
THROW(string("Unexpected attribute ")+iter->first+" in show command");
}
}
}
void Sentence::tokenize()
{
Tokens tokens;
::tokenize(sent_,tokens);
int i,n = tokens.size();
Syllable sy;
sy.span = 1;
sy.sent_ = this;
sy.start = 0;
for (i = 0;i < n;i ++) {
if (tokens[i].is_token) {
/*
char *viet_token = viet_to_viscii(tokens[i].value.c_str());
if (!viet_token) {
sy.id = get_sarch()[tokens[i].value];
sy.cid = get_sarch()[string("6")+tokens[i].value];
syllables.push_back(sy);
} else {
*/
const char *viet_token = tokens[i].value.c_str();
int jj,nn = strlen(viet_token);
for (jj = 0;jj < nn;jj ++)
if (viet_isalpha((unsigned char)viet_token[jj]) || viet_isdigit((unsigned char)viet_token[jj])) {
string s = viet_token;
sy.id = get_ngram()[s];
sy.cid = get_ngram()[get_std_syllable(s)];
syllables.push_back(sy);
break;
}
/*}*/
}
sy.start += tokens[i].value.size();
}
}
bool DatabasePostgre::Initialize(const char *infoString)
{
if(!Database::Initialize(infoString))
return false;
tranThread = NULL;
InitDelayThread();
Tokens tokens = StrSplit(infoString, ";");
Tokens::iterator iter;
std::string host, port_or_socket_dir, user, password, database;
iter = tokens.begin();
if(iter != tokens.end())
host = *iter++;
if(iter != tokens.end())
port_or_socket_dir = *iter++;
if(iter != tokens.end())
user = *iter++;
if(iter != tokens.end())
password = *iter++;
if(iter != tokens.end())
database = *iter++;
if (host == ".")
mPGconn = PQsetdbLogin(NULL, port_or_socket_dir == "." ? NULL : port_or_socket_dir.c_str(), NULL, NULL, database.c_str(), user.c_str(), password.c_str());
else
mPGconn = PQsetdbLogin(host.c_str(), port_or_socket_dir.c_str(), NULL, NULL, database.c_str(), user.c_str(), password.c_str());
/* check to see that the backend connection was successfully made */
if (PQstatus(mPGconn) != CONNECTION_OK)
{
sLog.outError( "Could not connect to Postgre database at %s: %s",
host.c_str(), PQerrorMessage(mPGconn));
PQfinish(mPGconn);
mPGconn = NULL;
return false;
}
else
{
sLog.outDetail( "Connected to Postgre database at %s",
host.c_str());
sLog.outString( "PostgreSQL server ver: %d",PQserverVersion(mPGconn));
return true;
}
}
int ClangFunctionHintModel::activeArgument(const QString &prefix) const
{
int argnr = 0;
int parcount = 0;
SimpleLexer tokenize;
Tokens tokens = tokenize(prefix);
for (int i = 0; i < tokens.count(); ++i) {
const CPlusPlus::Token &tk = tokens.at(i);
if (tk.is(T_LPAREN))
++parcount;
else if (tk.is(T_RPAREN))
--parcount;
else if (! parcount && tk.is(T_COMMA))
++argnr;
}
if (parcount < 0)
return -1;
if (argnr != m_currentArg)
m_currentArg = argnr;
return argnr;
}
//static
void Command::parseDescr( Tokens& tokens, bool helpMode, Command*& result )
{
if (tokens.size() == 1) {
result = new DescrCommand();
return;
}
switch( checkAngen( tokens, 1) ) {
case ANGEN_DATASPACE: result = new DescrDataspaceCommand; break;
case ANGEN_COLLECTION: result = new DescrCollectionCommand; break;
case ANGEN_METRIC: result = new DescrMetricCommand; break;
default: THROW( CWDB_ERR_PARSER, "Bad syntax: unrecognized option in \"descr\" command" );
}
if (result != 0 && !helpMode) result->parse( tokens );
}
void CommandLineEngine::help(Print * printer, Tokens & tk, FunctionFlags ff)
{
if (!printer)
return;
UserFunctions::iterator it;
String arg;
if( tk.next(arg) )
{
if( arg.equalsIgnoreCase("help") )
{
printer->println("Type help without any arguments to learn more.");
return;
}
else if( arg.equalsIgnoreCase("set") )
{
set(printer, tk, FF_HelpText);
return;
}
it = findFunction(arg);
if( it == mUserFunctions.end() )
{
printer->print("Unable to locate the function: ");
printer->println(arg);
return;
}
// Call the function and tell it to display its help text
it->func(printer, tk, FF_HelpText);
return;
}
else
{
printer->println("Function Name: help");
printer->println("Type help <function name> to learn more about that function.");
printer->println("The following functions are defined:");
printer->println("help");
printer->println("set");
// List all the functions
for( it = mUserFunctions.begin(); it != mUserFunctions.end(); ++it)
{
printer->println(it->name);
}
}
}
void Player::_LoadArchaeology(QueryResult* result)
{
for (uint8 i = 0; i < MAX_RESEARCH_SITES; ++i)
_digSites[i].count = 0;
if (!sWorld.getConfig(CONFIG_BOOL_ARCHAEOLOGY_ENABLED))
{
delete result;
return;
}
if (!result)
{
GenerateResearchSites();
GenerateResearchProjects();
return;
}
Field* fields = result->Fetch();
// Loading current zones
Tokens tokens = Tokens(fields[0].GetCppString(), ' ');
if (tokens.size() != 0 && tokens.size() <= MAX_RESEARCH_SITES)
{
_researchSites.clear();
for (uint8 i = 0; i < tokens.size(); ++i)
_researchSites.insert(uint32(atoi(tokens[i])));
}
else
GenerateResearchSites();
// Loading current zone info
tokens = Tokens(fields[1].GetCppString(), ' ');
if (tokens.size() == MAX_RESEARCH_SITES)
{
for (uint8 i = 0; i < MAX_RESEARCH_SITES; ++i)
_digSites[i].count = uint32(atoi(tokens[i]));
}
// Loading current projects
tokens = Tokens(fields[2].GetCppString(), ' ');
if (tokens.size() == MAX_RESEARCH_PROJECTS)
{
for (uint8 i = 0; i < MAX_RESEARCH_PROJECTS; ++i)
if (ResearchProjectEntry const* entry = sResearchProjectStore.LookupEntry(atoi(tokens[i])))
if (entry->IsVaid())
ReplaceResearchProject(0, entry->ID);
}
else
GenerateResearchProjects();
delete result;
}
Params parseParams(Tokens& tokens) {
Params r;
while (tokens.peek()[0] == '"') {
auto param = parseString(tokens);
if (param.rfind("string", 0) == 0 || param.rfind("texture", 0) == 0 ||
param.rfind("spectrum", 0) == 0)
r.strings[param] = parseStrings(tokens);
else if (param.rfind("integer", 0) == 0)
r.ints[param] = parseInts(tokens);
else if (param.rfind("bool", 0) == 0)
r.bools[param] = parseBools(tokens);
else
r.reals[param] = parseReals(tokens);
}
return r;
}
void Editor::doMatchingLeft()
{
// Tokenize the expression.
const int currentPosition = textCursor().position();
// Check for right par.
QString subtext = text().left(currentPosition);
Tokens tokens = m_evaluator->scan(subtext, Evaluator::NoAutoFix);
if (!tokens.valid() || tokens.count() < 1)
return;
Token lastToken = tokens.at(tokens.count() - 1);
// Right par?
if (lastToken.type() == Token::stxClosePar && lastToken.pos() == currentPosition - 1) {
// Find the matching left par.
unsigned par = 1;
int matchPosition = -1;
for (int i = tokens.count() - 2; i >= 0 && par > 0; --i) {
Token matchToken = tokens.at(i);
switch (matchToken.type()) {
case Token::stxOpenPar : --par; break;
case Token::stxClosePar: ++par; break;
default:;
}
matchPosition = matchToken.pos();
}
if (par == 0) {
QTextEdit::ExtraSelection hilite1;
hilite1.cursor = textCursor();
hilite1.cursor.setPosition(matchPosition);
hilite1.cursor.setPosition(matchPosition + 1, QTextCursor::KeepAnchor);
hilite1.format.setBackground(m_highlighter->colorForRole(SyntaxHighlighter::Matched));
QTextEdit::ExtraSelection hilite2;
hilite2.cursor = textCursor();
hilite2.cursor.setPosition(lastToken.pos());
hilite2.cursor.setPosition(lastToken.pos() + 1, QTextCursor::KeepAnchor);
hilite2.format.setBackground(m_highlighter->colorForRole(SyntaxHighlighter::Matched));
QList<QTextEdit::ExtraSelection> extras;
extras << hilite1;
extras << hilite2;
setExtraSelections(extras);
}
}
}
void Editor::doMatchingRight()
{
// Tokenize the expression.
const int currentPosition = textCursor().position();
// Check for left par.
QString subtext = text().right(text().length() - currentPosition);
Tokens tokens = m_evaluator->scan(subtext);
if (!tokens.valid() || tokens.count() < 1)
return;
Token firstToken = tokens.at(0);
// Left par?
if (firstToken.type() == Token::stxOpenPar && firstToken.pos() == 0) {
// Find the matching right par.
unsigned par = 1;
int k = 0;
Token matchToken;
int matchPosition = -1;
for (k = 1; k < tokens.count() && par > 0; ++k) {
const Token matchToken = tokens.at(k);
switch (matchToken.type()) {
case Token::stxOpenPar : ++par; break;
case Token::stxClosePar: --par; break;
default:;
}
matchPosition = matchToken.pos();
}
if (par == 0) {
QTextEdit::ExtraSelection hilite1;
hilite1.cursor = textCursor();
hilite1.cursor.setPosition(currentPosition+matchPosition);
hilite1.cursor.setPosition(currentPosition+matchPosition + 1, QTextCursor::KeepAnchor);
hilite1.format.setBackground(m_highlighter->colorForRole(SyntaxHighlighter::Matched));
QTextEdit::ExtraSelection hilite2;
hilite2.cursor = textCursor();
hilite2.cursor.setPosition(currentPosition+firstToken.pos());
hilite2.cursor.setPosition(currentPosition+firstToken.pos() + 1, QTextCursor::KeepAnchor);
hilite2.format.setBackground(m_highlighter->colorForRole(SyntaxHighlighter::Matched));
QList<QTextEdit::ExtraSelection> extras;
extras << hilite1;
extras << hilite2;
setExtraSelections(extras);
}
}
}
static NoCaseString getToken(unsigned& pos, const Tokens& toks, int symbol = SYMBOL)
{
if (pos >= toks.getCount())
generate_error("", UNEXPECTED_END_OF_COMMAND);
NoCaseString curTok(NoCaseString(toks[pos].text, toks[pos].length));
switch(symbol)
{
case SYMBOL:
break;
case STRING:
if (!strchr(quotes, toks[pos].text[0]))
generate_error(curTok, UNEXPECTED_TOKEN);
return toks[pos++].stripped().ToNoCaseString();
case NUMERIC:
{
const char* const end = &toks[pos].text[toks[pos].length];
for (const char* ptr = toks[pos].text; ptr < end; ++ptr)
{
if (*ptr < '0' || *ptr > '9')
generate_error(curTok, UNEXPECTED_TOKEN);
}
}
break;
default:
if (symbol > 0 && symbol <= 127) // good ascii symbol
{
if (toks[pos].length != 1 || toks[pos].text[0] != symbol)
generate_error(curTok, UNEXPECTED_TOKEN);
}
fb_assert(false);
break;
}
++pos;
return curTok;
}
//static
void Command::parseCreate( Tokens& tokens, bool helpMode, Command*& result )
{
if (tokens.size() < 3 && !helpMode) THROW( CWDB_ERR_PARSER, "Bad syntax: missing options in \"create\" command" );
switch( checkAngen(tokens, 1) ) {
case ANGEN_DATASPACE: result = new CreateDataspaceCommand; break;
case ANGEN_COLLECTION: result = new CreateCollectionCommand; break;
case ANGEN_METRIC: result = new CreateMetricCommand; break;
/******************
if (tokens.size() < 3 && !helpMode) THROW( CWDB_ERR_PARSER, "Bad syntax: missing options in \"create metric\" command" );
if (checkAngen( tokens, 3) == ANGEN_ASSIGN && !helpMode)
result = new CreateAggregationCommand;
else
result = new CreateMetricCommand;
break;
*******************/
default: THROW( CWDB_ERR_PARSER, "Bad syntax: unrecognized option in \"create\" command" );
}
if (result != 0 && !helpMode) result->parse( tokens );
}
//static
void Command::parseUpdate( Tokens& tokens, bool helpMode, Command*& result )
{
if (tokens.size() < 3 && !helpMode) THROW( CWDB_ERR_PARSER, "Bad syntax: missing options in \"update\" command" );
CreateUpdateMode mode;
tokens.erase( tokens.begin() );
if ( checkString( tokens.front(), "or") ) {
if (tokens[1].m_angen != ANGEN_CREATE) THROW( CWDB_ERR_PARSER, "Bad syntax: expected keyword \"create\"" );
tokens.erase( tokens.begin() );
mode = CRM_CREATE_UPDATE;
}
else {
Token dummy;
dummy.m_angen = ANGEN_CREATE;
tokens.insert( tokens.begin(), dummy );
mode = CRM_UPDATE;
}
switch( checkAngen(tokens, 1) ) {
case ANGEN_DATASPACE: result = new CreateDataspaceCommand( mode ); break;
case ANGEN_COLLECTION: result = new CreateCollectionCommand( mode ); break;
case ANGEN_METRIC: result = new CreateMetricCommand( mode ); break;
/*************************
if (tokens.size() < 3 && !helpMode) THROW( CWDB_ERR_PARSER, "Bad syntax: missing options in \"create metric\" command" );
if (checkAngen( tokens, 3) == ANGEN_ASSIGN && !helpMode)
result = new CreateAggregationCommand( mode );
else
result = new CreateMetricCommand( mode );
break;
**************************/
default: THROW( CWDB_ERR_PARSER, "Bad syntax: unrecognized option in \"create\" command" );
}
if (result != 0 && !helpMode) {
result->parse( tokens );
}
}
bool DatabaseMysql::Initialize(const char *infoString)
{
if (!Database::Initialize(infoString))
return false;
tranThread = NULL;
MYSQL *mysqlInit;
mysqlInit = mysql_init(NULL);
if (!mysqlInit)
{
sLog.outError("Could not initialize Mysql connection");
return false;
}
InitDelayThread();
Tokens tokens = StrSplit(infoString, ";");
Tokens::iterator iter;
std::string host, port_or_socket, user, password, database;
int port;
char const* unix_socket;
iter = tokens.begin();
if (iter != tokens.end())
host = *iter++;
if (iter != tokens.end())
port_or_socket = *iter++;
if (iter != tokens.end())
user = *iter++;
if (iter != tokens.end())
password = *iter++;
if (iter != tokens.end())
database = *iter++;
mysql_options(mysqlInit, MYSQL_SET_CHARSET_NAME, "utf8");
#ifdef WIN32
if (host==".") // named pipe use option (Windows)
{
unsigned int opt = MYSQL_PROTOCOL_PIPE;
mysql_options(mysqlInit, MYSQL_OPT_PROTOCOL, (char const*)&opt);
port = 0;
unix_socket = 0;
}
else // generic case
{
port = atoi(port_or_socket.c_str());
unix_socket = 0;
}
#else
if (host==".") // socket use option (Unix/Linux)
{
unsigned int opt = MYSQL_PROTOCOL_SOCKET;
mysql_options(mysqlInit, MYSQL_OPT_PROTOCOL, (char const*)&opt);
host = "localhost";
port = 0;
unix_socket = port_or_socket.c_str();
}
else // generic case
{
port = atoi(port_or_socket.c_str());
unix_socket = 0;
}
#endif
mMysql = mysql_real_connect(mysqlInit, host.c_str(), user.c_str(),
password.c_str(), database.c_str(), port, unix_socket, 0);
if (mMysql)
{
sLog.outDetail("Connected to MySQL database at %s", host.c_str());
sLog.outString("MySQL client library: %s", mysql_get_client_info());
sLog.outString("MySQL server ver: %s ", mysql_get_server_info( mMysql));
if (!mysql_autocommit(mMysql, 1))
sLog.outDetail("AUTOCOMMIT SUCCESSFULLY SET TO 1");
else
sLog.outDetail("AUTOCOMMIT NOT SET TO 1");
// set connection properties to UTF8 to properly handle locales for different
// server configs - core sends data in UTF8, so MySQL must expect UTF8 too
PExecute("SET NAMES `utf8`");
PExecute("SET CHARACTER SET `utf8`");
#if MYSQL_VERSION_ID >= 50003
my_bool my_true = (my_bool)1;
if (mysql_options(mMysql, MYSQL_OPT_RECONNECT, &my_true))
sLog.outDetail("Failed to turn on MYSQL_OPT_RECONNECT.");
else
sLog.outDetail("Successfully turned on MYSQL_OPT_RECONNECT.");
#else
#warning "Your mySQL client lib version does not support reconnecting after a timeout.\nIf this causes you any trouble we advice you to upgrade your mySQL client libs to at least mySQL 5.0.13 to resolve this problem."
#endif
return true;
}
else
{
sLog.outError("Could not connect to MySQL database at %s: %s\n", host.c_str(),mysql_error(mysqlInit));
mysql_close(mysqlInit);
return false;
}
}
void DropDataspaceCommand::parse(Tokens& tokens)
{
if (tokens.size() != 3 || tokens[2].m_angen != ANGEN_IDENT) THROW("Invalid DROP DATASPACE command");
m_name = tokens[2].m_val.m_str;
}
void CreateDataspaceCommand::parse(Tokens& tokens)
{
if (tokens.size() < 3 || tokens[2].m_angen != ANGEN_IDENT) THROW("Invalid CREATE DATASPACE command");
m_name = tokens[2].m_val.m_str;
if (tokens.size() > 3) parseAttributes(tokens, 3, m_attrs);
}
