1. 24 Oct, 2017 1 commit
    • Kirill Smelkov's avatar
      Relicense to GPLv3+ with wide exception for all Free Software / Open Source... · 4d9a613c
      Kirill Smelkov authored
      Relicense to GPLv3+ with wide exception for all Free Software / Open Source projects + Business options.
      
      Nexedi stack is licensed under Free Software licenses with various exceptions
      that cover three business cases:
      
      - Free Software
      - Proprietary Software
      - Rebranding
      
      As long as one intends to develop Free Software based on Nexedi stack, no
      license cost is involved. Developing proprietary software based on Nexedi stack
      may require a proprietary exception license. Rebranding Nexedi stack is
      prohibited unless rebranding license is acquired.
      
      Through this licensing approach, Nexedi expects to encourage Free Software
      development without restrictions and at the same time create a framework for
      proprietary software to contribute to the long term sustainability of the
      Nexedi stack.
      
      Please see https://www.nexedi.com/licensing for details, rationale and options.
      4d9a613c
  2. 11 Sep, 2017 1 commit
  3. 08 Aug, 2017 1 commit
  4. 25 Jul, 2017 1 commit
  5. 19 Jul, 2017 1 commit
    • Kirill Smelkov's avatar
      xerr += First, Merge · 79e328c5
      Kirill Smelkov authored
      This are handy utilities to reduce several errors into only 1 either
      picking the first error or merging, if there are several, into Errorv.
      
      It is unfortunate but an issue with Errorv was realized that even though
      it satisfies the error interface, it cannot be generally worked with as
      error because it (being []error) is uncomparable. Thus e.g. the following
      code, if err dynamic type is Errorv, will panic:
      
      	if err == io.EOF
      
      It is pity Go slices are uncomparable.
      79e328c5
  6. 07 Jun, 2017 1 commit
    • Kirill Smelkov's avatar
      xerr += Context, Contextf · 8f170959
      Kirill Smelkov authored
      This are handy utilities to automatically prepend context on error
      return. For example in
      
      	func myfunc(...) (..., err error) {
      		defer xerr.Context(&err, "error context")
      		...
      		if ... {
      			return ..., errors.New("an error")
      		}
      		return ..., nil
      	}
      
      while preserving nil error return on successful execution, myfunc will
      return error with string "error context: an error" on failure case.
      8f170959
  7. 20 Apr, 2017 4 commits
    • Kirill Smelkov's avatar
      xfmt: Qpy & friends to quote string the way Python would do · c0bbd06e
      Kirill Smelkov authored
      This is somtimes needed for checking programs output bit-to-bit where on
      python side repr(x), `x` or %r is used for output.
      c0bbd06e
    • Kirill Smelkov's avatar
      xfmt: Addons to fmt and strconv with focus on formatting text without allocations · 1aa677c8
      Kirill Smelkov authored
      Std fmt works ok unless you need to do text formatting in hot codepaths.
      There fmt becomes inappropriate as it is slow and does allocations on
      every formatting.
      
      strconv also does not have append routines for every needed case, e.g.
      there is no strconv.AppendRune, no strconv.AppendHex etc.
      
      So xfmt
      
      1. provides append routines for builtin types lacking in strconv
      
      2. introduces xfmt.Stringer interface which types can implement to hook
         into general formatting via xfmt.Append()
      
      3. provides xfmt.Buffer which is []byte with syntatic sugar for
         formatting in a way similar to printf: For example if in fmt speak
         you have
      
      	s := fmt.Sprintf("hello %q %d %x", "world", 1, []byte("data"))
      
         xfmt analog would be
      
      	buf := xfmt.Buffer{}
      	buf .S("hello ") .Q("world") .C(' ') .D(1) .C(' ') .Xb([]byte("data"))
      	s := buf.Bytes()
      
         and xfmt.Buffer can be reused several times via Buffer.Reset() .
      
      The above xfmt.Buffer usage is more uglier than fmt.Printf but much less uglier
      than direct strconv.Append* and friends calls, and works faster and without
      allocations compared to fmt.Printf:
      
      	BenchmarkXFmt/%c(0x41)-4                20000000                65.4 ns/op             1 B/op          1 allocs/op
      	BenchmarkXFmt/.Cb(0x41)-4               200000000                5.96 ns/op            0 B/op          0 allocs/op
      	BenchmarkXFmt/%c(-1)-4                  20000000                70.1 ns/op             3 B/op          1 allocs/op
      	BenchmarkXFmt/.C(-1)-4                  100000000               12.9 ns/op             0 B/op          0 allocs/op
      	BenchmarkXFmt/%c(66)-4                  20000000                65.8 ns/op             1 B/op          1 allocs/op
      	BenchmarkXFmt/.C(66)-4                  100000000               12.7 ns/op             0 B/op          0 allocs/op
      	BenchmarkXFmt/%c(1080)-4                20000000                67.2 ns/op             2 B/op          1 allocs/op
      	BenchmarkXFmt/.C(1080)-4                100000000               12.8 ns/op             0 B/op          0 allocs/op
      	BenchmarkXFmt/%c(8364)-4                20000000                69.4 ns/op             3 B/op          1 allocs/op
      	BenchmarkXFmt/.C(8364)-4                100000000               13.8 ns/op             0 B/op          0 allocs/op
      	BenchmarkXFmt/%c(65537)-4               20000000                70.5 ns/op             4 B/op          1 allocs/op
      	BenchmarkXFmt/.C(65537)-4               100000000               14.3 ns/op             0 B/op          0 allocs/op
      	BenchmarkXFmt/%s("hello")-4             20000000                72.3 ns/op             5 B/op          1 allocs/op
      	BenchmarkXFmt/.S("hello")-4             200000000                9.40 ns/op            0 B/op          0 allocs/op
      	...
      1aa677c8
    • Kirill Smelkov's avatar
      xbytes: Additional utilities for working with byte slices · 64936209
      Kirill Smelkov authored
      - small addons over std bytes package: xbytes.ContainsByte
      - (re)allocation routines for byte slices
      64936209
    • Kirill Smelkov's avatar
      xmath: Addon math routines · b1893d27
      Kirill Smelkov authored
      So far only one of them: CeilPow2 to return min(y) >= x: y = 2^i - i.e.
      next power of two >= x. This is handy to have in reallocation routines
      to allocate buffers from 2^i classes.
      
      Two implementations:
      
      - fast for go19
      - slower fallback for go18
      b1893d27
  8. 19 Apr, 2017 4 commits
    • Kirill Smelkov's avatar
      xruntime: Switch to using runtime.Frame · 7deb28a5
      Kirill Smelkov authored
      As it was planned switch to using runtime.Frame instead of our
      local imitation.
      
      Add test to make sure we are not breaking anything.
      Adjust users in exc.
      7deb28a5
    • Kirill Smelkov's avatar
      my: Add File, Line and Frame · 6cabc980
      Kirill Smelkov authored
      To determine current function's file name, line number and runtime.Frame
      6cabc980
    • Kirill Smelkov's avatar
      my: Use runtime.CallersFrames instead of runtime.FuncForPC · cf55754e
      Kirill Smelkov authored
      Because in general case runtime.CallersFrames is more accurate than
      runtime.FuncForPC - e.g. the latter does not correctly work with inlined
      functions.
      cf55754e
    • Kirill Smelkov's avatar
      myname -> my · 98249b24
      Kirill Smelkov authored
      This causes the following changes on client side:
      
      	myname.Func	-> my.FuncName
      	myname.Pkg	-> my.PkgName
      
      Reason for the change is that we are going to introduce my.File and
      my.Line which would not fit into myname package naming.
      98249b24
  9. 29 Mar, 2017 1 commit
  10. 06 Mar, 2017 1 commit
  11. 03 Mar, 2017 1 commit
  12. 14 Dec, 2016 6 commits
  13. 13 Dec, 2016 12 commits