go/bindata
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fixes some code comments.

Browse Source
This commit is contained in:
Jim Teeuwen 2013-11-01 10:27:50 +01:00
parent a36b3d3839
commit f5e037a829
1 changed files with 58 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
config.go
View File

@ -31,74 +31,68 @@ type Config struct {
// working directory. // working directory.
Output string Output string
/* // Prefix defines a path prefix which should be stripped from all
Prefix defines a path prefix which should be stripped from all // file names when generating the keys in the table of contents.
file names when generating the keys in the table of contents. // For example, running without the `-prefix` flag, we get:
For example, running without the `-prefix` flag, we get: //
// $ go-bindata /path/to/templates
$ go-bindata /path/to/templates // go_bindata["/path/to/templates/foo.html"] = _path_to_templates_foo_html
go_bindata["/path/to/templates/foo.html"] = _path_to_templates_foo_html //
// Running with the `-prefix` flag, we get:
Running with the `-prefix` flag, we get: //
// $ go-bindata -prefix "/path/to/" /path/to/templates/foo.html
$ go-bindata -prefix "/path/to/" /path/to/templates/foo.html // go_bindata["templates/foo.html"] = templates_foo_html
go_bindata["templates/foo.html"] = templates_foo_html
*/
Prefix string Prefix string
/* // NoMemCopy will alter the way the output file is generated.
NoMemCopy will alter the way the output file is generated. //
// It will employ a hack that allows us to read the file data directly from
It will employ a hack that allows us to read the file data directly from // the compiled program's `.rodata` section. This ensures that when we call
the compiled program's `.rodata` section. This ensures that when we call // call our generated function, we omit unnecessary mem copies.
call our generated function, we omit unnecessary mem copies. //
// The downside of this, is that it requires dependencies on the `reflect` and
The downside of this, is that it requires dependencies on the `reflect` and // `unsafe` packages. These may be restricted on platforms like AppEngine and
`unsafe` packages. These may be restricted on platforms like AppEngine and // thus prevent you from using this mode.
thus prevent you from using this mode. //
// Another disadvantage is that the byte slice we create, is strictly read-only.
Another disadvantage is that the byte slice we create, is strictly read-only. // For most use-cases this is not a problem, but if you ever try to alter the
For most use-cases this is not a problem, but if you ever try to alter the // returned byte slice, a runtime panic is thrown. Use this mode only on target
returned byte slice, a runtime panic is thrown. Use this mode only on target // platforms where memory constraints are an issue.
platforms where memory constraints are an issue. //
// The default behaviour is to use the old code generation method. This
The default behaviour is to use the old code generation method. This // prevents the two previously mentioned issues, but will employ at least one
prevents the two previously mentioned issues, but will employ at least one // extra memcopy and thus increase memory requirements.
extra memcopy and thus increase memory requirements. //
// For instance, consider the following two examples:
For instance, consider the following two examples: //
// This would be the default mode, using an extra memcopy but gives a safe
This would be the default mode, using an extra memcopy but gives a safe // implementation without dependencies on `reflect` and `unsafe`:
implementation without dependencies on `reflect` and `unsafe`: //
// func myfile() []byte {
func myfile() []byte { // return []byte{0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a}
return []byte{0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a} // }
} //
// Here is the same functionality, but uses the `.rodata` hack.
Here is the same functionality, but uses the `.rodata` hack. // The byte slice returned from this example can not be written to without
The byte slice returned from this example can not be written to without // generating a runtime error.
generating a runtime error. //
// var _myfile = "\x89\x50\x4e\x47\x0d\x0a\x1a"
var _myfile = "\x89\x50\x4e\x47\x0d\x0a\x1a" //
// func myfile() []byte {
func myfile() []byte { // var empty [0]byte
var empty [0]byte // sx := (*reflect.StringHeader)(unsafe.Pointer(&_myfile))
sx := (*reflect.StringHeader)(unsafe.Pointer(&_myfile)) // b := empty[:]
b := empty[:] // bx := (*reflect.SliceHeader)(unsafe.Pointer(&b))
bx := (*reflect.SliceHeader)(unsafe.Pointer(&b)) // bx.Data = sx.Data
bx.Data = sx.Data // bx.Len = len(_myfile)
bx.Len = len(_myfile) // bx.Cap = bx.Len
bx.Cap = bx.Len // return b
return b // }
}
*/
NoMemCopy bool NoMemCopy bool
/* // NoCompress means the assets are /not/ GZIP compressed before being turned
NoCompress means the assets are /not/ GZIP compressed before being turned // into Go code. The generated function will automatically unzip
into Go code. The generated function will automatically unzip // the file data when called. Defaults to false.
the file data when called. Defaults to true.
*/
NoCompress bool NoCompress bool
// Perform a debug build. This generates an asset file, which // Perform a debug build. This generates an asset file, which