void Insert (Item X, int position, List *L) { ListNode *p, *q; assert(position >= 0); assert(position <= L->size); L->size++; q=(ListNode *)malloc(sizeof(ListNode)); copyItem(&q->item,X); if(position==0) { q->next=L->first; L->first=q; } else { p=moveTo(position-1,L); q->next=p->next; p->next=q; } assert(Empty(L) == 0); assert(Size(L) == L->size); Peek(position, L, &X); assert(strcmp(q->item.name, X.name) == 0); assert(q->item.grade == X.grade); }
size_t BufferedTransformation::Peek(byte &outByte) const { if (AttachedTransformation()) return AttachedTransformation()->Peek(outByte); else return Peek(&outByte, 1); }
nsresult nsScanner::ReadUntil(nsScannerSharedSubstring& aString, const nsReadEndCondition& aEndCondition, PRBool addTerminal) { if (!mSlidingBuffer) { return kEOF; } nsScannerIterator origin, current; const PRUnichar* setstart = aEndCondition.mChars; const PRUnichar* setcurrent; origin = mCurrentPosition; current = origin; PRUnichar theChar=0; nsresult result=Peek(theChar); if (NS_FAILED(result)) { return result; } while (current != mEndPosition) { theChar = *current; if (theChar == '\0') { ReplaceCharacter(current, sInvalid); theChar = sInvalid; } // Filter out completely wrong characters // Check if all bits are in the required area if(!(theChar & aEndCondition.mFilter)) { // They were. Do a thorough check. setcurrent = setstart; while (*setcurrent) { if (*setcurrent == theChar) { if(addTerminal) ++current; AppendUnicodeTo(origin, current, aString); SetPosition(current); //DoErrTest(aString); return NS_OK; } ++setcurrent; } } ++current; } // If we are here, we didn't find any terminator in the string and // current = mEndPosition SetPosition(current); AppendUnicodeTo(origin, current, aString); return FillBuffer(); }
/** * Consume characters until you run into space, a '<', a '>', or a '/'. * * @param aString - receives new data from stream * @return error code */ nsresult nsScanner::ReadTagIdentifier(nsScannerSharedSubstring& aString) { if (!mSlidingBuffer) { return kEOF; } PRUnichar theChar=0; nsresult result=Peek(theChar); nsScannerIterator current, end; PRBool found=PR_FALSE; current = mCurrentPosition; end = mEndPosition; // Loop until we find an illegal character. Everything is then appended // later. while(current != end && !found) { theChar=*current; switch(theChar) { case '\n': case '\r': case ' ' : case '\t': case '\v': case '\f': case '<': case '>': case '/': found = PR_TRUE; break; case '\0': ReplaceCharacter(current, sInvalid); break; default: break; } if (!found) { ++current; } } // Don't bother appending nothing. if (current != mCurrentPosition) { AppendUnicodeTo(mCurrentPosition, current, aString); } SetPosition(current); if (current == end) { result = FillBuffer(); } //DoErrTest(aString); return result; }
int BuildSignatureDatabaseSearchMachine(signature_db* SignatureDatabase) { if (!SignatureDatabase) return -1; if (!SignatureDatabase->Trie && BuildSignatureDatabaseTrie(SignatureDatabase) != 0) return -1; InitializeSearchMachine(SignatureDatabase->SearchMachine, SignatureDatabase->Trie); search_machine* SM = SignatureDatabase->SearchMachine; // Phase 2 queue* Queue = xcalloc(1, sizeof(queue)); InitializeQueue(Queue); for (size_t AlphabetIndex = 0; AlphabetIndex < UNIT_CARDINALITY; ++AlphabetIndex) { trie* Node = SM->Goto[ROOT_IDENTIFIER][AlphabetIndex]; //if (Node && Node->Identifier != ROOT_IDENTIFIER) if (!Node || Node->Identifier != ROOT_IDENTIFIER) { SM->Fail[Node->Identifier] = SM->Trie; Enqueue(Queue, Node); } } while (Peek(Queue) != NULL) { trie* R = Dequeue(Queue); for (size_t AlphabetIndex = 0; AlphabetIndex < UNIT_CARDINALITY; ++AlphabetIndex) { trie* S = SM->Goto[R->Identifier][AlphabetIndex]; // Not 100% about this if (S) { Enqueue(Queue, S); trie* ST = SM->Fail[R->Identifier]; // Not 100% about this while (!SM->Goto[ST->Identifier][AlphabetIndex]) { ST = SM->Fail[ST->Identifier]; } SM->Fail[S->Identifier] = SM->Goto[ST->Identifier][AlphabetIndex]; // out(u) = out(u) UNION out(fail(u)) SM->Out[S->Identifier] = UniqExtendList(SM->Out[S->Identifier], SM->Out[SM->Fail[S->Identifier]->Identifier]); } } } FreeQueue(Queue); Queue = NULL; return 0; }
/** * Scan an AtKeyword token. Also handles production of Symbol when * an '@' is not followed by an identifier. */ bool nsCSSScanner::ScanAtKeyword(nsCSSToken& aToken) { MOZ_ASSERT(Peek() == '@', "should not have been called"); // Fall back for when '@' isn't followed by an identifier. aToken.mSymbol = '@'; Advance(); int32_t ch = Peek(); if (StartsIdent(ch, Peek(1))) { if (GatherText(IS_IDCHAR, aToken.mIdent)) { aToken.mType = eCSSToken_AtKeyword; } } return true; }
static void showListContent (List *L) { int i; Student S; for(i=0;i<Size(L);i++) { Peek(i,L,&S); printf("\t%s %d%%\n",NameOfStudent(S),GradeOfStudent(S)); FreeStudent(&S); } }
// <bool_term> ::= <bool_not_factor> [<and_op> <bool_not_factor]* void Term(CPU *cpu, Files file){ NotFactor(cpu, file); while(Peek("&&", file)){ Match("&&", file); NotFactor(cpu, file); cpu->PopValue(); cpu->BooleanAnd(); } }
// <bool_expression> ::= <bool_term> [<or_op> <bool_term]* void Expression(CPU *cpu, Files file){ Term(cpu, file); while(Peek("||", file)){ Match("||", file); Term(cpu, file); cpu->PopValue(); cpu->BooleanOr(); } }
const Token *TokenStream::PeekIf(const TokenTypeSet &typeSet) const { const Token *token = Peek(); if (typeSet.Contains(token->GetTokenType())) { return token; } return nullptr; }
const Token *TokenStream::PeekIf(Token::TokenType type) const { const Token *token = Peek(); if (token->GetTokenType() == type) { return token; } return nullptr; }
bool Tokenizer::CondRead(SYMBOL kind) { const Token* T = Peek(); if (T->kind() == kind) { Get( ); return true; } else { return false; } }
double basisfield::PeekWide(int i, int j, int k, FieldIndex fi) { if (!(i<0 || j<0 || k<0 || static_cast<unsigned int>(i)>=FieldSz_x() || static_cast<unsigned int>(j)>=FieldSz_y() || static_cast<unsigned int>(k)>=FieldSz_z())) { // Inside "valid" FOV return(Peek(static_cast<unsigned int>(i),static_cast<unsigned int>(j),static_cast<unsigned int>(k),fi)); } else { return(peek_outside_fov(i,j,k,fi)); } }
bool Compare(BufferedLineReader &other) { if (Peek(0) != other.Peek(0)) { return false; } Skip(1); other.Skip(1); return true; }
int LuaBinding::ActorPhysicsSetVelocity() { int actorId = 0; Vector2f velocity; if (!Peek(1, &actorId) || !Peek(2, &velocity)) { return ERROR_TYPE_PARAMETER; } const boost::shared_ptr<ActorPropertyPhysics> property = LuaBinding::GetActorProperty<ActorPropertyPhysics>(actorId); if (!property) { return ERROR_TYPE_STATE; } property->SetVelocity(velocity); return 0; }
int LuaBinding::ActorSetPosition() { int actorId = 0; Vector2i position; if (!Peek(1, &actorId) || !Peek(2, &position)) { return ERROR_TYPE_PARAMETER; } const boost::shared_ptr<Actor> actor = GetActor(actorId); if (!actor) { return ERROR_TYPE_STATE; } actor->SetPosition(position); return 0; }
int LuaBinding::ActorSetLayer() { int actorId = 0; int actorLayer = ACTOR_LAYER_COUNT; if (!Peek(1, &actorId) || !Peek(2, &actorLayer) || actorLayer >= ACTOR_LAYER_COUNT) { return ERROR_TYPE_PARAMETER; } const boost::shared_ptr<Actor> actor = GetActor(actorId); if (!actor) { return ERROR_TYPE_STATE; } actor->SetLayer(static_cast<ActorLayer>(actorLayer)); return 0; }
int LuaBinding::ActorIsShapeEnabled() { int actorId = 0; int actorShapeType = ACTOR_SHAPE_TYPE_COUNT; if (!Peek(1, &actorId) || !Peek(2, &actorShapeType) || actorShapeType >= ACTOR_SHAPE_TYPE_COUNT) { return ERROR_TYPE_PARAMETER; } const boost::shared_ptr<Actor> actor = GetActor(actorId); if (!actor) { return ERROR_TYPE_STATE; } Push(actor->IsShapeEnabled(static_cast<ActorShapeType>(actorShapeType))); return 1; }
int LuaBinding::ActorHasProperty() { int actorId = 0; int actorPropertyType = ACTOR_PROPERTY_TYPE_COUNT; if (!Peek(1, &actorId) || !Peek(2, &actorPropertyType) || actorPropertyType >= ACTOR_PROPERTY_TYPE_COUNT) { return ERROR_TYPE_PARAMETER; } const boost::shared_ptr<Actor> actor = GetActor(actorId); if (!actor) { return ERROR_TYPE_STATE; } Push(actor->HasProperty(static_cast<ActorPropertyType>(actorPropertyType))); return 1; }
void Parser::assignments(MethodGenerationContext* mgenc, list<StdString>& l) { if (symIsIdentifier()) { l.push_back(assignment(mgenc)); Peek(); if (nextSym == Assign) assignments(mgenc, l); } }
/***************************************************************************** * GetLine: Internal function used to dup a line of string from the buffer *****************************************************************************/ static char* GetLine( demux_t *p_demux, int *p_pos ) { demux_sys_t *p_sys = p_demux->p_sys; const uint8_t *p_buf; int i_size; int i; char *p_line; while( *p_pos >= p_sys->i_data_peeked ) { if( ! Peek( p_demux, false ) ) { return NULL; } } p_buf = p_sys->p_peek + *p_pos; i_size = p_sys->i_data_peeked - *p_pos; i = 0; while( p_buf[i] != '\n' ) { i++; if( i == i_size ) { if( ! Peek( p_demux, false ) ) { return NULL; } p_buf = p_sys->p_peek + *p_pos; i_size = p_sys->i_data_peeked - *p_pos; } } *p_pos += ( i + 1 ); if( i > 0 && '\r' == p_buf[i - 1] ) { i--; } p_line = malloc( i + 1 ); if( p_line == NULL ) return NULL; strncpy ( p_line, (char*)p_buf, i ); p_line[i] = '\0'; // msg_Dbg( p_demux, "i = %d, pos = %d, %s", i, *p_pos, p_line ); return p_line; }
ExecutionLexer::Token ExecutionLexer::PullSql() { int start = pos; do { int c = Take(); if (c < 0) { return Token(Token::SQL, start, pos - start); } // note that dollar-quoting takes priority over *everything* (except end of input of course) if (c == '$') PassDollarQuote(); else if (quoteStack.empty()) { if (c == '\'') PassSingleQuotedString(false); // FIXME handle E'...' flag for escape syntax else if (c == '\"') PassDoubleQuotedString(); else if (c == ';') { // inclusive end character int end = ++pos; PassWhitespace(); return Token(Token::SQL, start, end - start); } else if (c == '-') { if (Peek() == '-') { PassSingleLineComment(); } } else if (c == '/') { if (Peek() == '*') { PassBlockComment(); } } else if (c == '\\') { // exclusive end character BackUp(); return Token(Token::SQL, start, pos - start); } } } while (true); }
void ParseScopedName() { if(Token==TOK_SCOPE && (Peek()==TOK_NAME || Peek()==TOK_TYPE)) { Match(); Match(); } else if(Token==TOK_NAME || Token==TOK_TYPE) Match(); while(Token==TOK_SCOPE) { Match(); if(Token==TOK_NAME || Token==TOK_TYPE) Match(); else Error("scoped name error"); } }
int LuaBinding::ActorSetShape() { int actorId = 0; int actorShapeType = ACTOR_SHAPE_TYPE_COUNT; ActorShape actorShape; if (!Peek(1, &actorId) || !Peek(2, &actorShapeType) || !Peek(3, &actorShape) || actorShapeType >= ACTOR_SHAPE_TYPE_COUNT) { return ERROR_TYPE_PARAMETER; } const boost::shared_ptr<Actor> actor = GetActor(actorId); if (!actor) { return ERROR_TYPE_STATE; } actor->SetShape(static_cast<ActorShapeType>(actorShapeType), actorShape); return 1; }
bool BufferedTransformation::AnyRetrievable() const { if (AttachedTransformation()) return AttachedTransformation()->AnyRetrievable(); else { byte b; return Peek(b) != 0; } }
/* * Function TakeOff * * Takes the instantiated drone struct and adds it to the takeoff_queue. * After that it waits to take off and updates the state to inflight. * * Drone *d: current drone struct. */ void TakeOff(Drone *d) { Enqueue(d->q, d); set_drone_state(d, TAKEOFF_QUEUE); Drone *e = Peek(d->q); while (strcmp(d->drone_id, e->drone_id) != 0) { printf("%s: %s \n", d->drone_id, get_drone_state(d)); e = Peek(d->q); sleep(QUEUE_SLEEP); } set_drone_state(d, TAKING_OFF); int i = TAKEOFF_TIME; while(i > 0) { printf("%s: %s - %d \n", d->drone_id, get_drone_state(d), i); i--; sleep(1); } Dequeue(d->q); set_drone_state(d, IN_FLIGHT); }
bool GenericXMLParser::ParseTag(String &tag, Anything &tagAttributes) { StartTrace(GenericXMLParser.ParseTag); tag = ParseName(); Trace("tag = " << tag); while (!IsEof()) { SkipWhitespace(); int c = Peek(); switch (c) { case '>': // done with tag c = Get(); return true;//lint !e438 case '/': // an empty tag? i.e. <br /> c = Get(); if ('>' == Peek()) { c = Get(); return false;//lint !e438 } // an error occured, ignore '/' silently PutBack(c); default: {//lint !e616 String name; String value; if (ParseAttribute(name, value)) { tagAttributes[name] = value; } else { // non-well formed XML...no value given if (name.Length() > 0) { tagAttributes.Append(name); } else { String msg("Unexpected character <"); c = Get(); msg.AppendAsHex((unsigned char)c).Append("> near ").Append(tag); Error(msg); tagAttributes.Append(String(char(c))); } } } } } Error("unexpected EOF in Tag"); return false; // no body to expect }
void _READ_STRING(unsigned char* &MEM) { aint DLUG=0; astr DAT_S=""; DLUG=Peek(MEM); MEM++; // DLUG=Peek(MEM) : Inc MEM DAT_S=Peek_S(MEM,DLUG); // DAT$=Peek$(MEM,DLUG) MEM+=DLUG; // Add MEM,DLUG // Return Param_S=DAT_S; // }
bool CAccountConnector::__AnalyzeVarSizePacket(UINT uHeader, bool (CAccountConnector::*pfnDispatchPacket)(int)) { BYTE bHeader; if (!Peek(sizeof(bHeader), &bHeader)) return true; if (bHeader!=uHeader) return true; TDynamicSizePacketHeader dynamicHeader; if (!Peek(sizeof(dynamicHeader), &dynamicHeader)) return true; if (!Peek(dynamicHeader.size)) return true; return (this->*pfnDispatchPacket)(dynamicHeader.size); }
/***************************************************************************** * GetLine: Internal function used to dup a line of string from the buffer *****************************************************************************/ static char* GetLine( demux_t *p_demux, int *p_pos ) { demux_sys_t *p_sys = p_demux->p_sys; const uint8_t *p_buf; int i_size; int i; char *p_line; while( *p_pos >= p_sys->i_data_peeked ) { if( ! Peek( p_demux, false ) ) { return NULL; } } p_buf = p_sys->p_peek + *p_pos; i_size = p_sys->i_data_peeked - *p_pos; i = 0; while( p_buf[i] != '\n' ) { i++; if( i == i_size ) { if( ! Peek( p_demux, false ) ) { return NULL; } p_buf = p_sys->p_peek + *p_pos; i_size = p_sys->i_data_peeked - *p_pos; } } *p_pos += i + 1; if( i > 0 && p_buf[i - 1] == '\r' ) { i--; } p_line = (char *)malloc( i + 1 ); // sunqueen modify if( unlikely( p_line == NULL ) ) return NULL; strncpy ( p_line, (char*)p_buf, i ); p_line[i] = '\0'; return p_line; }