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

include ../../../Make.inc

TARG=container/vector
GOFILES=\
	defs.go\
	intvector.go\
	stringvector.go\
	vector.go\

include ../../../Make.pkg

generate: vector.go vector_test.go
	< vector.go cat\
	| gofmt -r='Vector -> IntVector'\
	| gofmt -r='interface{} -> int'\
	> intvector.go\
	
	< vector.go cat\
	| gofmt -r='Vector -> StringVector'\
	| gofmt -r='interface{} -> string'\
	> stringvector.go\
	
	< vector_test.go cat\
	| gofmt -r='Vector -> IntVector'\
	| gofmt -r='zero -> intzero'\
	| gofmt -r='elem2Value -> elem2IntValue'\
	| gofmt -r='intf2Value -> intf2IntValue'\
	| gofmt -r='int2Value -> int2IntValue'\
	| gofmt -r='TestZeroLen -> TestIntZeroLen'\
	| gofmt -r='TestResize -> TestIntResize'\
	| gofmt -r='TestResize2 -> TestIntResize2'\
	| gofmt -r='checkZero -> checkIntZero'\
	| gofmt -r='TestTrailingElements -> TestIntTrailingElements'\
	| gofmt -r='TestAccess -> TestIntAccess'\
	| gofmt -r='TestInsertDeleteClear -> TestIntInsertDeleteClear'\
	| gofmt -r='verify_slice -> verify_sliceInt'\
	| gofmt -r='verify_pattern -> verify_patternInt'\
	| gofmt -r='make_vector -> make_vectorInt'\
	| gofmt -r='TestInsertVector -> TestIntInsertVector'\
	| gofmt -r='TestDo -> TestIntDo'\
	| gofmt -r='TestVectorCopy -> TestIntVectorCopy'\
	| gofmt -r='interface{} -> int'\
	> intvector_test.go\
	
	< vector_test.go cat\
	| gofmt -r='Vector -> StringVector'\
	| gofmt -r='zero -> strzero'\
	| gofmt -r='int2Value -> int2StrValue'\
	| gofmt -r='intf2Value -> intf2StrValue'\
	| gofmt -r='elem2Value -> elem2StrValue'\
	| gofmt -r='TestZeroLen -> TestStrZeroLen'\
	| gofmt -r='TestResize -> TestStrResize'\
	| gofmt -r='TestResize2 -> TestStrResize2'\
	| gofmt -r='checkZero -> checkStrZero'\
	| gofmt -r='TestTrailingElements -> TestStrTrailingElements'\
	| gofmt -r='TestAccess -> TestStrAccess'\
	| gofmt -r='TestInsertDeleteClear -> TestStrInsertDeleteClear'\
	| gofmt -r='verify_slice -> verify_sliceStr'\
	| gofmt -r='verify_pattern -> verify_patternStr'\
	| gofmt -r='make_vector -> make_vectorStr'\
	| gofmt -r='TestInsertVector -> TestStrInsertVector'\
	| gofmt -r='TestDo -> TestStrDo'\
	| gofmt -r='TestVectorCopy -> TestStrVectorCopy'\
	| gofmt -r='interface{} -> string'\
	> stringvector_test.go
