File Manager

X7ROOT File Manager

Current Path: /opt/golang/1.17.2/test

📁 ..
📄 235.go(1.56 KB)
📄 64bit.go(24.83 KB)
📄 README.md(696 B)
📁 abi
📄 alg.go(822 B)
📄 alias.go(588 B)
📄 alias1.go(803 B)
📄 alias2.go(2.52 KB)
📁 alias3.dir
📄 alias3.go(187 B)
📄 align.go(603 B)
📄 append.go(9.09 KB)
📄 append1.go(836 B)
📄 args.go(374 B)
📄 armimm.go(3.85 KB)
📄 assign.go(1.01 KB)
📄 assign1.go(5.55 KB)
📄 atomicload.go(798 B)
📁 bench
📄 bigalg.go(2.12 KB)
📄 bigmap.go(2.46 KB)
📄 blank.go(2.1 KB)
📄 blank1.go(724 B)
📄 bom.go(406 B)
📄 bombad.go(480 B)
📄 bounds.go(6.09 KB)
📄 cannotassign.go(1.04 KB)
📁 chan
📄 chancap.go(1.57 KB)
📄 chanlinear.go(2.12 KB)
📄 char_lit.go(657 B)
📄 char_lit1.go(822 B)
📄 checkbce.go(3.56 KB)
📄 clearfat.go(1.15 KB)
📄 closedchan.go(5.79 KB)
📄 closure.go(1.69 KB)
📄 closure1.go(280 B)
📄 closure2.go(1.86 KB)
📁 closure3.dir
📄 closure3.go(321 B)
📄 closure4.go(364 B)
📁 closure5.dir
📄 closure5.go(280 B)
📄 closure6.go(346 B)
📄 closure7.go(373 B)
📄 cmp.go(7.63 KB)
📄 cmp6.go(2.16 KB)
📄 cmplx.go(1.39 KB)
📄 cmplxdivide.c(2.05 KB)
📄 cmplxdivide.go(868 B)
📄 cmplxdivide1.go(240.68 KB)
📁 codegen
📄 complit.go(1.71 KB)
📄 complit1.go(1.66 KB)
📄 compos.go(403 B)
📄 const.go(4.78 KB)
📄 const1.go(3.79 KB)
📄 const2.go(1008 B)
📄 const3.go(659 B)
📄 const4.go(1.28 KB)
📄 const5.go(835 B)
📄 const6.go(834 B)
📄 const7.go(1.9 KB)
📄 convT2X.go(3.33 KB)
📄 convert.go(833 B)
📄 convert1.go(3.41 KB)
📄 convert2.go(5.92 KB)
📄 convert3.go(544 B)
📄 convert4.go(1.63 KB)
📄 convlit.go(2.39 KB)
📄 convlit1.go(458 B)
📄 copy.go(6.6 KB)
📄 copy1.go(851 B)
📄 crlf.go(782 B)
📄 ddd.go(4.23 KB)
📄 ddd1.go(1.58 KB)
📁 ddd2.dir
📄 ddd2.go(252 B)
📄 decl.go(926 B)
📄 declbad.go(1.43 KB)
📄 defer.go(875 B)
📄 defererrcheck.go(1.4 KB)
📄 deferfin.go(1.05 KB)
📄 defernil.go(563 B)
📄 deferprint.go(586 B)
📄 deferprint.out(126 B)
📄 devirt.go(599 B)
📄 directive.go(2.24 KB)
📄 divide.go(1.22 KB)
📄 divmod.go(9.28 KB)
📁 dwarf
📄 embedfunc.go(308 B)
📄 embedvers.go(292 B)
📄 empty.go(316 B)
📄 env.go(585 B)
📄 eof.go(308 B)
📄 eof1.go(333 B)
📄 escape.go(3.79 KB)
📄 escape2.go(35.07 KB)
📄 escape2n.go(35.1 KB)
📄 escape3.go(524 B)
📄 escape4.go(1.31 KB)
📄 escape5.go(5.37 KB)
📄 escape_array.go(3.64 KB)
📄 escape_calls.go(1.26 KB)
📄 escape_closure.go(4.24 KB)
📄 escape_field.go(2.92 KB)
📄 escape_goto.go(674 B)
📄 escape_hash_maphash.go(368 B)
📄 escape_iface.go(4.47 KB)
📄 escape_indir.go(3.31 KB)
📄 escape_level.go(1.79 KB)
📄 escape_map.go(2.76 KB)
📄 escape_param.go(8.9 KB)
📄 escape_runtime_atomic.go(874 B)
📄 escape_selfassign.go(538 B)
📄 escape_slice.go(3.79 KB)
📄 escape_struct_param1.go(8.9 KB)
📄 escape_struct_param2.go(8.94 KB)
📄 escape_struct_return.go(1.04 KB)
📄 escape_sync_atomic.go(943 B)
📄 escape_unsafe.go(2.16 KB)
📄 fibo.go(6.28 KB)
📄 finprofiled.go(1.95 KB)
📁 fixedbugs
📄 float_lit.go(3.95 KB)
📄 float_lit2.go(7.88 KB)
📄 float_lit3.go(1.59 KB)
📄 floatcmp.go(3.03 KB)
📄 for.go(844 B)
📄 func.go(1.29 KB)
📄 func1.go(445 B)
📄 func2.go(578 B)
📄 func3.go(505 B)
📄 func4.go(409 B)
📄 func5.go(1.49 KB)
📄 func6.go(393 B)
📄 func7.go(477 B)
📄 func8.go(599 B)
📄 funcdup.go(1.31 KB)
📄 funcdup2.go(721 B)
📄 fuse.go(5.31 KB)
📄 gc.go(411 B)
📄 gc1.go(303 B)
📄 gc2.go(972 B)
📄 gcgort.go(34.54 KB)
📄 gcstring.go(872 B)
📄 goprint.go(722 B)
📄 goprint.out(65 B)
📄 goto.go(8.39 KB)
📄 heapsampling.go(9.53 KB)
📄 helloworld.go(269 B)
📄 helloworld.out(13 B)
📄 if.go(1.36 KB)
📄 import.go(425 B)
📄 import1.go(633 B)
📁 import2.dir
📄 import2.go(247 B)
📁 import4.dir
📄 import4.go(310 B)
📄 import5.go(722 B)
📄 import6.go(1.38 KB)
📄 index.go(6.42 KB)
📄 index0.go(301 B)
📄 index1.go(305 B)
📄 index2.go(305 B)
📄 indirect.go(1.39 KB)
📄 indirect1.go(1.53 KB)
📄 init.go(479 B)
📄 init1.go(1.08 KB)
📄 initcomma.go(1.22 KB)
📄 initempty.go(604 B)
📄 initexp.go(1.74 KB)
📄 initialize.go(1.24 KB)
📄 initializerr.go(1.04 KB)
📄 initloop.go(407 B)
📄 inline.go(7.59 KB)
📄 inline_big.go(12.67 KB)
📄 inline_caller.go(1.36 KB)
📄 inline_callers.go(1.87 KB)
📄 inline_literal.go(1.02 KB)
📄 inline_math_bits_rotate.go(569 B)
📄 inline_sync.go(1.52 KB)
📄 inline_variadic.go(513 B)
📄 int_lit.go(387 B)
📄 intcvt.go(4.26 KB)
📁 interface
📁 intrinsic.dir
📄 intrinsic.go(259 B)
📄 intrinsic_atomic.go(799 B)
📄 iota.go(1.59 KB)
📁 ken
📄 label.go(1.02 KB)
📄 label1.go(2.08 KB)
📄 linkmain.go(236 B)
📄 linkmain_run.go(1.71 KB)
📁 linkname.dir
📄 linkname.go(456 B)
📄 linkname2.go(794 B)
📄 linkobj.go(3.17 KB)
📄 linkx.go(741 B)
📄 linkx_run.go(1.65 KB)
📄 literal.go(4.99 KB)
📄 literal2.go(2.22 KB)
📄 live.go(17.96 KB)
📄 live1.go(1.29 KB)
📄 live2.go(963 B)
📄 live_regabi.go(17.93 KB)
📄 live_syscall.go(1.13 KB)
📄 locklinear.go(3.56 KB)
📄 loopbce.go(9.75 KB)
📄 mainsig.go(598 B)
📄 makechan.go(1.04 KB)
📄 makemap.go(1.3 KB)
📄 makenew.go(605 B)
📄 makeslice.go(5.49 KB)
📄 mallocfin.go(1.18 KB)
📄 map.go(14.91 KB)
📄 map1.go(1.47 KB)
📄 mapclear.go(1.49 KB)
📄 maplinear.go(3.62 KB)
📄 mergemul.go(3.16 KB)
📄 method.go(5.24 KB)
📄 method1.go(727 B)
📄 method2.go(1.16 KB)
📄 method3.go(570 B)
📁 method4.dir
📄 method4.go(230 B)
📄 method5.go(6.73 KB)
📄 method6.go(467 B)
📄 method7.go(1.15 KB)
📄 named.go(4.61 KB)
📄 named1.go(984 B)
📄 nil.go(2.23 KB)
📄 nilcheck.go(3.62 KB)
📄 nilptr.go(3.15 KB)
📄 nilptr2.go(3.6 KB)
📄 nilptr3.go(5.39 KB)
📄 nilptr4.go(428 B)
📄 nilptr5.go(814 B)
📄 nilptr5_aix.go(805 B)
📄 nilptr5_wasm.go(812 B)
📄 nilptr_aix.go(3.09 KB)
📄 nosplit.go(10.8 KB)
📄 notinheap.go(1.29 KB)
📄 notinheap2.go(1.78 KB)
📄 notinheap3.go(1.24 KB)
📄 nowritebarrier.go(1.21 KB)
📄 nul1.go(1.23 KB)
📁 oldescape_linkname.dir
📄 opt_branchlikely.go(2.08 KB)
📄 parentype.go(424 B)
📄 peano.go(2.22 KB)
📄 phiopt.go(2.02 KB)
📄 print.go(1.56 KB)
📄 print.out(247 B)
📄 printbig.go(315 B)
📄 printbig.out(41 B)
📄 prove.go(19.65 KB)
📄 range.go(8.14 KB)
📄 recover.go(10.64 KB)
📄 recover1.go(2.5 KB)
📄 recover2.go(1.22 KB)
📄 recover3.go(1.64 KB)
📄 recover4.go(2.17 KB)
📄 recover5.go(408 B)
📄 reflectmethod1.go(578 B)
📄 reflectmethod2.go(719 B)
📄 reflectmethod3.go(651 B)
📄 reflectmethod4.go(573 B)
📄 reflectmethod5.go(544 B)
📄 reflectmethod6.go(555 B)
📄 reflectmethod7.go(417 B)
📄 rename.go(1.52 KB)
📄 rename1.go(1.13 KB)
📄 reorder.go(2.28 KB)
📄 reorder2.go(7.22 KB)
📁 retjmp.dir
📄 retjmp.go(252 B)
📄 return.go(32.69 KB)
📄 rotate.go(3.27 KB)
📄 rotate0.go(286 B)
📄 rotate1.go(286 B)
📄 rotate2.go(286 B)
📄 rotate3.go(286 B)
📄 run.go(56.89 KB)
📄 rune.go(603 B)
📁 runtime
📄 runtime.go(600 B)
📄 shift1.go(8.92 KB)
📄 shift2.go(1.31 KB)
📄 sieve.go(1 KB)
📄 sigchld.go(365 B)
📄 sigchld.out(17 B)
📄 simassign.go(1.12 KB)
📄 sinit.go(5.75 KB)
📄 sinit_run.go(856 B)
📄 sizeof.go(2.95 KB)
📄 slice3.go(2.92 KB)
📄 slice3err.go(5.19 KB)
📄 slicecap.go(1.85 KB)
📄 sliceopt.go(735 B)
📄 solitaire.go(2.9 KB)
📄 stack.go(1.69 KB)
📄 stackobj.go(975 B)
📄 stackobj2.go(1.55 KB)
📄 stackobj3.go(1.42 KB)
📄 strcopy.go(674 B)
📄 strength.go(1.02 KB)
📁 stress
📄 string_lit.go(3.58 KB)
📄 stringrange.go(1.45 KB)
📄 struct0.go(565 B)
📄 switch.go(6.1 KB)
📄 switch2.go(778 B)
📄 switch3.go(1.24 KB)
📄 switch4.go(526 B)
📄 switch5.go(2.25 KB)
📄 switch6.go(1.16 KB)
📄 switch7.go(796 B)
📁 syntax
📄 tinyfin.go(1.57 KB)
📄 torture.go(7.69 KB)
📄 turing.go(893 B)
📄 typecheck.go(549 B)
📄 typecheckloop.go(526 B)
📁 typeparam
📄 typeswitch.go(1.83 KB)
📄 typeswitch1.go(1.6 KB)
📄 typeswitch2.go(655 B)
📄 typeswitch2b.go(598 B)
📄 typeswitch3.go(1009 B)
📁 uintptrescapes.dir
📄 uintptrescapes.go(250 B)
📄 uintptrescapes2.go(2.18 KB)
📄 uintptrescapes3.go(1.28 KB)
📄 undef.go(758 B)
📄 unsafebuiltins.go(1.29 KB)
📄 used.go(5.96 KB)
📄 utf.go(1.19 KB)
📄 varerr.go(449 B)
📄 varinit.go(509 B)
📄 winbatch.go(1.97 KB)
📄 writebarrier.go(5.57 KB)
📄 zerodivide.go(5.71 KB)

Editing: 64bit.go

// runoutput

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Generate test of 64-bit arithmetic.
// Most synthesized routines have different cases for
// constants vs variables and even the generated code has
// different cases for large and small constants,
// so try a good range of inputs.

package main

import (
	"bufio"
	"fmt"
	"os"
)

var bout *bufio.Writer

// 64-bit math without using 64-bit numbers,
// so that we can generate the test program even
// if the compiler has buggy or missing 64-bit support.

type Uint64 struct {
	hi	uint32
	lo	uint32
}

type Int64 struct {
	hi	int32
	lo	uint32
}

func (a Uint64) Int64() (c Int64) {
	c.hi = int32(a.hi)
	c.lo = a.lo
	return
}

func (a Uint64) Cmp(b Uint64) int {
	switch {
	case a.hi < b.hi:
		return -1
	case a.hi > b.hi:
		return 1
	case a.lo < b.lo:
		return -1
	case a.lo > b.lo:
		return 1
	}
	return 0
}

func (a Uint64) LeftShift(b uint) (c Uint64) {
	switch {
	case b >= 64:
		c.hi = 0
		c.lo = 0
	case b >= 32:
		c.hi = a.lo << (b - 32)
		c.lo = 0
	default:
		c.hi = a.hi<<b | a.lo>>(32-b)
		c.lo = a.lo << b
	}
	return
}

func (a Uint64) RightShift(b uint) (c Uint64) {
	switch {
	case b >= 64:
		c.hi = 0
		c.lo = a.hi
	case b >= 32:
		c.hi = 0
		c.lo = a.hi >> (b - 32)
	default:
		c.hi = a.hi >> b
		c.lo = a.hi<<(32-b) | a.lo>>b
	}
	return
}

func (a Uint64) LeftShift64(b Uint64) (c Uint64) {
	if b.hi != 0 || b.lo >= 64 {
		return
	}
	return a.LeftShift(uint(b.lo))
}

func (a Uint64) RightShift64(b Uint64) (c Uint64) {
	if b.hi != 0 || b.lo >= 64 {
		return
	}
	return a.RightShift(uint(b.lo))
}

func (a Uint64) Plus(b Uint64) (c Uint64) {
	var carry uint32
	if c.lo = a.lo + b.lo; c.lo < a.lo {
		carry = 1
	}
	c.hi = a.hi + b.hi + carry
	return
}

func (a Uint64) Minus(b Uint64) (c Uint64) {
	var borrow uint32
	if c.lo = a.lo - b.lo; c.lo > a.lo {
		borrow = 1
	}
	c.hi = a.hi - b.hi - borrow
	return
}

func (a Uint64) Neg() (c Uint64) {
	var zero Uint64
	return zero.Minus(a)
}

func (a Uint64) Com() (c Uint64) {
	c.hi = ^a.hi
	c.lo = ^a.lo
	return
}

func (a Uint64) Len() int {
	switch {
	case a.hi != 0:
		for i := 31; i >= 0; i-- {
			if a.hi&(1<<uint(i)) != 0 {
				return i + 1 + 32
			}
		}
	case a.lo != 0:
		for i := 31; i >= 0; i-- {
			if a.lo&(1<<uint(i)) != 0 {
				return i + 1
			}
		}
	}
	return 0
}

func (a Uint64) HasBit(b uint) bool {
	switch {
	case b >= 64:
		return false
	case b >= 32:
		return a.hi&(1<<(b-32)) != 0
	}
	return a.lo&(1<<b) != 0
}

func (a Uint64) Times(b Uint64) (c Uint64) {
	for i := uint(0); i < 64; i++ {
		if b.HasBit(i) {
			c = c.Plus(a.LeftShift(i))
		}
	}
	return
}

func (a Uint64) DivMod(b Uint64) (quo, rem Uint64) {
	n := a.Len() - b.Len()
	if n >= 0 {
		b = b.LeftShift(uint(n))
		for i := 0; i <= n; i++ {
			quo = quo.LeftShift(1)
			if b.Cmp(a) <= 0 {	// b <= a
				quo.lo |= 1
				a = a.Minus(b)
			}
			b = b.RightShift(1)
		}
	}
	rem = a
	return
}

func (a Uint64) And(b Uint64) (c Uint64) {
	c.hi = a.hi & b.hi
	c.lo = a.lo & b.lo
	return
}

func (a Uint64) AndNot(b Uint64) (c Uint64) {
	c.hi = a.hi &^ b.hi
	c.lo = a.lo &^ b.lo
	return
}

func (a Uint64) Or(b Uint64) (c Uint64) {
	c.hi = a.hi | b.hi
	c.lo = a.lo | b.lo
	return
}

func (a Uint64) Xor(b Uint64) (c Uint64) {
	c.hi = a.hi ^ b.hi
	c.lo = a.lo ^ b.lo
	return
}

func (a Uint64) String() string	{ return fmt.Sprintf("%#x%08x", a.hi, a.lo) }

func (a Int64) Uint64() (c Uint64) {
	c.hi = uint32(a.hi)
	c.lo = a.lo
	return
}

func (a Int64) Cmp(b Int64) int {
	// Same body as Uint64.Cmp,
	// but behaves differently
	// because hi is uint32 not int32.
	switch {
	case a.hi < b.hi:
		return -1
	case a.hi > b.hi:
		return 1
	case a.lo < b.lo:
		return -1
	case a.lo > b.lo:
		return 1
	}
	return 0
}

func (a Int64) LeftShift(b uint) (c Int64)	{ return a.Uint64().LeftShift(b).Int64() }

func (a Int64) RightShift(b uint) (c Int64) {
	switch {
	case b >= 64:
		c.hi = a.hi >> 31	// sign extend
		c.lo = uint32(c.hi)
	case b >= 32:
		c.hi = a.hi >> 31	// sign extend
		c.lo = uint32(a.hi >> (b - 32))
	default:
		c.hi = a.hi >> b
		c.lo = uint32(a.hi<<(32-b)) | a.lo>>b
	}
	return
}

func (a Int64) LeftShift64(b Uint64) (c Int64) {
	if b.hi != 0 || b.lo >= 64 {
		return
	}
	return a.LeftShift(uint(b.lo))
}

func (a Int64) RightShift64(b Uint64) (c Int64) {
	if b.hi != 0 || b.lo >= 64 {
		return a.RightShift(64)
	}
	return a.RightShift(uint(b.lo))
}

func (a Int64) Plus(b Int64) (c Int64)	{ return a.Uint64().Plus(b.Uint64()).Int64() }

func (a Int64) Minus(b Int64) (c Int64)	{ return a.Uint64().Minus(b.Uint64()).Int64() }

func (a Int64) Neg() (c Int64)	{ return a.Uint64().Neg().Int64() }

func (a Int64) Com() (c Int64)	{ return a.Uint64().Com().Int64() }

func (a Int64) Times(b Int64) (c Int64)	{ return a.Uint64().Times(b.Uint64()).Int64() }

func (a Int64) DivMod(b Int64) (quo Int64, rem Int64) {
	var zero Int64

quoSign := +1
	remSign := +1
	if a.Cmp(zero) < 0 {
		quoSign = -1
		remSign = -1
		a = a.Neg()
	}
	if b.Cmp(zero) < 0 {
		quoSign = -quoSign
		b = b.Neg()
	}

q, r := a.Uint64().DivMod(b.Uint64())
	quo = q.Int64()
	rem = r.Int64()

if quoSign < 0 {
		quo = quo.Neg()
	}
	if remSign < 0 {
		rem = rem.Neg()
	}
	return
}

func (a Int64) And(b Int64) (c Int64)	{ return a.Uint64().And(b.Uint64()).Int64() }

func (a Int64) AndNot(b Int64) (c Int64)	{ return a.Uint64().AndNot(b.Uint64()).Int64() }

func (a Int64) Or(b Int64) (c Int64)	{ return a.Uint64().Or(b.Uint64()).Int64() }

func (a Int64) Xor(b Int64) (c Int64)	{ return a.Uint64().Xor(b.Uint64()).Int64() }

func (a Int64) String() string {
	if a.hi < 0 {
		return fmt.Sprintf("-%s", a.Neg().Uint64())
	}
	return a.Uint64().String()
}

var int64Values = []Int64{
	Int64{0, 0},
	Int64{0, 1},
	Int64{0, 2},
	Int64{0, 3},
	Int64{0, 100},
	Int64{0, 10001},
	Int64{0, 1<<31 - 1},
	Int64{0, 1 << 31},
	Int64{0, 1<<31 + 1},
	Int64{0, 1<<32 - 1<<30},
	Int64{0, 1<<32 - 1},
	Int64{1, 0},
	Int64{1, 1},
	Int64{2, 0},
	Int64{1<<31 - 1, 1<<32 - 10000},
	Int64{1<<31 - 1, 1<<32 - 1},
	Int64{0x789abcde, 0xf0123456},

Int64{-1, 1<<32 - 1},
	Int64{-1, 1<<32 - 2},
	Int64{-1, 1<<32 - 3},
	Int64{-1, 1<<32 - 100},
	Int64{-1, 1<<32 - 10001},
	Int64{-1, 1<<32 - (1<<31 - 1)},
	Int64{-1, 1<<32 - 1<<31},
	Int64{-1, 1<<32 - (1<<31 + 1)},
	Int64{-1, 1<<32 - (1<<32 - 1<<30)},
	Int64{-1, 0},
	Int64{-1, 1},
	Int64{-2, 0},
	Int64{-(1 << 31), 10000},
	Int64{-(1 << 31), 1},
	Int64{-(1 << 31), 0},
	Int64{-0x789abcde, 0xf0123456},
}

var uint64Values = []Uint64{
	Uint64{0, 0},
	Uint64{0, 1},
	Uint64{0, 2},
	Uint64{0, 3},
	Uint64{0, 100},
	Uint64{0, 10001},
	Uint64{0, 1<<31 - 1},
	Uint64{0, 1 << 31},
	Uint64{0, 1<<31 + 1},
	Uint64{0, 1<<32 - 1<<30},
	Uint64{0, 1<<32 - 1},
	Uint64{1, 0},
	Uint64{1, 1},
	Uint64{2, 0},
	Uint64{1<<31 - 1, 1<<32 - 10000},
	Uint64{1<<31 - 1, 1<<32 - 1},
	Uint64{1<<32 - 1<<30, 0},
	Uint64{1<<32 - 1, 0},
	Uint64{1<<32 - 1, 1<<32 - 100},
	Uint64{1<<32 - 1, 1<<32 - 1},
	Uint64{0x789abcde, 0xf0123456},
	Uint64{0xfedcba98, 0x76543210},
}

var shiftValues = []Uint64{
	Uint64{0, 0},
	Uint64{0, 1},
	Uint64{0, 2},
	Uint64{0, 3},
	Uint64{0, 15},
	Uint64{0, 16},
	Uint64{0, 17},
	Uint64{0, 31},
	Uint64{0, 32},
	Uint64{0, 33},
	Uint64{0, 61},
	Uint64{0, 62},
	Uint64{0, 63},
	Uint64{0, 64},
	Uint64{0, 65},
	Uint64{0, 1<<32 - 1},
	Uint64{1, 0},
	Uint64{1, 1},
	Uint64{1 << 28, 0},
	Uint64{1 << 31, 0},
	Uint64{1<<32 - 1, 0},
	Uint64{1<<32 - 1, 1<<32 - 1},
}

var ntest = 0

// Part 1 is tests of variable operations; generic functions
// called by repetitive code.  Could make a table but not worth it.

func varTests() {
	fmt.Fprint(bout, prolog)
	for _, a := range int64Values {
		fmt.Fprintf(bout, "func test%v() {\n", ntest)
		ntest++
		fmt.Fprintf(bout, "\ttestInt64Unary(%v, %v, %v, %v);\n", a, a, a.Com(), a.Neg())
		for _, b := range int64Values {
			var div, mod Int64
			dodiv := false
			var zero Int64
			if b.Cmp(zero) != 0 {	// b != 0
				// Can't divide by zero but also can't divide -0x8000...000 by -1.
				var bigneg = Int64{-0x80000000, 0}
				var minus1 = Int64{-1, ^uint32(0)}
				if a.Cmp(bigneg) != 0 || b.Cmp(minus1) != 0 {	// a != -1<<63 || b != -1
					div, mod = a.DivMod(b)
					dodiv = true
				}
			}
			fmt.Fprintf(bout, "\ttestInt64Binary(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n",
				a, b, a.Plus(b), a.Minus(b), a.Times(b), div, mod,
				a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv)
		}
		for _, b := range shiftValues {
			fmt.Fprintf(bout, "\ttestInt64Shift(%v, %v, %v, %v);\n",
				a, b, a.LeftShift64(b), a.RightShift64(b))
		}
		fmt.Fprintf(bout, "}\n")
	}

for _, a := range uint64Values {
		fmt.Fprintf(bout, "func test%v() {\n", ntest)
		ntest++
		fmt.Fprintf(bout, "\ttestUint64Unary(%v, %v, %v, %v);\n", a, a, a.Com(), a.Neg())
		for _, b := range uint64Values {
			var div, mod Uint64
			dodiv := false
			var zero Uint64
			if b.Cmp(zero) != 0 {	// b != 0
				div, mod = a.DivMod(b)
				dodiv = true
			}
			fmt.Fprintf(bout, "\ttestUint64Binary(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n",
				a, b, a.Plus(b), a.Minus(b), a.Times(b), div, mod,
				a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv)
		}
		for _, b := range shiftValues {
			fmt.Fprintf(bout, "\ttestUint64Shift(%v, %v, %v, %v);\n",
				a, b, a.LeftShift64(b), a.RightShift64(b))
		}
		fmt.Fprintf(bout, "}\n")
	}
}

// Part 2 is tests of operations involving one variable and one constant.

func constTests() {
	for i, a := range int64Values {
		fmt.Fprintf(bout, binaryConstL, "Int64", i, "int64", "int64", a, "int64")
		if a.hi == 0 && a.lo == 0 {
			fmt.Fprintf(bout, binaryConstR0, "Int64", i, "int64", "int64", a, "int64")
		} else {
			fmt.Fprintf(bout, binaryConstR, "Int64", i, "int64", "int64", a, "int64")
		}
		fmt.Fprintf(bout, shiftConstL, "Int64", i, "int64", "int64", a, "int64")
	}
	for i, a := range uint64Values {
		fmt.Fprintf(bout, binaryConstL, "Uint64", i, "uint64", "uint64", a, "uint64")
		if a.hi == 0 && a.lo == 0 {
			fmt.Fprintf(bout, binaryConstR0, "Uint64", i, "uint64", "uint64", a, "uint64")
		} else {
			fmt.Fprintf(bout, binaryConstR, "Uint64", i, "uint64", "uint64", a, "uint64")
		}
		fmt.Fprintf(bout, shiftConstL, "Uint64", i, "uint64", "uint64", a, "uint64")
	}
	for i, a := range shiftValues {
		fmt.Fprintf(bout, shiftConstR, "Int64", i, "int64", a, "int64")
		fmt.Fprintf(bout, shiftConstR, "Uint64", i, "uint64", a, "uint64")
	}
	for i, a := range int64Values {
		fmt.Fprintf(bout, "func test%v() {\n", ntest)
		ntest++
		for j, b := range int64Values {
			var div, mod Int64
			dodiv := false
			var zero Int64
			if b.Cmp(zero) != 0 {	// b != 0
				// Can't divide by zero but also can't divide -0x8000...000 by -1.
				var bigneg = Int64{-0x80000000, 0}
				var minus1 = Int64{-1, ^uint32(0)}
				if a.Cmp(bigneg) != 0 || b.Cmp(minus1) != 0 {	// a != -1<<63 || b != -1
					div, mod = a.DivMod(b)
					dodiv = true
				}
			}
			fmt.Fprintf(bout, "\ttestInt64BinaryL%v(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n",
				i, b, a.Plus(b), a.Minus(b), a.Times(b), div, mod,
				a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv)
			fmt.Fprintf(bout, "\ttestInt64BinaryR%v(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n",
				j, a, a.Plus(b), a.Minus(b), a.Times(b), div, mod,
				a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv)
		}
		for j, b := range shiftValues {
			fmt.Fprintf(bout, "\ttestInt64ShiftL%v(%v, %v, %v);\n",
				i, b, a.LeftShift64(b), a.RightShift64(b))
			fmt.Fprintf(bout, "\ttestInt64ShiftR%v(%v, %v, %v);\n",
				j, a, a.LeftShift64(b), a.RightShift64(b))
		}
		fmt.Fprintf(bout, "}\n")
	}
	for i, a := range uint64Values {
		fmt.Fprintf(bout, "func test%v() {\n", ntest)
		ntest++
		for j, b := range uint64Values {
			var div, mod Uint64
			dodiv := false
			var zero Uint64
			if b.Cmp(zero) != 0 {	// b != 0
				div, mod = a.DivMod(b)
				dodiv = true
			}
			fmt.Fprintf(bout, "\ttestUint64BinaryL%v(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n",
				i, b, a.Plus(b), a.Minus(b), a.Times(b), div, mod,
				a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv)
			fmt.Fprintf(bout, "\ttestUint64BinaryR%v(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n",
				j, a, a.Plus(b), a.Minus(b), a.Times(b), div, mod,
				a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv)
		}
		for j, b := range shiftValues {
			fmt.Fprintf(bout, "\ttestUint64ShiftL%v(%v, %v, %v);\n",
				i, b, a.LeftShift64(b), a.RightShift64(b))
			fmt.Fprintf(bout, "\ttestUint64ShiftR%v(%v, %v, %v);\n",
				j, a, a.LeftShift64(b), a.RightShift64(b))
		}
		fmt.Fprintf(bout, "}\n")
	}
}

func main() {
	bout = bufio.NewWriter(os.Stdout)
	varTests()
	constTests()

fmt.Fprintf(bout, "func main() {\n")
	for i := 0; i < ntest; i++ {
		fmt.Fprintf(bout, "\ttest%v();\n", i)
	}
	fmt.Fprintf(bout, "\tif !ok { os.Exit(1) }\n")
	fmt.Fprintf(bout, "}\n")
	bout.Flush()
}

X7ROOT File Manager

Editing: 64bit.go

Upload File

Create Folder