Beispiel #1
0
// peekToken performs lookahead of the given count on the token stream.
func (l *peekableLexer) peekToken(count int) lexeme {
	if count < 1 {
		panic(fmt.Sprintf("Expected count > 1, received: %v", count))
	}

	// Ensure that the readTokens has at least the requested number of tokens.
	if l.readTokens.Len() < count {
		for {
			l.readTokens.PushBack(l.lex.nextToken())

			if l.readTokens.Len() == count {
				break
			}
		}
	}

	// Retrieve the count-th token from the list.
	var element *list.Element
	element = l.readTokens.Front()

	for i := 1; i < count; i++ {
		element = element.Next()
	}

	return element.Value.(lexeme)
}
Beispiel #2
0
// listen is run in a goroutine. It reads new pull lists from its
// input queue until the queue is closed.
// listen takes ownership of the list that is passed to it.
//
// Note that the routine does not ever need to access the list
// itself once the current_item has been initialized, so we do
// not bother to keep a pointer to the list. Because it is a
// doubly linked list, holding on to the current item will keep
// it from garbage collection.
//
func (b *WorkQueue) listen() {
	var current_item *list.Element

	// When we're done, close the output channel to shut down any
	// workers.
	defer close(b.NextItem)

	for {
		// If the current list is empty, wait for a new list before
		// even checking if workers are ready.
		if current_item == nil {
			if p, ok := <-b.newlist; ok {
				current_item = p.Front()
			} else {
				// The channel was closed; shut down.
				return
			}
		}
		select {
		case p, ok := <-b.newlist:
			if ok {
				current_item = p.Front()
			} else {
				// The input channel is closed; time to shut down
				return
			}
		case b.NextItem <- current_item.Value:
			current_item = current_item.Next()
		}
	}
}
Beispiel #3
0
// SetAsync 设置是否异步输出,仅当之前为非异步并且设置为异步时,logList和mu有效
func (this *SimpleLogWriter) SetAsync(async bool, logList *list.List, mu *sync.Mutex) {
	if !this.async && async {
		if logList == nil || mu == nil {
			panic(ErrorLogWriterInvalidParam)
		}
		this.logList = logList
		this.logmu = mu
		go func() {
			var counter = atomic.AddInt32(&this.counter, 1)
			for this.async && counter == this.counter && !this.closed {
				if this.logList.Len() > 0 {
					var start *list.Element
					var length = 0
					this.logmu.Lock()
					if this.logList.Len() > 0 {
						start = this.logList.Front()
						length = this.logList.Len()
						this.logList.Init()
					}
					this.logmu.Unlock()
					for i := 0; i < length; i++ {
						var v, ok = start.Value.(string)
						if ok {
							this.writer.Write(v)
						}
						start = start.Next()
					}
				} else {
					time.Sleep(50 * time.Millisecond)
				}
			}
		}()
	}
	this.async = async
}
Beispiel #4
0
// this time eviction is called by a scheduler for background, periodic evictions
func TimeEvict(lru *LRUCache, now time.Time, ttl time.Duration) {
	lru.mu.Lock()
	defer lru.mu.Unlock()

	if lru.list.Len() < 1 {
		return
	}

	var n *entry
	var el *list.Element
	hasEvictCallback := lru.EvictCallback != nil

	el = lru.list.Back()

	for {
		if el == nil {
			break
		}
		n = el.Value.(*entry)
		if now.Sub(n.time_accessed) > ttl {
			// the Difference is greater than max TTL so we need to evict this entry
			// first grab the next entry (as this is about to dissappear)
			el = el.Prev()
			lru.remove(n.key)
			if hasEvictCallback {
				lru.EvictCallback(n.key, n.value)
			}
		} else {
			// since they are stored in time order, as soon as we find
			// first item newer than ttl window, we are safe to bail
			break
		}
	}
	lru.last_ttl_check = time.Now()
}
Beispiel #5
0
// AsyncWrite 异步写入日志
func (this *ConsoleLogWriter) AsyncWrite(logList *list.List, mu *sync.Mutex) {
	this.logList = logList
	this.logmu = mu
	go func() {
		for !this.closed {
			if this.logList.Len() > 0 {
				var start *list.Element
				var length = 0
				this.logmu.Lock()
				start = this.logList.Front()
				length = this.logList.Len()
				this.logList.Init()
				this.logmu.Unlock()
				for i := 0; i < length; i++ {
					var v, ok = start.Value.(string)
					if ok {
						this.Write(v)
					}
					start = start.Next()
				}
			} else {
				//暂停15毫秒
				time.Sleep(15 * time.Millisecond)
				//runtime.Gosched()
			}
		}
	}()
}
Beispiel #6
0
func (c *Cache) cleaner(limit int) {
	for _ = range c.clean {
		var item *list.Element
		for {
			c.lock.Lock() // X1+
			if len(c.m) < limit {
				c.lock.Unlock() // X1-
				break
			}

			if item == nil {
				item = c.lru.Front()
			}
			if p := item.Value.(*cachepage); !p.dirty {
				delete(c.m, p.pi)
				c.lru.Remove(item)
				c.Purge++
			}
			item = item.Next()
			c.lock.Unlock() // X1-
		}
		atomic.AddInt32(&c.cleaning, -1)
	}
	c.close <- true
}
func listXmpl() {
	fmt.Println("Teste Liste")
	myList := list.New()
	// einige Elemente einfügen
	myList.PushFront(element2{"a", 1})
	myList.PushFront(element2{"b", 2})
	myList.PushFront(element2{"c", 3})
	myList.PushFront(element2{"d", 4})
	myList.PushFront(element2{"e", 5})
	myList.PushFront(element2{"f", 6})

	for e := myList.Front(); e != nil; e = e.Next() {
		fmt.Println(e.Value)
	}

	// Ein Element umsortieren
	fmt.Println("Gehe zum zweiten Element")
	// erstmal den Anfang holen
	var e *list.Element = myList.Front()
	// einen Schritt weiter, zum e gehen
	e = e.Next()
	// Ausgeben zum Test
	fmt.Println("aktuell:", e.Value)
	fmt.Println("Verschiebe Element ans Listenende")
	// und e/5 ans Ende verbannen
	myList.MoveToBack(e)

	// nochmal mittels Iterator Elemente auslesen
	for e := myList.Front(); e != nil; e = e.Next() {
		fmt.Println(e.Value)
	}

}
Beispiel #8
0
// Returns the item after e or nil it is the last item or nil.
// The item is a *list.Element from the 'container/list' package.
// Even though it is possible to call e.Next() directly, don't. This behavior
// may not be supported moving forward.
func (q Queue) Next(e *list.Element) *list.Element {
	if e == nil {
		return e
	}

	return e.Next()
}
Beispiel #9
0
func TestInsertBefore(t *testing.T) {
	var e *list.Element
	l := list.New()

	for i := 0; i < 5; i++ {
		if i == 3 {
			e = l.PushFront(i)
		} else {
			l.PushFront(i)
		}
	}

	l.InsertBefore(5, e)

	if l.Len() != 6 {
		t.Errorf("length = %d", l.Len())
	}

	e = l.Front()
	for i := 0; i < 6; i++ {
		t.Logf("e = %d", e.Value)

		e = e.Next()
	}
}
Beispiel #10
0
// C & U
func (node Node) Update(cmp *RemoteNode) {
	bucketID := node.ID.DistanceTo(cmp.ID).GetBucketID()
	bucket := node.RoutingTable[bucketID]

	var found bool = false
	var foundElement *list.Element

	for elem := bucket.Front(); elem != nil; elem = elem.Next() {
		e, ok := elem.Value.(*RemoteNode)
		if !ok {
			continue // if it's not a NodeID, wtf is it doing in the list?? Probably should error out
		}
		if e.ID.EqualsTo(cmp.ID) || e.ID.EqualsTo(node.ID) {
			found = true
			foundElement = elem
			break
		}
	}
	if !found {
		if bucket.Len() <= BUCKET_SIZE {
			bucket.PushFront(cmp)
		}
	} else {
		foundElement.Value = cmp // update the  foundElement value
		bucket.MoveToFront(foundElement)
	}
}
Beispiel #11
0
func (s *Summary) incrElement(el *list.Element) {
	counter := el.Value.(*Counter)
	counter.count++

	// This element already has the largest count so it won't get moved.
	if s.list.Front() == el {
		return
	}

	// Starting at the previous element, move this element behind the first
	// element we find which has a higher count.
	moved := false
	for currEl := el.Prev(); currEl != nil; currEl = currEl.Prev() {
		if currEl.Value.(*Counter).count > counter.count {
			s.list.MoveAfter(el, currEl)
			moved = true
			break
		}
	}

	// If we didn't find an element with a higher count then this element must
	// have the highest count.  Move it to the front.
	if !moved {
		s.list.MoveToFront(el)
	}
}
Beispiel #12
0
/* Create tree ball list with id random. If Ball is already taked, a first ball next is taked */
func (Data *Data) Manage_magnet(requete *list.Element, Tab_wd *owm.All_data) {
	rqt := requete.Value.(*protocol.Request)
	var tab [3]int64
	list_tmp := list.New()
	var ifball Posball
	user := Data.User.Value.(*users.User)
	var answer []byte
	var eball *list.Element

	if user.MagnetisValid() == true {
		if Data.Lst_ball.Id_max > 0 {
			for i := 0; i < 3; i++ {
				tab[i] = rand.Int63n(Data.Lst_ball.Id_max)
			}
			list_tmp_2 := Data.Lst_ball.Get_ballbyid_tomagnet(tab, Data.User)
			eball = list_tmp_2.Front()
		}
		for eball != nil {
			ball := eball.Value.(*list.Element).Value.(*ballon.Ball)
			ifball.id = ball.Id_ball
			ifball.title = ball.Title
			ifball.FlagPoss = 0
			ifball.lon = ball.Coord.Value.(ballon.Checkpoint).Coord.Lon
			ifball.lat = ball.Coord.Value.(ballon.Checkpoint).Coord.Lat
			ifball.wins = ball.Wind.Speed
			ifball.wind = ball.Wind.Degress
			list_tmp.PushBack(ifball)
			eball = eball.Next()
		}
		answer = Write_nearby(requete, list_tmp, MAGNET, user)
	} else {
		answer = Data.Manage_ack(rqt.Rtype, 0, 0)
	}
	Data.Lst_asw.PushBack(answer)
}
Beispiel #13
0
func findRefKClosestTo(kadems []*Kademlia, portrange int, searchID ID, KConst int) *list.List {
	var retList *list.List = list.New()
	for i := 0; i < len(kadems); i++ {
		var newNodeID ID
		var newNodeIDDist int
		newNodeID = CopyID(kadems[i].ContactInfo.NodeID)
		newNodeIDDist = newNodeID.Distance(searchID)
		var e *list.Element = retList.Front()
		for ; e != nil; e = e.Next() {
			var dist int
			dist = e.Value.(ID).Distance(searchID)
			//if responseNode is closer than node in ShortList, add it
			if newNodeIDDist < dist {
				retList.InsertBefore(newNodeID, e)
				//node inserted! getout
				break
			}
		}
		if e == nil {
			//node is farthest yet
			retList.PushBack(newNodeID)
		}
	}
	return retList
}
Beispiel #14
0
func compareClosestContacts(fn []FoundNode, kadems []*Kademlia, portrange int, searchID ID) {
	var closestList *list.List = findRefKClosestTo(kadems, portrange, searchID, KConst)
	/*
		var pE *list.Element = closestList.Front()
		for ; pE != nil; pE = pE.Next(){
			log.Printf("Sorted? %s %d\n", pE.Value.(ID).AsString(), pE.Value.(ID).Distance(searchID))
		}*/
	var e *list.Element = closestList.Front()
	var overlap int = 0
	//log.Printf("searching for:%s\n", searchID.AsString())
	//log.Printf("reference List: \t\t\t\t\t iterativeFound List:\n")
	for i := 0; i < len(fn); i++ {
		var id ID = e.Value.(ID)
		//log.Printf("[%d]:%s %d\t%s %d", i, id.AsString(), id.Distance(searchID), fn[i].NodeID.AsString(), fn[i].NodeID.Distance(searchID))
		if id.Equals(fn[i].NodeID) {
			overlap++
		} else {
			for k := closestList.Front(); k != nil; k = k.Next() {
				if k.Value.(ID).Equals(fn[i].NodeID) {
					overlap++
				}
			}
		}
		e = e.Next()
	}
	if overlap < 5 {
		log.Printf("overlap of %d. Out of %d total nodes\n", overlap, portrange)
		panic(1)
	}
	//return retContacts
}
Beispiel #15
0
func defSetup(e *list.Element, s *env.Scope) (*parse.Atom, error) {
	name := e.Next().Value.(*parse.Atom).Value.(string)
	val, err := eval(e.Next().Next().Value, s)
	if err != nil {
		return nil, err
	}
	return Def(name, val, s), nil
}
Beispiel #16
0
func (c *Client) requeue(cursor *list.Element) {
	// If `cursor` is not nil, this means there are notifications that
	// need to be delivered (or redelivered)
	for ; cursor != nil; cursor = cursor.Next() {
		if n, ok := cursor.Value.(Notification); ok {
			go func() { c.notifs <- n }()
		}
	}
}
Beispiel #17
0
func ifSetup(e *list.Element, s *env.Scope) (*parse.Atom, error) {
	test, err := eval(e.Next().Value, s)
	if err != nil {
		return nil, err
	}
	thenStmt := e.Next().Next().Value
	elseStmt := e.Next().Next().Next().Value
	return If(test, thenStmt, elseStmt, s)
}
Beispiel #18
0
// Removes as space map element from a space map cell and removes it,
// or return nil if not found
func (cell *SpaceMapCell) Remove(el SpaceMapElement) SpaceMapElement {
	var e *list.Element
	for e = cell.Shapes.Front(); e != nil; e = e.Next() {
		val := e.Value
		if val.(SpaceMapElement) == el {
			cell.Shapes.Remove(e)
			return el
		}
	}
	return nil
}
Beispiel #19
0
// ListTruncate() removes elements from `e' to the last element in list `l'.
// The range to be removed is [e, l.Back()]. It returns list `l'.
func ListTruncate(l *list.List, e *list.Element) *list.List {
	AssertNotEqual(nil, l)
	AssertNotEqual(nil, e)
	// remove `e' and all elements after `e'
	var next *list.Element
	for ; e != nil; e = next {
		next = e.Next()
		l.Remove(e)
	}
	return l
}
Beispiel #20
0
// Finalize and free the cached prepared statements
// To be called in Conn#Close
func (c *cache) flush() {
	if c.maxSize <= 0 {
		return
	}
	c.m.Lock()
	defer c.m.Unlock()
	var e, next *list.Element
	for e = c.l.Front(); e != nil; e = next {
		next = e.Next()
		c.l.Remove(e).(*Stmt).finalize()
	}
}
Beispiel #21
0
//recursive function to find the kth from last element
func findKFromLastRecr(l *list.Element, k int) WrapObj {
	if l.Next() == nil {
		return WrapObj{1, l.Value.(int)}
	}

	resObj := findKFromLastRecr(l.Next(), k)
	resObj = WrapObj{resObj.count + 1, l.Value.(int)}
	if resObj.count == k {
		return resObj
	}
	return resObj
}
func firstNodeAfterTime(node *list.Element, cutoff time.Time) (*list.Element, bool) {
	for ; node != nil; node = node.Next() {
		tick := node.Value.(Tick)

		// log.Printf("Is %v > %v ?\n", tick.Time, cutoff)
		if tick.Time.After(cutoff) {
			return node, true
		}
	}

	return nil, false
}
Beispiel #23
0
func (this *Chart) loadSentence(s *Sentence, k int) {
	var j, n int
	var w *list.Element

	//println("Loading sentence")

	n = s.Len()
	this.table = make([]*list.List, (1+n)*n/2)

	//println("Loading sentence 2")

	j = 0
	l := list.New()
	for w = s.Front(); w != nil; w = w.Next() {
		ce := list.New()
		//println("Processing word " + w.Value.(*Word).getForm())
		for a := w.Value.(*Word).selectedBegin(k).Element; a != w.Value.(*Word).selectedBegin(k).Next(); a = a.Next() {
			//println("selected tags")
			e := NewEdgeFromString(a.Value.(*Analysis).getTag(), l, 0)
			ce.PushBack(e)
			//println(" created edge " + a.Value.(*Analysis).getTag() + " in cell (0," + strconv.Itoa(j) + ")")
			this.findAllRules(e, ce, 0, j)

			e1 := NewEdgeFromString(a.Value.(*Analysis).getTag()+"("+w.Value.(*Word).getLCForm()+")", l, 0)
			ce.PushBack(e1)
			//println(" created edge " + a.Value.(*Analysis).getTag() + "(" + w.Value.(*Word).getLCForm() + ") in cell (0," + strconv.Itoa(j) + ")")
			this.findAllRules(e1, ce, 0, j)

			e2 := NewEdgeFromString(a.Value.(*Analysis).getTag()+"<"+a.Value.(*Analysis).getLemma()+">", l, 0)
			ce.PushBack(e2)
			//println(" created edge " + a.Value.(*Analysis).getTag() + "<" + a.Value.(*Analysis).getLemma() + "> in cell (0," + strconv.Itoa(j) + ")")
			this.findAllRules(e2, ce, 0, j)
		}

		this.table[this.index(0, j)] = ce
		j++
	}
	this.size = j

	for k := 0; k < j; k++ {
		//println("Rule[", k, "]=", this.table[this.index(0, k)].Len())
		ce := this.table[this.index(0, k)]
		//println("Found", ce.Len(), "Rules")
		for e := ce.Front(); e != nil; e = e.Next() {
			//println(e.Value.(*Edge).String())
			//println("_______")
		}
		//println("=========")
	}

	//println("Sentence loaded")
}
func main() {
	var n, m int

	fmt.Fscan(reader, &n, &m)

	w := make([]int, n)
	b := make([]int, m)

	d := make([]int, n)
	rs := list.New()

	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &w[i])
	}

	for i := 0; i < m; i++ {
		var j int
		fmt.Fscan(reader, &j)
		b[i] = j - 1
	}

	for i := 0; i < m; i++ {
		if d[b[i]] == 0 {
			rs.PushBack(b[i])
		}
		d[b[i]] = 1
	}

	for i := 0; i < n; i++ {
		if d[i] == 0 {
			rs.PushBack(i)
		}
		d[i] = 1
	}

	var res int

	for i := 0; i < m; i++ {
		e := new(list.Element)
		for e = rs.Front(); e != nil; e = e.Next() {
			if e.Value == b[i] {
				break
			}
			j, _ := e.Value.(int)
			res += w[j]
		}
		rs.Remove(e)
		rs.PushFront(e.Value)
	}

	fmt.Println(res)
}
func (m *ChsFullTextMatch) mergeAllCombinations(redundancy int) *list.List {
	result := list.New()

	if (redundancy == 0 || !m.options.MultiDimensionality) && !m.options.ForceSingleWord {
		for _, v := range m.allCombinations[0] {
			result.PushBack(v)
		}
		return result
	}

	i := 0
	var cur *list.Element
	forceOnce := false

loop:
	for i <= redundancy && i < len(m.allCombinations) {
		cur = result.Front()
		for j := 0; j < len(m.allCombinations[i]); j++ {
			m.allCombinations[i][j].Level = i
			if cur != nil {
				for cur.Value.(dict.PositionLength).Position < m.allCombinations[i][j].Position {
					cur = cur.Next()
					if cur == nil {
						break
					}
				}
				if cur != nil {
					if cur.Value.(dict.PositionLength).Position != m.allCombinations[i][j].Position || cur.Value.(dict.PositionLength).Length != m.allCombinations[i][j].Length {
						result.InsertBefore(m.allCombinations[i][j], cur)
					}
				} else {
					result.PushBack(m.allCombinations[i][j])
				}
			} else {
				result.PushBack(m.allCombinations[i][j])
			}
		}

		i++
	}

	if m.options.ForceSingleWord && !forceOnce {
		i = len(m.allCombinations) - 1
		redundancy = i
		forceOnce = true
		goto loop
	}

	return result
}
Beispiel #26
0
func (this *Chart) cover(a, b int) *list.List {
	x := 0
	y := 0
	var i, j int
	var f bool
	var ed *list.Element
	var lp, lr *list.List

	if a < 0 || b < 0 || a+b >= this.size {
		return list.New()
	}

	//println("Covering under (" + strconv.Itoa(a) + "," + strconv.Itoa(b) + ")")

	f = false

	best := NewEdge()

	for i = a; !f && i >= 0; i-- {
		for j = b; j < b+(a-i)+1; j++ {
			//println("ED len:" + strconv.Itoa(this.table[this.index(i, j)].Len()))
			for ed = this.table[this.index(i, j)].Front(); ed != nil; ed = ed.Next() {
				LOG.Tracef("ed.active:%b 1st best:%b", ed.Value.(*Edge).active(), this.betterEdge(ed.Value.(*Edge), best))
				if !ed.Value.(*Edge).active() && this.betterEdge(ed.Value.(*Edge), best) {
					x = i
					y = j
					best = ed.Value.(*Edge)
					f = true
				}
			}
		}
	}

	//println("  Highest cell found is (" + strconv.Itoa(x) + "," + strconv.Itoa(y) + ")")
	//println("   Pending (" + strconv.Itoa(y-b-1) + "," + strconv.Itoa(b) + ") (" + strconv.Itoa((a+b)-(x+y+1)) + "," + strconv.Itoa(x+y+1) + ")")

	if !f {
		LOG.Panic("Inconsistent chart or wrongly loaded sentence")
	}

	lp = this.cover(y-b-1, b)
	lr = this.cover((a+b)-(x+y+1), x+y+1)

	lp.PushBack(Pair{x, y})
	for tlr := lr.Front(); tlr != nil; tlr = tlr.Next() {
		lp.PushBack(tlr.Value.(Pair))
	}

	return lp
}
Beispiel #27
0
func (me *orderedList) ValueChanged(e *list.Element) {
	for prev := e.Prev(); prev != nil && me.lessFunc(e.Value, prev.Value); prev = e.Prev() {
		me.list.MoveBefore(e, prev)
	}
	for next := e.Next(); next != nil && me.lessFunc(next.Value, e.Value); next = e.Next() {
		me.list.MoveAfter(e, next)
	}
}
Beispiel #28
0
func (this *Dictionary) Analyze(se *Sentence) {
	contr := false

	for pos := se.Front(); pos != nil; pos = pos.Next() {
		LOG.Tracef("Processing: %s - %d %s", pos.Value.(*Word).getForm(), pos.Value.(*Word).getNAnalysis(), string(pos.Value.(*Word).getTag(0)))
		if pos.Value.(*Word).getNAnalysis() == 0 || (pos.Value.(*Word).getNAnalysis() > 0 && string(pos.Value.(*Word).getTag(0)[0]) == "Z") {
			LOG.Trace("Annotating word:" + pos.Value.(*Word).getForm())

			lw := list.New()

			if this.AnnotateWord(pos.Value.(*Word), lw, false) {
				st := pos.Value.(*Word).getSpanStart()
				fin := pos.Value.(*Word).getSpanFinish()
				LOG.Trace("Contraction found, replacing... " + pos.Value.(*Word).getForm() + ". span=(" + strconv.Itoa(int(st)) + "," + strconv.Itoa(int(fin)) + ")")

				step := (float64(fin) - float64(st) + 1.0) / float64(lw.Len())
				step = math.Max(1, step)
				ln := math.Max(1, step-1.0)

				var n int
				var i *list.Element
				n = 1
				for i = lw.Front(); i != nil; i = i.Next() {
					f := If(n == lw.Len(), fin, st+int(ln)).(int)
					i.Value.(*Word).setSpan(st, f)
					i.Value.(*Word).user = pos.Value.(*Word).user

					LOG.Trace("   Inserting " + i.Value.(*Word).getForm() + ". span=(" + strconv.Itoa(int(st)) + "," + strconv.Itoa(int(fin)) + ")")
					pos = se.InsertBefore(i.Value.(*Word), pos)
					pos = pos.Next()
					st = st + int(step)

					contr = true
				}

				LOG.Trace("   Erasing " + pos.Value.(*Word).getForm())
				q := pos
				q = q.Prev()
				se.Remove(pos)
				pos = q
			}
		}
	}

	if contr {
		se.rebuildWordIndex()
	}
}
Beispiel #29
0
//---------------------------------------------------------------------
// parse data
//---------------------------------------------------------------------
func ikcp_parse_data(kcp *Ikcpcb, newseg *IKCPSEG) {
	var p *list.Element
	sn := newseg.sn
	repeat := 0
	if _itimediff(sn, kcp.rcv_nxt+kcp.rcv_wnd) >= 0 ||
		_itimediff(sn, kcp.rcv_nxt) < 0 {
		return
	}

	for p = kcp.rcv_buf.Back(); p != nil; p = p.Prev() {
		seg := p.Value.(*IKCPSEG)
		if seg.sn == sn {
			repeat = 1
			break
		}
		if _itimediff(sn, seg.sn) > 0 {
			break
		}
	}

	if repeat == 0 {
		if p == nil {
			kcp.rcv_buf.PushFront(newseg)
		} else {
			kcp.rcv_buf.InsertAfter(newseg, p)
		}
		kcp.nrcv_buf++
	} else {
	}
	for p = kcp.rcv_buf.Front(); p != nil; {
		seg := p.Value.(*IKCPSEG)
		if seg.sn == kcp.rcv_nxt && kcp.nrcv_que < kcp.rcv_wnd {
			q := p.Next()
			kcp.rcv_buf.Remove(p)
			p = q
			kcp.nrcv_buf--
			kcp.rcv_queue.PushBack(seg)
			//if kcp.user[0] == 0 {
			//fmt.Println("insert from recvqueue2", kcp.rcv_queue.Len(), kcp.user)
			//}
			kcp.nrcv_que++
			kcp.rcv_nxt++
		} else {
			break
		}
	}
	//println("inputok!!!", kcp.nrcv_buf, kcp.nrcv_que, repeat, kcp.rcv_nxt, sn)
}
Beispiel #30
0
func lambdaSetup(e *list.Element, s *env.Scope) (*parse.Atom, error) {
	arglist := e.Next().Value.(*list.List)
	args := make([]string, 0)
	for a := arglist.Front(); a != nil; a = a.Next() {
		args = append(args, a.Value.(*parse.Atom).Value.(string))
	}
	body := make([]interface{}, 0)
	for b := e.Next().Next(); b != nil; b = b.Next() {
		body = append(body, b.Value)
	}
	// taking liberties with the name "Atom"
	return &parse.Atom{
		Value: Lambda(args, body, env.New(s)),
		Type:  "function",
	}, nil
}