// the backtracker using prog.
func maxBitStateLen(prog *syntax.Prog) int {
	if !shouldBacktrack(prog) {
		return 0
	}
	return maxBacktrackVector / len(prog.Inst)
}

// shouldBacktrack reports whether the program is too
// long for the backtracker to run.
func shouldBacktrack(prog *syntax.Prog) bool {
	return len(prog.Inst) <= maxBacktrackProg
}

fi

exec="$FESS_HOME/bin/fess"
prog="fess"
pidfile="$PID_DIR/${prog}.pid"

export FESS_TEMP_PATH
export FESS_LOG_PATH
export FESS_CONF_PATH
export FESS_VAR_PATH
export FESS_DICTIONARY_PATH
export FESS_HEAP_SIZE
export SEARCH_ENGINE_HOME
export SEARCH_ENGINE_HTTP_URL
export FESS_JAVA_OPTS
export JAVA_HOME

lockfile=/var/lock/subsys/$prog

// Test source files and strings containing \r and \r\n.

package main

import (
	"fmt"
	"strings"
)

func main() {
	prog = strings.Replace(prog, "BQ", "`", -1)
	prog = strings.Replace(prog, "CR", "\r", -1)
	fmt.Print(prog)
}

var prog = `
package main
CR

import "fmt"

var CR s = "hello\n" + CR
	" world"CR

var t = BQhelloCR
 worldBQ

var u = BQhCReCRlCRlCRoCR

	//
	// Unfortunately, it provides no means of escaping interior quotation marks
	// within that program name, and we have no way to report them here.
	prog := args[0]
	mustQuote := len(prog) == 0
	for i := 0; i < len(prog); i++ {
		c := prog[i]
		if c <= ' ' || (c == '"' && i == 0) {
			// Force quotes for not only the ASCII space and tab as described in the
			// MSDN article, but also ASCII control characters.

stderr 'link.* -X=x.y=z'

# -ldflags applies to link of command
go build -a -n -ldflags=-X=math.pi=3 my/cmd/prog
stderr 'link.* -X=math.pi=3'

# -ldflags applies to link of command even with strange directory name
go build -a -n -ldflags=-X=math.pi=3 my/cmd/prog/
stderr 'link.* -X=math.pi=3'

# -ldflags applies to current directory
cd my/cmd/prog
go build -a -n -ldflags=-X=math.pi=3
stderr 'link.* -X=math.pi=3'

var p, pc int
var a [30000]byte

const prog = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.!"

func scan(dir int) {
	for nest := dir; dir*nest > 0; pc += dir {
		switch prog[pc+dir] {
		case ']':
			nest--
		case '[':
			nest++
		}
	}
}

func main() {
	r := ""
	for {
		switch prog[pc] {
		case '>':
			p++
		case '<':
			p--

		t.Skipf("skipping on %s/%s: no DWARF symbol table in executables", runtime.GOOS, runtime.GOARCH)
	}

	t.Parallel()

	for _, prog := range []string{"testprog", "testprogcgo"} {
		prog := prog
		expectDWARF := expectDWARF
		if runtime.GOOS == "aix" && prog == "testprogcgo" {
			extld := os.Getenv("CC")
			if extld == "" {
				extld = "gcc"
			}
			extldArgs, err := quoted.Split(extld)
			if err != nil {

[short] skip

# collect coverage profile in text format
go test -coverprofile=blah.prof prog.go prog_test.go

# should not contain cmd-line pseudo-import-path
grep prog.go blah.prof
grep $PWD blah.prof
! grep command-line-arguments blah.prof

-- prog.go --
package main

func Mumble(x int) int {
	if x < 0 {
		return -x
	}
	return 42
}

func Grumble(y int) int {
	return -y
}

func main() {
}

// run

// 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.

package main

func main() {
prog := "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
"xxxxxxxxxx"+
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
"xxxxxxxxxxxxxxxxxxxxxx"+
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"+

	"runtime"
	"strings"
	"testing"
)

const prog = `
package main

import "log"

func main() {
	log.Fatalf("HERE")
}
`

func TestIssue33808(t *testing.T) {
	if runtime.GOOS != "darwin" {
		return
	}
	testenv.MustHaveGoBuild(t)
	testenv.MustHaveCGO(t)
	t.Parallel()

	dir := t.TempDir()

	f := gobuild(t, dir, prog, "-ldflags=-linkmode=external")
	f.Close()