void processLineOfTokens(TokenNode **tokens){
int i = 0;
TokenNode *pointer = tokens[i];
if (!pointer->pipe){
processToken(pointer);
}
else
{
while (pointer != NULL){
if (!pointer->pipe){
processToken(pointer);
//process will terminate in processToken function
}
int desp[2];
pipe(desp);
int pid = fork();
if (pid == 0){
close(desp[0]);
dup2(desp[1],1);
processToken(pointer);
}else{
close(desp[1]);
int status;
waitpid(pid,&status,0);
dup2(desp[0],STDIN_FILENO);
}
i++;
pointer = tokens[i];
}
}
}
// The state machine loop
PassRefPtrWillBeRawPtr<MediaQuerySet> MediaQueryParser::parseImpl(CSSParserTokenRange range)
{
while (!range.atEnd())
processToken(range.consume());
// FIXME: Can we get rid of this special case?
if (m_parserType == MediaQuerySetParser)
processToken(CSSParserToken(EOFToken));
if (m_state != ReadAnd && m_state != ReadRestrictor && m_state != Done && m_state != ReadMediaNot)
m_querySet->addMediaQuery(MediaQuery::createNotAll());
else if (m_mediaQueryData.currentMediaQueryChanged())
m_querySet->addMediaQuery(m_mediaQueryData.takeMediaQuery());
return m_querySet;
}
void PostfixExprEvaluator::processToken(Token &token,
std::stack<Token> &operands,
Variables &vars)
{
switch (token.type)
{
case TokenType::TOK_VARIABLE:
token = vars.at(token.value.valueString);
processToken(token, operands, vars);
break;
case TokenType::TOK_LPAREN:
case TokenType::TOK_RPAREN:
break;
case TokenType::TOK_FLOAT:
case TokenType::TOK_INT:
operands.push(token);
break;
case TokenType::TOK_UNARYOP:
processUnaryOp(token, operands);
break;
case TokenType::TOK_BINARYOP:
processBinaryOp(token, operands);
break;
}
}
//--------------------------------------------------------------
// parse the file
void BVHFile::parseFile(
const char* fileName)
{
FILE* bvhFile = fopen(fileName, "rt");
if (bvhFile == NULL)
throw new mgException("cannot open %s", (const char*) fileName);
m_state = STATE_START;
m_linenum = 1;
char buffer[4096];
while (true)
{
size_t readLen = fread(buffer, 1, sizeof(buffer), bvhFile);
if (readLen == 0)
break;
parseBuffer(buffer, (int) readLen);
}
if (!m_token.isEmpty())
processToken(m_token);
fclose(bvhFile);
if (m_root != NULL)
mgDebug("read %d nodes", m_root->nodeCount());
mgDebug("frameCount: %d, frameTime: %g, totalChannels: %d", m_frameCount, m_frameTime, m_totalChannels);
if (m_state != STATE_DONE)
mgDebug("did not read all samples. count = %d, expected %d", m_count, m_totalChannels*m_frameCount);
}
// The state machine loop
RefPtr<MediaQuerySet> MediaQueryParser::parseInternal(CSSParserTokenRange range)
{
while (!range.atEnd())
processToken(range.consume());
// FIXME: Can we get rid of this special case?
if (m_parserType == MediaQuerySetParser)
processToken(CSSParserToken(EOFToken));
if (m_state != ReadAnd && m_state != ReadRestrictor && m_state != Done && m_state != ReadMediaNot) {
MediaQuery query = MediaQuery(MediaQuery::Not, "all", Vector<MediaQueryExpression>());
m_querySet->addMediaQuery(WTFMove(query));
} else if (m_mediaQueryData.currentMediaQueryChanged())
commitMediaQuery();
return m_querySet;
}
// The state machine loop
PassRefPtrWillBeRawPtr<MediaQuerySet> MediaQueryParser::parseImpl(TokenIterator token, TokenIterator endToken)
{
for (; token != endToken; ++token)
processToken(*token);
if (m_state != ReadAnd && m_state != ReadRestrictor && m_state != Done)
m_querySet->addMediaQuery(MediaQuery::createNotAll());
else if (m_mediaQueryData.currentMediaQueryChanged())
m_querySet->addMediaQuery(m_mediaQueryData.takeMediaQuery());
return m_querySet;
}
std::stack<Token> PostfixExprEvaluator::eval(const Tokens &tokens,
Variables vars)
{
std::stack<Token> operands;
for (auto token : tokens)
{
processToken(token, operands, vars);
}
return operands;
}
void CSyncSource::syncServerChanges()
{
LOG(INFO) + "Sync server changes source ID :" + getID();
while( getSync().isContinueSync() )
{
setCurPageCount(0);
String strUrl = getProtocol().getServerQueryUrl("");
String strQuery = getProtocol().getServerQueryBody(getName(), getSync().getClientID(), getSync().getSyncPageSize());
if ( !m_bTokenFromDB && getToken() > 1 )
strQuery += "&token=" + convertToStringA(getToken());
LOG(INFO) + "Pull changes from server. Url: " + (strUrl+strQuery);
PROF_START("Net");
NetResponse(resp,getNet().pullData(strUrl+strQuery, &getSync()));
PROF_STOP("Net");
if ( !resp.isOK() )
{
getSync().stopSync();
m_nErrCode = RhoAppAdapter.getErrorFromResponse(resp);
m_strError = resp.getCharData();
continue;
}
const char* szData = resp.getCharData();
//const char* szData = "[{\"version\":3},{\"token\":\"\"},{\"count\":0},{\"progress_count\":28},{\"total_count\":28},{\"source-error\":{\"login-error\":{\"message\":\"s currently connected from another machine\"}}}]";
//const char* szData = "[{\"version\":3},{\"token\":\"\"},{\"count\":0},{\"progress_count\":0},{\"total_count\":0},{\"create-error\":{\"0_broken_object_id\":{\"name\":\"wrongname\",\"an_attribute\":\"error create\"},\"0_broken_object_id-error\":{\"message\":\"error create\"}}}]";
//const char* szData = "[{\"version\":3},{\"token\":\"35639160294387\"},{\"count\":3},{\"progress_count\":0},{\"total_count\":3},{\"metadata\":\"{\\\"foo\\\":\\\"bar\\\"}\",\"insert\":{\"1\":{\"price\":\"199.99\",\"brand\":\"Apple\",\"name\":\"iPhone\"}}}]";
//LOG(INFO) + szData;
PROF_START("Parse");
CJSONArrayIterator oJsonArr(szData);
PROF_STOP("Parse");
processServerResponse_ver3(oJsonArr);
if (getSync().getSourceOptions().getBoolProperty(getID(), "pass_through"))
processToken(0);
if ( getToken() == 0 )
break;
}
if ( getSync().isSchemaChanged() )
getSync().stopSync();
}
/*
Creates and parses through an input file using a tokenizer object.
Caller is responsible for opening and closing the input file.
Tokenizer object is intialized and destroyed by this function.
@param file : File object pointer to parse
@param inputname : The filename pointed to by the file pointer
*/
int parseFile(FILE* file, char* inputname)
{
TokenizerT* tk = TKCreate(file);
char* token;
token = TKGetNextToken(tk);
do{
//printf("\tCurrent token is: %s in %s \n",token, inputname);
if(token == NULL){
break;
}
processToken(token, inputname);
}while((token = TKGetNextToken(tk)) != 0);
TKDestroy(tk);
return 0;
}
//--------------------------------------------------------------
// parse a buffer
void BVHFile::parseBuffer(
const char* buffer,
int bufferLen)
{
for (int i = 0; i < bufferLen; i++)
{
char c = buffer[i];
if (isspace(c))
{
if (!m_token.isEmpty())
{
processToken(m_token);
m_token.empty();
}
if (c == '\n')
m_linenum++;
}
else if (c == '{')
{
if (!m_token.isEmpty())
{
processToken(m_token);
m_token.empty();
}
processToken("{");
}
else if (c == '{')
{
if (!m_token.isEmpty())
{
processToken(m_token);
m_token.empty();
}
processToken("}");
}
else if (c == ':')
{
m_token += c;
processToken(m_token);
m_token.empty();
}
else m_token += c;
}
}
bool Command::processParameter(const QStringList& block)
{
QString parameterLine = mergeBlockToLine(block);
// remove " :"
parameterLine = parameterLine.remove(0, 2).trimmed();
/* State: one parameter one line
* one parameter n lines
* n parameters one line
*/
// break into parameter tokens
bool lastTokenEnclosed = true;
QStringList tokens = breakIntoTokens(parameterLine, lastTokenEnclosed);
if (!lastTokenEnclosed)
{
// we need more lines of command parameters
//dbgPlugins << "ParameterLine not enclosed";
return false;
}
static int unhandledParameters = 0;
Parameter * parameter = 0;
Q_FOREACH (QString token, tokens)
{
QString paramName;
QString typeDefinition;
// determine parameter name and parameter definition
processToken(token, paramName, typeDefinition);
bool showPreviewOnChange = true;
if (typeDefinition.startsWith("_"))
{
showPreviewOnChange = false;
typeDefinition.remove(0,1);
}
if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::FLOAT_P]))
{
parameter = new FloatParameter(paramName, showPreviewOnChange);
}
else if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::INT_P]))
{
parameter = new IntParameter(paramName, showPreviewOnChange);
}
else if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::SEPARATOR_P]))
{
parameter = new SeparatorParameter(paramName, showPreviewOnChange);
}
else if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::CHOICE_P]))
{
parameter = new ChoiceParameter(paramName, showPreviewOnChange);
}
else if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::TEXT_P]))
{
parameter = new TextParameter(paramName, showPreviewOnChange);
}
else if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::NOTE_P]))
{
parameter = new NoteParameter(paramName, showPreviewOnChange);
}
else if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::LINK_P]))
{
parameter = new LinkParameter(paramName, showPreviewOnChange);
}
else if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::BOOL_P]))
{
parameter = new BoolParameter(paramName, showPreviewOnChange);
}
else if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::COLOR_P]))
{
parameter = new ColorParameter(paramName, showPreviewOnChange);
}
else if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::FOLDER_P]))
{
parameter = new FolderParameter(paramName, showPreviewOnChange);
}
else if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::FILE_P]))
{
parameter = new FileParameter(paramName, showPreviewOnChange);
}
else if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::CONST_P]))
{
parameter = new ConstParameter(paramName, showPreviewOnChange);
}
else if (typeDefinition.startsWith(Parameter::PARAMETER_NAMES[Parameter::BUTTON_P]))
{
parameter = new ButtonParameter(paramName, showPreviewOnChange);
}
else
{
unhandledParameters++;
dbgPlugins << "Unhandled parameter " << unhandledParameters << parent()->name() << "\\" << name() << paramName << typeDefinition;
}
if (parameter)
{
parameter->parseValues(typeDefinition);
m_parameters.append(parameter);
parameter = 0;
}
}
/* virtual */ SysStatus
XHandleTrans::demolish(XHandle xhandle, uval &clientData)
{
XBaseObj *xBaseObj;
ObjRef objRef;
BaseProcessRef procRef;
SysStatus rc;
SysStatusProcessID processPID;
// no lock is held, so these pointers can dissapear
// out from under us. That's why we copy and test.
// also, the xhandle may already be free, so all errors
// just lead to returning
tassertMsg(XHANDLE_IDX(xhandle) >= CObjGlobals::numReservedEntries,
"Freeing global xhandle\n");
xBaseObj = &xhandleTable[XHANDLE_IDX(xhandle)];
objRef = xBaseObj->__iobj;
processPID = xBaseObj->getOwnerProcessID();
#ifdef __NO_REGISTER_WITH_KERNEL_WRAPPER
#define REGISTER_ALWAYS 0
#else
#define REGISTER_ALWAYS 0
#endif
if (REGISTER_ALWAYS || (processPID != _KERNEL_PID)) {
// we know kernel will not go away, don't insert in process list,
// since this ProcessWrapper becomes a hot spot in file systems
rc = DREFGOBJ(TheProcessSetRef)->
getRefFromPID(xBaseObj->getOwnerProcessID(), procRef);
if (_FAILURE(rc)) {
procRef = NULL;
}
}
uval procLocked = 0;
tassertMsg(objRef, "No object in XHandleTrans::demolish\n");
rc=DREF(objRef)->publicLockExportedXObjectList();
tassertMsg(rc==0, "Can't lock in XHandleTrans::demolish\n");
if (procRef && (REGISTER_ALWAYS || (processPID != _KERNEL_PID))) {
procLocked = DREF(procRef)->lockMatchedXObjectList();
}
tassertMsg(xBaseObj->isValid(), "Object is invalid\n");
/* kill xobject so subsequent calls fail don't need a sync -
* token circulates before xobj becomes unsafe for stale
* references remove from process and object lists. Remove
* holder from lists and reset __nummeth to prevent another
* releaseAccess call (inflight) from trying to free this
* again.
*/
xBaseObj->__nummeth = 0;
if (procRef && (REGISTER_ALWAYS || (processPID != _KERNEL_PID))) {
DREF(procRef)->removeMatchedXObj(xhandle);
}
DREF(objRef)->removeExportedXObj(xhandle);
// release locks before callback
if (procLocked && (REGISTER_ALWAYS || (processPID != _KERNEL_PID))) {
DREF(procRef)->unlockMatchedXObjectList();
}
clientData = xBaseObj->getClientData();
DREF(objRef)->publicUnlockExportedXObjectList();
xBaseObj->setBeingFreed(0);
// DREF(objRef)->handleXObjFree(xhandle);
XBaseObj *removed;
// must to this after removes - same space is used for both
do {
removed = removedEntries;
xBaseObj->setNextFree(removed);
} while (!CompareAndStoreSynced((uval*)(&removedEntries),
(uval)removed, (uval)xBaseObj));
numberRemoved++; // doesn't have to be exact,
// so don't sync
if ((numberRemoved % XHANDLE_TABLE_GC_INTERVAL) == 0) processToken();
return 0;
}
/* virtual */ SysStatus
XHandleTrans::free(XHandle xhandle)
{
XBaseObj *xBaseObj;
ObjRef objRef;
BaseProcessRef procRef;
SysStatus rc;
SysStatusProcessID processPID;
// no lock is held, so these pointers can dissapear
// out from under us. That's why we copy and test.
// also, the xhandle may already be free, so all errors
// just lead to returning
tassertMsg(XHANDLE_IDX(xhandle) >= CObjGlobals::numReservedEntries,
"Freeing global xhandle\n");
xBaseObj = &xhandleTable[XHANDLE_IDX(xhandle)];
objRef = xBaseObj->__iobj;
processPID = xBaseObj->getOwnerProcessID();
#ifdef __NO_REGISTER_WITH_KERNEL_WRAPPER
if (processPID != _KERNEL_PID) {
// we know kernel will not go away, don't insert in process list,
// since this ProcessWrapper becomes a hot spot in file systems
rc = DREFGOBJ(TheProcessSetRef)->
getRefFromPID(xBaseObj->getOwnerProcessID(), procRef);
if (_FAILURE(rc)) {
tassert(!(xBaseObj->isValid()),
err_printf("PID %ld invalid in valid Xobj\n",
xBaseObj->getOwnerProcessID()));
return 0;
}
if (!procRef) return 0;
}
#else
rc = DREFGOBJ(TheProcessSetRef)->
getRefFromPID(xBaseObj->getOwnerProcessID(), procRef);
if (_FAILURE(rc)) {
tassert(!(xBaseObj->isValid()),
err_printf("PID %ld invalid in valid Xobj\n",
xBaseObj->getOwnerProcessID()));
return 0;
}
if (!procRef) return 0;
#endif
if ((!objRef)) return 0;
if ((rc=DREF(objRef)->publicLockExportedXObjectList())) return 0;
#ifdef __NO_REGISTER_WITH_KERNEL_WRAPPER
if (processPID != _KERNEL_PID) {
if ((rc=DREF(procRef)->lockMatchedXObjectList())) {
DREF(objRef)->publicUnlockExportedXObjectList();
return 0;
}
}
#else
if ((rc=DREF(procRef)->lockMatchedXObjectList())) {
DREF(objRef)->publicUnlockExportedXObjectList();
return 0;
}
#endif
//once we have the locks, the XObject state can't change out from
//under us.
if (xBaseObj->isValid()) {
/* kill xobject so subsequent calls fail don't need a sync -
* token circulates before xobj becomes unsafe for stale
* references remove from process and object lists. Remove
* holder from lists and reset __nummeth to prevent another
* releaseAccess call (inflight) from trying to free this
* again.
*/
xBaseObj->__nummeth = 0;
#ifdef __NO_REGISTER_WITH_KERNEL_WRAPPER
if (processPID != _KERNEL_PID) {
DREF(procRef)->removeMatchedXObj(xhandle);
}
#else
DREF(procRef)->removeMatchedXObj(xhandle);
#endif
DREF(objRef)->removeExportedXObj(xhandle);
// release locks before callback
#ifdef __NO_REGISTER_WITH_KERNEL_WRAPPER
if (processPID != _KERNEL_PID) {
DREF(procRef)->unlockMatchedXObjectList();
}
#else
DREF(procRef)->unlockMatchedXObjectList();
#endif
DREF(objRef)->publicUnlockExportedXObjectList();
xBaseObj->setBeingFreed(0);
DREF(objRef)->handleXObjFree(xhandle);
XBaseObj *removed;
// must to this after removes - same space is used for both
do {
removed = removedEntries;
xBaseObj->setNextFree(removed);
} while (!CompareAndStoreSynced((uval*)(&removedEntries),
(uval)removed, (uval)xBaseObj));
numberRemoved++; // doesn't have to be exact,
// so don't sync
} else {
// race - someone else freed the XObject
// release locks using original values.
#ifdef __NO_REGISTER_WITH_KERNEL_WRAPPER
if (processPID != _KERNEL_PID) {
DREF(procRef)->unlockMatchedXObjectList();
}
#else
DREF(procRef)->unlockMatchedXObjectList();
#endif
DREF(objRef)->publicUnlockExportedXObjectList();
}
if ((numberRemoved % XHANDLE_TABLE_GC_INTERVAL) == 0) processToken();
return 0;
}
/* virtual */ SysStatusXHandle
XHandleTrans::alloc(ObjRef oref, BaseProcessRef pref,
AccessRights matched, AccessRights unmatched,
COVTableEntry* vtbl, uval8 numMethods,
uval clientData)
{
SysStatus rc = 0;
XBaseObj *te;
SysStatusProcessID matchPID;
// lock the obj and process lists
// we munch the static function to be a member function so to speak
uval idx = CObjGlobals::GlobalXHandleIdx(oref);
if (idx && (matched & MetaObj::globalHandle)) {
te = &xhandleTable[idx];
} else do {
/*
* because these objects are managed with ReadCopyUpdate
* its safe to do a non-blocking pop. If the top object
* disappears, it cant re-appear will this thread completes
*/
while ((te = freeEntries)) {
XBaseObj* next;
next=te->getNextFree();
if (CompareAndStoreSynced(
(uval*)(&freeEntries), (uval)te, (uval)next)) break;
}
if (te == 0) {
// Free list is empty. See if any previous of frees can
// be completed.
processToken();
if (freeEntries == 0) {
// Free list is still empty. Allocate a new chunk of
// the table, guarded by oldEntries lock
oldEntries.acquire();
// check after getting the lock to avoid duplicate extends
if (FetchAndNop((uval*)&freeEntries) == 0) {
XBaseObj *top, *bottom, *oldFree;
uval const newLimit = xhandleTableLimit +
XHANDLE_TABLE_INCREMENT;
passertMsg(newLimit <= XHANDLE_TABLE_MAX,
"Quasi-infinite xhandle table exhausted.\n");
InitXHandleRange(xhandleTable,
xhandleTableLimit, newLimit,
top, bottom);
xhandleTableLimit = newLimit;
rc = DREFGOBJ(TheDispatcherMgrRef)->
publishXHandleTable(xhandleTable, xhandleTableLimit);
tassertMsg(_SUCCESS(rc),"publishXHandleTable failed.\n");
// must not make new entries available until limit is moved
do {
oldFree = freeEntries;
bottom->setNextFree(oldFree);
} while (!(CompareAndStoreSynced(
(uval*)(&freeEntries), (uval)oldFree, (uval)top)));
}
oldEntries.release();
}
}
} while (te == 0);
matchPID = DREF(pref)->getPID();
tassertMsg(_SUCCESS(matchPID), "bad process ref passed in alloc %lx\n",rc);
if (_FAILURE(rc = DREF(oref)->publicLockExportedXObjectList())) goto exit1;
#ifdef __NO_REGISTER_WITH_KERNEL_WRAPPER
if (matchPID != _KERNEL_PID) {
// we know kernel will not go away, don't insert in process list,
// since this ProcessWrapper becomes a hot spot in file systems
if (_FAILURE(rc = DREF(pref)->lockMatchedXObjectList())) goto exit2;
}
#else
if (_FAILURE(rc = DREF(pref)->lockMatchedXObjectList())) goto exit2;
#endif
// populate the translation entry, make sure vtable is last
// do not modify the seqNo which is incremented on free
te->__iobj = oref;
te->__matchPID = _SGETPID(matchPID);
te->__mrights = matched | MetaObj::processOnly;
te->__urights = unmatched;
te->clientData = clientData;
XHandle xhandle;
xhandle = te->getXHandle();
// add to process and object lists - can't fail, lock is held
#ifdef __NO_REGISTER_WITH_KERNEL_WRAPPER
if (matchPID != _KERNEL_PID) {
DREF(pref)->addMatchedXObj(xhandle);
}
#else
DREF(pref)->addMatchedXObj(xhandle);
#endif
DREF(oref)->addExportedXObj(xhandle);
// now stick in the vtable pointer
XBaseObj::SetFTable(te, vtbl);
// now sync and then make the xobject valid
// N.B. nummeth is valid flag
SyncBeforeRelease();
te->__nummeth = numMethods;
tassertMsg(numMethods != 0, "numMethods is 0 for xhandle 0x%lx\n", xhandle);
#ifdef __NO_REGISTER_WITH_KERNEL_WRAPPER
if (matchPID != _KERNEL_PID) {
DREF(pref)->unlockMatchedXObjectList();
}
#else
DREF(pref)->unlockMatchedXObjectList();
#endif
DREF(oref)->publicUnlockExportedXObjectList();
return xhandle;
exit2:
DREF(oref)->publicUnlockExportedXObjectList();
exit1:
// Return the entry we acquired to the removed list
// We don't put it on the free list because we want ReadCopyUpdate
// guarantees for nonblocking access to freelist.
XBaseObj *removed;
te->setBeingFreed(0); // make sure since its going
// through removed cycle
do {
removed = removedEntries;
te->setNextFree(removed);
} while (!CompareAndStoreSynced((uval*)(&removedEntries),
(uval)removed, (uval)te));
numberRemoved++; // doesn't have to be exact,
// so don't sync
return rc;
}
Result<SelfTestStatistic> SelfTest::GetStatistic(const Settings& settings) const
{
Trace trace(settings.GetLogLevel());
trace < L"SelfTest::GetStatistic";
Handle processToken(L"Process token");
if (!::OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &processToken))
{
return Error(L"OpenProcessToken");
}
trace < L"Token groups:";
auto tokenGroupsResult = _securityManager.GetTokenGroups(trace, processToken);
if (!tokenGroupsResult.HasError())
{
auto tokenGroups = tokenGroupsResult.GetResultValue();
for (auto groupsIterator = tokenGroups.begin(); groupsIterator != tokenGroups.end(); ++groupsIterator)
{
trace < groupsIterator->ToString();
}
}
auto isServiceResult = IsService(trace, processToken);
if (isServiceResult.HasError())
{
return isServiceResult.GetError();
}
trace < L"SelfTest::IsService: ";
trace << isServiceResult.GetResultValue();
auto hasAdministrativePrivilegesResult = HasAdministrativePrivileges(trace);
if (hasAdministrativePrivilegesResult.HasError())
{
return hasAdministrativePrivilegesResult.GetError();
}
trace < L"SelfTest::HasAdministrativePrivileges: ";
trace << hasAdministrativePrivilegesResult.GetResultValue();
auto hasSeAssignPrimaryTokenPrivilegeResult = HasPrivilege(trace, processToken, SE_ASSIGNPRIMARYTOKEN_NAME);
if (hasSeAssignPrimaryTokenPrivilegeResult.HasError())
{
return hasSeAssignPrimaryTokenPrivilegeResult.GetError();
}
trace < L"SelfTest::HasPrivilege(SE_ASSIGNPRIMARYTOKEN_NAME): ";
trace << hasSeAssignPrimaryTokenPrivilegeResult.GetResultValue();
auto hasSeTcbPrivilegeResult = HasPrivilege(trace, processToken, SE_TCB_NAME);
if (hasSeTcbPrivilegeResult.HasError())
{
return hasSeTcbPrivilegeResult.GetError();
}
trace < L"SelfTest::HasPrivilege(SE_TCB_NAME): ";
trace << hasSeTcbPrivilegeResult.GetResultValue();
auto integrityLevelResult = GetIntegrityLevel(trace, processToken);
if (integrityLevelResult.HasError())
{
return integrityLevelResult.GetError();
}
trace < L"SelfTest::GetIntegrityLevel: ";
trace << integrityLevelResult.GetResultValue();
return SelfTestStatistic(
isServiceResult.GetResultValue(),
hasAdministrativePrivilegesResult.GetResultValue(),
hasSeAssignPrimaryTokenPrivilegeResult.GetResultValue(),
hasSeTcbPrivilegeResult.GetResultValue(),
integrityLevelResult.GetResultValue());
}
static void
parseScript(const char * const scriptText,
struct script ** const scriptPP) {
struct script * scriptP;
unsigned int cursor; /* cursor in scriptText[] */
bool intoken; /* Cursor is inside token */
unsigned int tokenStart;
/* Position in 'scriptText' where current token starts.
Meaningless if 'intoken' is false.
*/
bool quotedToken;
/* Current token is a quoted string. Meaningless if 'intoken'
is false
*/
struct tokenSet tokenSet;
MALLOCVAR_NOFAIL(scriptP);
scriptP->commandListHeadP = NULL;
scriptP->commandListTailP = NULL;
/* A token begins with a non-whitespace character. A token ends before
a whitespace character or semicolon or end of script, except that if
the token starts with a double quote, whitespace and semicolon don't
end it and another double quote does.
Semicolon (unquoted) is a token by itself.
*/
tokenSet.count = 0;
intoken = FALSE;
tokenStart = 0;
cursor = 0;
while (scriptText[cursor] != '\0') {
char const scriptChar = scriptText[cursor];
if (intoken) {
if ((quotedToken && scriptChar == '"') ||
(!quotedToken && (isspace(scriptChar) || scriptChar == ';'))) {
/* We've passed a token. */
processToken(scriptText, cursor, tokenStart, scriptP,
&tokenSet);
intoken = FALSE;
if (scriptChar != ';')
++cursor;
} else
++cursor;
} else {
if (!isspace(scriptChar)) {
/* A token starts here */
if (scriptChar == ';')
/* It ends here too -- semicolon is token by itself */
processToken(scriptText, cursor+1, cursor, scriptP,
&tokenSet);
else {
intoken = TRUE;
quotedToken = (scriptChar == '"');
if (quotedToken)
tokenStart = cursor + 1;
else
tokenStart = cursor;
}
}
++cursor;
}
}
if (intoken) {
/* Parse the last token, which was terminated by end of string */
if (quotedToken)
pm_error("Script ends in the middle of a quoted string");
processToken(scriptText, cursor, tokenStart, scriptP, &tokenSet);
}
if (tokenSet.count > 0) {
/* Parse the last command, which was not terminated with a semicolon.
*/
disposeOfCommandTokens(&tokenSet, scriptP);
}
*scriptPP = scriptP;
}
void CSyncSource::processServerResponse_ver3(CJSONArrayIterator& oJsonArr)
{
PROF_START("Data1");
int nVersion = 0;
if ( !oJsonArr.isEnd() && oJsonArr.getCurItem().hasName("version") )
{
nVersion = oJsonArr.getCurItem().getInt("version");
oJsonArr.next();
}
if ( nVersion != getProtocol().getVersion() )
{
LOG(ERROR) + "Sync server send data with incompatible version. Client version: " + convertToStringA(getProtocol().getVersion()) +
"; Server response version: " + convertToStringA(nVersion) + ". Source name: " + getName();
getSync().stopSync();
m_nErrCode = RhoAppAdapter.ERR_SYNCVERSION;
return;
}
if ( !oJsonArr.isEnd() && oJsonArr.getCurItem().hasName("token"))
{
processToken(oJsonArr.getCurItem().getUInt64("token"));
oJsonArr.next();
}
if ( !oJsonArr.isEnd() && oJsonArr.getCurItem().hasName("source") )
{
//skip it. it uses in search only
oJsonArr.next();
}
if ( !oJsonArr.isEnd() && oJsonArr.getCurItem().hasName("count") )
{
setCurPageCount(oJsonArr.getCurItem().getInt("count"));
oJsonArr.next();
}
if ( !oJsonArr.isEnd() && oJsonArr.getCurItem().hasName("refresh_time") )
{
setRefreshTime(oJsonArr.getCurItem().getInt("refresh_time"));
oJsonArr.next();
}
if ( !oJsonArr.isEnd() && oJsonArr.getCurItem().hasName("progress_count") )
{
//TODO: progress_count
//setTotalCount(oJsonArr.getCurItem().getInt("progress_count"));
oJsonArr.next();
}
if ( !oJsonArr.isEnd() && oJsonArr.getCurItem().hasName("total_count") )
{
setTotalCount(oJsonArr.getCurItem().getInt("total_count"));
oJsonArr.next();
}
//if ( getServerObjectsCount() == 0 )
// getNotify().fireSyncNotification(this, false, RhoAppAdapter.ERR_NONE, "");
if ( getToken() == 0 )
{
//oo conflicts
getDB().executeSQL("DELETE FROM changed_values where source_id=? and sent>=3", getID() );
//
}
LOG(INFO) + "Got " + getCurPageCount() + "(Processed: " + getServerObjectsCount() + ") records of " + getTotalCount() + " from server. Source: " + getName()
+ ". Version: " + nVersion;
PROF_STOP("Data1");
if ( !oJsonArr.isEnd() && getSync().isContinueSync() )
{
CJSONEntry oCmds = oJsonArr.getCurItem();
PROF_START("Data");
//TODO: use isUIWaitDB inside processSyncCommand
// if ( getDB().isUIWaitDB() )
// {
// LOG(INFO) + "Commit transaction because of UI request.";
// getDB().endTransaction();
// getDB().startTransaction();
// }
if ( oCmds.hasName("schema-changed") )
{
getSync().setSchemaChanged(true);
}else if ( oCmds.hasName("source-error") )
{
CJSONEntry errSrc = oCmds.getEntry("source-error");
CJSONStructIterator errIter(errSrc);
for( ; !errIter.isEnd(); errIter.next() )
{
m_nErrCode = RhoAppAdapter.ERR_CUSTOMSYNCSERVER;
m_strError = errIter.getCurValue().getString("message");
m_strErrorType = errIter.getCurKey();
}
}else if ( oCmds.hasName("search-error") )
{
CJSONEntry errSrc = oCmds.getEntry("search-error");
CJSONStructIterator errIter(errSrc);
for( ; !errIter.isEnd(); errIter.next() )
{
m_nErrCode = RhoAppAdapter.ERR_CUSTOMSYNCSERVER;
m_strError = errIter.getCurValue().getString("message");
m_strErrorType = errIter.getCurKey();
}
}else if ( oCmds.hasName("create-error") )
{
m_nErrCode = RhoAppAdapter.ERR_CUSTOMSYNCSERVER;
m_strErrorType = "create-error";
}else if ( oCmds.hasName("update-error") )
{
m_nErrCode = RhoAppAdapter.ERR_CUSTOMSYNCSERVER;
m_strErrorType = "update-error";
}else if ( oCmds.hasName("delete-error") )
{
m_nErrCode = RhoAppAdapter.ERR_CUSTOMSYNCSERVER;
m_strErrorType = "delete-error";
}else
{
getDB().startTransaction();
if (getSync().getSourceOptions().getBoolProperty(getID(), "pass_through"))
{
if ( m_bSchemaSource )
getDB().executeSQL( (String("DELETE FROM ") + getName()).c_str() );
else
getDB().executeSQL("DELETE FROM object_values WHERE source_id=?", getID() );
}
if ( oCmds.hasName("metadata") && getSync().isContinueSync() )
{
String strMetadata = oCmds.getString("metadata");
getDB().executeSQL("UPDATE sources SET metadata=? WHERE source_id=?", strMetadata, getID() );
}
if ( oCmds.hasName("links") && getSync().isContinueSync() )
processSyncCommand("links", oCmds.getEntry("links") );
if ( oCmds.hasName("delete") && getSync().isContinueSync() )
processSyncCommand("delete", oCmds.getEntry("delete") );
if ( oCmds.hasName("insert") && getSync().isContinueSync() )
processSyncCommand("insert", oCmds.getEntry("insert") );
PROF_STOP("Data");
PROF_START("DB");
getDB().endTransaction();
PROF_STOP("DB");
getNotify().fireObjectsNotification();
}
}
PROF_START("Data1");
if ( getCurPageCount() > 0 )
getNotify().fireSyncNotification(this, false, RhoAppAdapter.ERR_NONE, "");
PROF_STOP("Data1");
}
/*main fonction du programme*/
int main()
{
char input = '\0';
char flag = ' ';
char erreur = '\0';
/*erreur est une variable qui enregistre un code d'erreur sur la lecture ou l'execution d'une ligne
'\0' -> pas d'erreur
'i' -> lecture d'un caractere inconnu
'c' -> lecture d'un charactere inattandu
'm' -> erreur d'allocation mémoire
'o' -> operateur non-attendu
'd' -> digit inattendu
'p' -> erreur de pile
'u' -> variable non-définie
'f' -> Erreur fatale
*/
num* buffer = makeNumber();
stack* stk = createStack();
num* variables[26];
if(buffer == NULL || stk == NULL || variables == NULL)
erreur = 'f';
int i;
for(i = 0; i < 26; i++){
variables[i] = NULL;
}
//boucle tant que l'utilisateur de quitte pas avec la commande ';' (ou ctrl-c)
while (input != ';'){
putchar('>');
//boucle sur l'entrée
while ((erreur == '\0') && ((input = getchar()) != '\n') && (input != ';') ){
switch (identify(input)){
case ' ':
erreur = processToken(buffer,flag,stk);
if((buffer = makeNumber()) == NULL)
erreur = 'm';
break;
case '=':
//detection d'erreur syntaxique
if (flag != ' '){
erreur = 'o';
break;
}
//code execution ...
//printf("symbole =");
//gestion du =
break;
case '+':
//detection d'erreur syntaxique
if (flag != ' '){
erreur = 'o';
break;
}
//code execution ...
//printf("symbole +");
//gestion du +
break;
case '-':
//detection d'erreur syntaxique
if (flag != ' '){
erreur = 'o';
break;
}
//code execution ...
//printf("symbole -");
//gestion du -
break;
case '*':
//detection d'erreur syntaxique
if (flag != ' '){
erreur = 'o';
}
//code execution ...
//printf("symbole *");
//gestion du *
break;
case '.':
if(flag != ' '){
erreur = 'o';
}
break;
case ':':
if(flag != ' '){
erreur = 'o';
}
break;
case 'c':
//detection d'erreur syntaxique
if ((flag != ' ') && (flag != '=')){
erreur = 'c';
break;
}
//code execution ...
//printf("variable :\n");
//putchar(input);
//gestion d'un char
if(flag == '='){
char next = getchar();
if(next != ' ' && next != '\n' ){
//code d'erreur approprié
switch(identify(next)){
case 'c':
erreur = 'c';
break;
case 'i':
erreur = 'd';
break;
default:
erreur = 'o';
break;
}
break;
}
else {
//assignation
num* old_value = variables[(int) input - 'a'];
if(old_value != NULL){
old_value->refs--;
killOrLetLive(old_value);
}
variables[(int) input - 'a'] = stk->top->number;
stk->top->number->refs++;
}
input = next;
}
else if(flag == ' '){
if (variables[input - 'a'] != NULL){
push(variables[input - 'a'], stk);
variables[input - 'a']->refs++;
}
else {
erreur = 'u';
}
}
break;
case 'i':
//detection d'erreur syntaxique
if ((flag != ' ') && (flag != 'i')){
erreur = 'd';
break;
}
//code execution ...
//printf("digit :\n");
//putchar(input);
//gestion d'un digit
erreur = addDigitRight(buffer, (int) input - '0');
break;
case 'e':
erreur = 'c';
default:
break;
}
if(input == '\n')
break;
flag = identify(input);
}//fin du while de lecture de ligne
if (erreur != '\0')
while (getchar() != '\n');//vide le input
else
erreur = processToken(buffer,flag,stk);
if((buffer = makeNumber()) == NULL)
erreur = 'm';
switch(erreur){
case 'i':
printf("Erreur : caractere non reconnu");
break;
case 'c':
printf("Erreur : catactere non-attendu");
break;
case 'm':
printf("Erreur : Memoire");
break;
case 'o':
printf("Erreur : operateur non-attendu");
break;
case 'd':
printf("Erreur : digit non-attendu");
break;
case 'p':
printf("Erreur de pile");
break;
case 'u':
printf("Erreur: variable non-définie.");
break;
case 'n':
printf("Erreur: problème de construction d'un nombre.");
case 'f':
printf("Erreur fatale: impossible de continuer. Veuillez Quitter.");
break;
case '\0':
default:
break;
}
putchar('\n');
if(erreur != 'f')
erreur = '\0';
flag = ' ';
printStack(stk);
putchar('\n');
//Output result & error code
}
printf("done\n");
return 0;
}
void CSyncSource::processServerData(const char* szData)
{
PROF_START("Parse");
CJSONArrayIterator oJsonArr(szData);
PROF_STOP("Parse");
PROF_START("Data1");
if ( !oJsonArr.isEnd() && oJsonArr.getCurItem().hasName("error") )
{
m_strError = oJsonArr.getCurItem().getString("error");
m_nErrCode = RhoRuby.ERR_CUSTOMSYNCSERVER;
getSync().stopSync();
return;
}
if ( !oJsonArr.isEnd() )
{
setCurPageCount(oJsonArr.getCurItem().getInt("count"));
oJsonArr.next();
}
int nVersion = 0;
if ( !oJsonArr.isEnd() && oJsonArr.getCurItem().hasName("version") )
{
nVersion = oJsonArr.getCurItem().getInt("version");
oJsonArr.next();
}
if ( nVersion != getSync().SYNC_VERSION() )
{
LOG(ERROR) + "Sync server send data with incompatible version. Client version: " + convertToStringA(getSync().SYNC_VERSION()) +
"; Server response version: " + convertToStringA(nVersion) + ". Source name: " + getName();
getSync().stopSync();
m_nErrCode = RhoRuby.ERR_SYNCVERSION;
return;
}
if ( !oJsonArr.isEnd() && oJsonArr.getCurItem().hasName("rt") )
{
setRefreshTime(oJsonArr.getCurItem().getInt("rt"));
oJsonArr.next();
}
if ( !oJsonArr.isEnd() && oJsonArr.getCurItem().hasName("total_count") )
{
setTotalCount(oJsonArr.getCurItem().getInt("total_count"));
oJsonArr.next();
}
//if ( getServerObjectsCount() == 0 )
// getNotify().fireSyncNotification(this, false, RhoRuby.ERR_NONE, "");
if ( !oJsonArr.isEnd() )
{
processToken(oJsonArr.getCurItem().getUInt64("token"));
oJsonArr.next();
}else if ( getCurPageCount() == 0 )
{
//oo conflicts
getDB().executeSQL("DELETE FROM changed_values where source_id=? and sent>=3", getID() );
//
processToken(0);
}
LOG(INFO) + "Got " + getCurPageCount() + "(Processed: " + getServerObjectsCount() + ") records of " + getTotalCount() + " from server. Source: " + getName()
+ ". Version: " + nVersion;
PROF_STOP("Data1");
if ( !oJsonArr.isEnd() && getSync().isContinueSync() )
{
PROF_START("Data");
//TODO: support DBExceptions
getDB().startTransaction();
int nSavedPos = oJsonArr.getCurPos();
setSyncServerDataPass(edpNone);
processServerData_Ver1(oJsonArr);
setSyncServerDataPass(edpDeleteObjects);
oJsonArr.reset(nSavedPos);
processServerData_Ver1(oJsonArr);
PROF_STOP("Data");
PROF_START("DB");
getDB().endTransaction();
PROF_STOP("DB");
getNotify().fireObjectsNotification();
}
PROF_START("Data1");
if ( getCurPageCount() > 0 )
getNotify().fireSyncNotification(this, false, RhoRuby.ERR_NONE, "");
PROF_STOP("Data1");
}
void CPBSAnalysis::processToken(TRSessionManager *sess, CTRAnalise*an, CTRToken *tk, CPBSSink* pbssink, std::map<short, int> &onts_doc, char * _textChunck, int offset) {
if (!tk)
return;
if (tk->obtemTipo() & TK_CONTR_P1) {
if (tk->obtemTokenLocucao())
processSepToken(sess, tk, tk->obtemTokenLocucao(), pbssink, _textChunck, offset);
// obtem o pr�ximo token da locu��o e trata
processToken(sess, an, (CTRToken*)tk->obtemTokenLocucao(), pbssink, onts_doc, _textChunck, offset);
return;
}
unsigned char doms[255], n_doms = 255, n_onts = 255;
unsigned short onts[255];
// Primeiro colocar a locu��o ou token
char* token = (char *)alloca(tk->obtemLen() + 1);
strncpy(token, _textChunck + tk->obtemPosInicial(), tk->obtemLen());
token[tk->obtemLen()] = '\0';
std::string word = token;
pbssink->PutToken(word, tk->obtemLen(), tk->obtemPosInicial() + offset, getTokenKind(tk));
OpenSemTag *tagloc = sess->obtemOSCData()->checkToken(tk);
if (tagloc) {
std::string name = tagloc->getName();
std::string value = tagloc->getValue(an, tk);
pbssink->PutFeature(name, value);
}
OpenSemTag *tag;
if ((tag = sess->obtemOSCData()->getTagLemma()) != NULL && tag->checkToken(tk)) {
std::string name = tag->getName();
std::string value = tag->getValue(an, tk);
pbssink->PutFeature(name, value);
}
if ((tag = sess->obtemOSCData()->getTagHead()) != NULL && tag->checkToken(tk)) {
std::string name = tag->getName();
std::string value = tag->getValue(an, tk);
pbssink->PutFeature(name, value);
}
if ((tag = sess->obtemOSCData()->getTagMrcat()) != NULL && tag->checkToken(tk)) {
std::string name = tag->getName();
std::string value = tag->getValue(an, tk);
pbssink->PutFeature(name, value);
}
if ((tag = sess->obtemOSCData()->getTagFullcat()) != NULL && tag->checkToken(tk)) {
std::string name = tag->getName();
std::string value = tag->getValue(an, tk);
pbssink->PutFeature(name, value);
}
if (sess->obtemOSCData()->getTagOnt1() || sess->obtemOSCData()->getTagOnt1Raw()) {
tk->obtemInfoOnt(an->obtemTRExec(), doms, n_doms, onts, NULL, n_onts);
std::map<short, int>::iterator itr;
for (int i = 0; i < n_onts; i++) {
if ((itr = onts_doc.find(onts[i])) != onts_doc.end())
itr->second++;
else
onts_doc.insert(std::pair<short, int>(onts[i], 1));
char stont[200];
if (sess->obtemOSCData()->getTagOnt1()) {
unsigned char id_nivel1, id_nivel2, id_nivel3, id_nivel4;
char* descs[4];
CTROntDataNos* nos_ont = an->obtemTRData()->obtemTROntData()->obtemTROntDataNos();
nos_ont->obtemNiveis(onts[i], id_nivel1, id_nivel2, id_nivel3, id_nivel4);
nos_ont->obtemDescricoesNiveis(descs, id_nivel1, id_nivel2, id_nivel3, id_nivel4);
sprintf(stont, "%d.%d.%d.%d - %s / %s / %s / %s", id_nivel1 + 1, id_nivel2 + 1, id_nivel3 + 1, id_nivel4 + 1, descs[0], descs[1], descs[2], descs[3]);
std::string name = sess->obtemOSCData()->getTagOnt1()->getName();
std::string value = stont;
pbssink->PutFeature(name, value);
}
if (sess->obtemOSCData()->getTagOnt1Raw()) {
unsigned char id_nivel1, id_nivel2, id_nivel3, id_nivel4;
CTROntDataNos* nos_ont = an->obtemTRData()->obtemTROntData()->obtemTROntDataNos();
nos_ont->obtemNiveis(onts[i], id_nivel1, id_nivel2, id_nivel3, id_nivel4);
sprintf(stont, "%02d.%02d.%02d.%02d", id_nivel1 + 1, id_nivel2 + 1, id_nivel3 + 1, id_nivel4 + 1);
std::string name = sess->obtemOSCData()->getTagOnt1Raw()->getName();
std::string value = stont;
pbssink->PutFeature(name, value);
}
}
}
std::string name = "pbt.endfeatures";
std::string value = "";
pbssink->PutFeature(name, value);
if (tk->obtemTokenLocucao())
processSepToken(sess, tk, tk->obtemTokenLocucao(), pbssink, _textChunck, offset);
// obtem o pr�ximo token da locu��o e trata
processToken(sess, an, (CTRToken*)tk->obtemTokenLocucao(), pbssink, onts_doc, _textChunck, offset);
}
