TODO lang:Go · golang/go — 2,626 matches

misc/cgo/gmp/gmp.go GO 1 matches view file →

func (z *Int) SetInt64(x int64) *Int {
	z.doinit()
	// TODO(rsc): more work on 32-bit platforms
	C.mpz_set_si(&z.i[0], C.long(x))
	return z

misc/go_android_exec/main.go GO 1 matches view file →

// This wrapper uses syscall.Flock to prevent concurrent adb commands,
// so for now it only builds on platforms that support that system call.
// TODO(#33974): use a more portable library for file locking.
//go:build darwin || dragonfly || freebsd || illumos || linux || netbsd || openbsd

src/archive/tar/common.go GO 1 matches view file →

	}
	// TODO(dsnet): Re-enable this when adding sparse support.
	// See https://golang.org/issue/22735
	/*

src/archive/tar/example_test.go GO 2 matches view file →

		{"readme.txt", "This archive contains some text files."},
		{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
		{"todo.txt", "Get animal handling license."},
	}
	for _, file := range files {

· · ·

	// Geoffrey
	// Gonzo
	// Contents of todo.txt:
	// Get animal handling license.
}

src/archive/tar/fuzz_test.go GO 1 matches view file →

		}
		// TODO: We may want to check if the archive roundtrips. This would require
		// taking into account addition of the two zero trailer blocks that Writer.Close
		// appends.

src/archive/tar/reader.go GO 1 matches view file →

// This always writes the last byte to ensure w is the right size.
//
// TODO(dsnet): Re-export this when adding sparse file support.
// See https://golang.org/issue/22735
func (tr *Reader) writeTo(w io.Writer) (int64, error) {

src/archive/tar/stat_unix.go GO 1 matches view file →

			h.Devmajor, h.Devminor = int64(major), int64(minor)
		default:
			// TODO: Implement solaris (see https://golang.org/issue/8106)
		}
	}

src/archive/tar/writer.go GO 4 matches view file →

	realName, realSize := hdr.Name, hdr.Size
	// TODO(dsnet): Re-enable this when adding sparse support.
	// See https://golang.org/issue/22735
	/*

· · ·

	}
	// TODO(dsnet): Re-enable this when adding sparse support.
	// See https://golang.org/issue/22735
	/*

· · ·

		f.formatNumeric(blk.toGNU().changeTime(), hdr.ChangeTime.Unix())
	}
	// TODO(dsnet): Re-enable this when adding sparse support.
	// See https://golang.org/issue/22735
	/*

· · ·

// This always reads the last byte to ensure r is the right size.
//
// TODO(dsnet): Re-export this when adding sparse file support.
// See https://golang.org/issue/22735
func (tw *Writer) readFrom(r io.Reader) (int64, error) {

src/archive/tar/writer_test.go GO 1 matches view file →

			testClose{nil},
		},
		// TODO(dsnet): Re-enable this test when adding sparse support.
		// See https://golang.org/issue/22735
		/*

src/archive/zip/example_test.go GO 1 matches view file →

		{"readme.txt", "This archive contains some text files."},
		{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
		{"todo.txt", "Get animal handling licence.\nWrite more examples."},
	}
	for _, file := range files {

src/archive/zip/fuzz_test.go GO 1 matches view file →

		}
		// TODO: We may want to check if the archive roundtrips.
	})
}

src/archive/zip/reader_test.go GO 1 matches view file →

		b[0x9d]++
		// TODO(bradfitz): add a new test that only corrupts
		// one of these values, and verify that that's also an
		// error. Currently, the reader code doesn't verify the

src/archive/zip/struct.go GO 1 matches view file →

// timeToMsDosTime converts a time.Time to an MS-DOS date and time.
// The resolution is 2s.
// See: https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-filetimetodosdatetime
func timeToMsDosTime(t time.Time) (fDate uint16, fTime uint16) {
	fDate = uint16(t.Day() + int(t.Month())<<5 + (t.Year()-1980)<<9)

src/archive/zip/writer_test.go GO 1 matches view file →

)
// TODO(adg): a more sophisticated test suite
type WriteTest struct {

src/bytes/buffer.go GO 1 matches view file →

		}
	}()
	// TODO(http://golang.org/issue/51462): We should rely on the append-make
	// pattern so that the compiler can call runtime.growslice. For example:
	//	return append(b, make([]byte, n)...)

src/bytes/bytes.go GO 2 matches view file →

// isSeparator reports whether the rune could mark a word boundary.
// TODO: update when package unicode captures more of the properties.
func isSeparator(r rune) bool {
	// ASCII alphanumerics and underscore are not separators

· · ·

			// Experiments (using IndexPeriodic) suggest
			// the cutover is about 16 byte skips.
			// TODO: if large prefixes of sep are matching
			// we should cutover at even larger average skips,
			// because Equal becomes that much more expensive.

src/cmd/api/api_test.go GO 1 matches view file →

		}
		// TODO(gri) remove extra pkg directory eventually
		goldenFile := filepath.Join("testdata", "src", "pkg", fi.Name(), "golden.txt")
		w := NewWalker(nil, "testdata/src/pkg")

src/cmd/api/main_test.go GO 2 matches view file →

		ctags[tag] = true
	}
	// TODO: ReleaseTags (need to load default)
	key := dir

· · ·

		case types.UntypedRune:
			// "ideal-char" for compatibility with old tool
			// TODO(gri) change to "ideal-rune"
			s = "ideal-char"
		case types.UntypedFloat:

src/cmd/asm/internal/asm/asm.go GO 2 matches view file →

)
// TODO: configure the architecture
var testOut *strings.Builder // Gathers output when testing.

· · ·

			prog.To = a[2]
		default:
			p.errorf("TODO: implement three-operand instructions for this architecture")
			return
		}

src/cmd/asm/internal/asm/operand_test.go GO 1 matches view file →

	{"(BX)", "(BX)"},
	{"(SP)", "(SP)"},
	{"*AX", "AX"}, // TODO: Should make * illegal here; a simple alias for JMP AX.
	{"*runtime·_GetStdHandle(SB)", "*runtime._GetStdHandle(SB)"},
	{"-(4+12)(DI)", "-16(DI)"},

src/cmd/asm/internal/asm/parse.go GO 3 matches view file →

// Package asm implements the parser and instruction generator for the assembler.
// TODO: Split apart?
package asm

· · ·

		return true
	}
	// R(1)<<...   Ugly check. TODO: Rethink how we handle ARM register shifts to be
	// less special.
	if p.peek() != '(' || len(p.input)-p.inputPos < 4 {

· · ·

	a.Reg = r1
	if r2 != 0 {
		// TODO: Consistency in the encoding would be nice here.
		if p.arch.InFamily(sys.ARM, sys.ARM64) {
			// Special form

src/cmd/asm/internal/lex/slice.go GO 1 matches view file →

func (s *Slice) Col() int {
	// TODO: Col is only called when defining a macro and all it cares about is increasing
	// position to discover whether there is a blank before the parenthesis.
	// We only get here if defining a macro inside a macro.

src/cmd/cgo/gcc.go GO 8 matches · showing 5 view file →

	// _cgoCheckPointer returns the untyped nil the type assertion we
	// are going to insert will fail. Easier to just skip nil arguments.
	// TODO: Note that this fails if nil is shadowed.
	if id, ok := arg.(*ast.Ident); ok && id.Name == "nil" {
		return false

· · ·

		return true
	case *ast.Ident:
		// TODO: Handle types defined within function.
		for _, d := range p.Decl {
			gd, ok := d.(*ast.GenDecl)

· · ·

		return false
	case *ast.Ident:
		// TODO: This ignores shadowing.
		switch t.Name {
		case "unsafe.Pointer", "bool", "byte",

· · ·

// gccErrors is called concurrently with different C programs.
func (p *Package) gccErrors(stdin []byte, extraArgs ...string) string {
	// TODO(rsc): require failure
	args := p.gccCmd(gccTmp())

· · ·

				t.C.Set("__typeof__(unsigned char[%d])", t.Size)
			}
			t.Align = 1 // TODO: should probably base this on field alignment.
			typedef[name.Name] = t
		case "struct":

+ 3 more matches in this file

src/cmd/cgo/internal/test/callback.go GO 1 matches view file →

	}
	for i := 0; i < n; i++ {
		f := runtime.FuncForPC(pc[i] - 1) // TODO: use runtime.CallersFrames
		if f == nil {
			t.Fatalf("expected non-nil Func for pc %d", pc[i])

src/cmd/cgo/internal/test/callback_windows.go GO 2 matches view file →

	}
	if runtime.GOARCH != "amd64" {
		// TODO: support SEH on other architectures.
		t.Skip("skipping on non-amd64")
	}

· · ·

		switch fname {
		case "goCallback":
			// TODO(qmuntal): investigate why this function doesn't appear
			// when using the external linker.
			continue

`auth login`	both terms (AND is implicit)
`auth OR login`	either term
`NOT path:vendor`	exclude matches
`"exact phrase"`	quoted exact match
`/func\s+Test/`	regex
`handler~1`	fuzzy (Levenshtein 1)
`file:*_test.go`	filename glob
`path:pkg/auth/**`	full path glob
`lang:go`	language filter

Search any public repo from your terminal