tequilaOS/platform_build_blueprint
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
platform_build_blueprint/parser/parser_test.go

523 lines
11 KiB
Go
Raw Normal View History

Add license headers and LICENSE file Change-Id: I6f7c7374093c0745ee4aa677480376a06648b358
2015-01-23 23:15:10 +01:00
// Copyright 2014 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
package parser
import (
"bytes"
"reflect"
"testing"
"text/scanner"
)
func mkpos(offset, line, column int) scanner.Position {
return scanner.Position{
Offset: offset,
Line: line,
Column: column,
}
}
var validParseTestCases = []struct {
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
input string
defs []Definition
comments []Comment
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
}{
{`
foo {}
`,
[]Definition{
&Module{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Type: Ident{"foo", mkpos(3, 2, 3)},
LbracePos: mkpos(7, 2, 7),
RbracePos: mkpos(8, 2, 8),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
},
},
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
nil,
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
},
{`
foo {
name: "abc",
}
`,
[]Definition{
&Module{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Type: Ident{"foo", mkpos(3, 2, 3)},
LbracePos: mkpos(7, 2, 7),
RbracePos: mkpos(27, 4, 3),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
Properties: []*Property{
{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Name: Ident{"name", mkpos(12, 3, 4)},
Pos: mkpos(16, 3, 8),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
Value: Value{
Type: String,
Pos: mkpos(18, 3, 10),
StringValue: "abc",
},
},
},
},
},
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
nil,
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
},
{`
foo {
isGood: true,
}
`,
[]Definition{
&Module{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Type: Ident{"foo", mkpos(3, 2, 3)},
LbracePos: mkpos(7, 2, 7),
RbracePos: mkpos(28, 4, 3),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
Properties: []*Property{
{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Name: Ident{"isGood", mkpos(12, 3, 4)},
Pos: mkpos(18, 3, 10),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
Value: Value{
Type: Bool,
Pos: mkpos(20, 3, 12),
BoolValue: true,
},
},
},
},
},
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
nil,
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
},
{`
foo {
stuff: ["asdf", "jkl;", "qwert",
"uiop", "bnm,"]
}
`,
[]Definition{
&Module{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Type: Ident{"foo", mkpos(3, 2, 3)},
LbracePos: mkpos(7, 2, 7),
RbracePos: mkpos(67, 5, 3),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
Properties: []*Property{
{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Name: Ident{"stuff", mkpos(12, 3, 4)},
Pos: mkpos(17, 3, 9),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
Value: Value{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Type: List,
Pos: mkpos(19, 3, 11),
EndPos: mkpos(63, 4, 19),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
ListValue: []Value{
Value{
Type: String,
Pos: mkpos(20, 3, 12),
StringValue: "asdf",
},
Value{
Type: String,
Pos: mkpos(28, 3, 20),
StringValue: "jkl;",
},
Value{
Type: String,
Pos: mkpos(36, 3, 28),
StringValue: "qwert",
},
Value{
Type: String,
Pos: mkpos(49, 4, 5),
StringValue: "uiop",
},
Value{
Type: String,
Pos: mkpos(57, 4, 13),
StringValue: "bnm,",
},
},
},
},
},
},
},
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
nil,
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
},
Add support for map properties Example: foo { // string property name: "hello", // map property translations: { ge: "guten tag", fr: "bonjour", }, } Change-Id: Ib9e6570cb6f355677b4ba0235e8fb4186e40f5f8
2014-07-26 02:01:20 +02:00
{`
foo {
stuff: {
isGood: true,
name: "bar"
}
}
`,
[]Definition{
&Module{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Type: Ident{"foo", mkpos(3, 2, 3)},
LbracePos: mkpos(7, 2, 7),
RbracePos: mkpos(62, 7, 3),
Add support for map properties Example: foo { // string property name: "hello", // map property translations: { ge: "guten tag", fr: "bonjour", }, } Change-Id: Ib9e6570cb6f355677b4ba0235e8fb4186e40f5f8
2014-07-26 02:01:20 +02:00
Properties: []*Property{
{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Name: Ident{"stuff", mkpos(12, 3, 4)},
Pos: mkpos(17, 3, 9),
Add support for map properties Example: foo { // string property name: "hello", // map property translations: { ge: "guten tag", fr: "bonjour", }, } Change-Id: Ib9e6570cb6f355677b4ba0235e8fb4186e40f5f8
2014-07-26 02:01:20 +02:00
Value: Value{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Type: Map,
Pos: mkpos(19, 3, 11),
EndPos: mkpos(58, 6, 4),
Add support for map properties Example: foo { // string property name: "hello", // map property translations: { ge: "guten tag", fr: "bonjour", }, } Change-Id: Ib9e6570cb6f355677b4ba0235e8fb4186e40f5f8
2014-07-26 02:01:20 +02:00
MapValue: []*Property{
{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Name: Ident{"isGood", mkpos(25, 4, 5)},
Pos: mkpos(31, 4, 11),
Add support for map properties Example: foo { // string property name: "hello", // map property translations: { ge: "guten tag", fr: "bonjour", }, } Change-Id: Ib9e6570cb6f355677b4ba0235e8fb4186e40f5f8
2014-07-26 02:01:20 +02:00
Value: Value{
Type: Bool,
Pos: mkpos(33, 4, 13),
BoolValue: true,
},
},
{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Name: Ident{"name", mkpos(43, 5, 5)},
Pos: mkpos(47, 5, 9),
Add support for map properties Example: foo { // string property name: "hello", // map property translations: { ge: "guten tag", fr: "bonjour", }, } Change-Id: Ib9e6570cb6f355677b4ba0235e8fb4186e40f5f8
2014-07-26 02:01:20 +02:00
Value: Value{
Type: String,
Pos: mkpos(49, 5, 11),
StringValue: "bar",
},
},
},
},
},
},
},
},
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
nil,
Add support for map properties Example: foo { // string property name: "hello", // map property translations: { ge: "guten tag", fr: "bonjour", }, } Change-Id: Ib9e6570cb6f355677b4ba0235e8fb4186e40f5f8
2014-07-26 02:01:20 +02:00
},
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
{`
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
// comment1
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
foo {
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
// comment2
isGood: true, // comment3
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
}
`,
[]Definition{
&Module{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Type: Ident{"foo", mkpos(17, 3, 3)},
LbracePos: mkpos(21, 3, 7),
RbracePos: mkpos(70, 6, 3),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
Properties: []*Property{
{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Name: Ident{"isGood", mkpos(41, 5, 4)},
Pos: mkpos(47, 5, 10),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
Value: Value{
Type: Bool,
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Pos: mkpos(49, 5, 12),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
BoolValue: true,
},
},
},
},
},
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
[]Comment{
Comment{
Comment: "// comment1",
Pos: mkpos(3, 2, 3),
},
Comment{
Comment: "// comment2",
Pos: mkpos(26, 4, 4),
},
Comment{
Comment: "// comment3",
Pos: mkpos(56, 5, 19),
},
},
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
},
{`
foo {
name: "abc",
}
bar {
name: "def",
}
`,
[]Definition{
&Module{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Type: Ident{"foo", mkpos(3, 2, 3)},
LbracePos: mkpos(7, 2, 7),
RbracePos: mkpos(27, 4, 3),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
Properties: []*Property{
{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Name: Ident{"name", mkpos(12, 3, 4)},
Pos: mkpos(16, 3, 8),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
Value: Value{
Type: String,
Pos: mkpos(18, 3, 10),
StringValue: "abc",
},
},
},
},
&Module{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Type: Ident{"bar", mkpos(32, 6, 3)},
LbracePos: mkpos(36, 6, 7),
RbracePos: mkpos(56, 8, 3),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
Properties: []*Property{
{
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
Name: Ident{"name", mkpos(41, 7, 4)},
Pos: mkpos(45, 7, 8),
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
Value: Value{
Type: String,
Pos: mkpos(47, 7, 10),
StringValue: "def",
},
},
},
},
},
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
nil,
},
{`
foo = "stuff"
bar = foo
baz = foo + bar
Support += assignments Support += assignments to variables. Variables are now mutable up until they are referenced, then they become immutable. This will allow variables to be modified in a conditional, or allow better commenting on why parts of a variable are set. Change-Id: Iad964da7206b493365fe3686eedd7954e6eaf9a2
2015-02-04 19:50:22 +01:00
boo = baz
boo += foo
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
`,
[]Definition{
&Assignment{
Name: Ident{"foo", mkpos(3, 2, 3)},
Pos: mkpos(7, 2, 7),
Value: Value{
Type: String,
Pos: mkpos(9, 2, 9),
StringValue: "stuff",
},
Support += assignments Support += assignments to variables. Variables are now mutable up until they are referenced, then they become immutable. This will allow variables to be modified in a conditional, or allow better commenting on why parts of a variable are set. Change-Id: Iad964da7206b493365fe3686eedd7954e6eaf9a2
2015-02-04 19:50:22 +01:00
OrigValue: Value{
Type: String,
Pos: mkpos(9, 2, 9),
StringValue: "stuff",
},
Assigner: "=",
Referenced: true,
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
},
&Assignment{
Name: Ident{"bar", mkpos(19, 3, 3)},
Pos: mkpos(23, 3, 7),
Value: Value{
Type: String,
Pos: mkpos(25, 3, 9),
StringValue: "stuff",
Variable: "foo",
},
Support += assignments Support += assignments to variables. Variables are now mutable up until they are referenced, then they become immutable. This will allow variables to be modified in a conditional, or allow better commenting on why parts of a variable are set. Change-Id: Iad964da7206b493365fe3686eedd7954e6eaf9a2
2015-02-04 19:50:22 +01:00
OrigValue: Value{
Type: String,
Pos: mkpos(25, 3, 9),
StringValue: "stuff",
Variable: "foo",
},
Assigner: "=",
Referenced: true,
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
},
&Assignment{
Name: Ident{"baz", mkpos(31, 4, 3)},
Pos: mkpos(35, 4, 7),
Value: Value{
Type: String,
Pos: mkpos(37, 4, 9),
StringValue: "stuffstuff",
Expression: &Expression{
Args: [2]Value{
{
Type: String,
Pos: mkpos(37, 4, 9),
StringValue: "stuff",
Variable: "foo",
},
{
Type: String,
Pos: mkpos(43, 4, 15),
StringValue: "stuff",
Variable: "bar",
},
},
Operator: '+',
Pos: mkpos(41, 4, 13),
},
},
Support += assignments Support += assignments to variables. Variables are now mutable up until they are referenced, then they become immutable. This will allow variables to be modified in a conditional, or allow better commenting on why parts of a variable are set. Change-Id: Iad964da7206b493365fe3686eedd7954e6eaf9a2
2015-02-04 19:50:22 +01:00
OrigValue: Value{
Type: String,
Pos: mkpos(37, 4, 9),
StringValue: "stuffstuff",
Expression: &Expression{
Args: [2]Value{
{
Type: String,
Pos: mkpos(37, 4, 9),
StringValue: "stuff",
Variable: "foo",
},
{
Type: String,
Pos: mkpos(43, 4, 15),
StringValue: "stuff",
Variable: "bar",
},
},
Operator: '+',
Pos: mkpos(41, 4, 13),
},
},
Assigner: "=",
Referenced: true,
},
&Assignment{
Name: Ident{"boo", mkpos(49, 5, 3)},
Pos: mkpos(53, 5, 7),
Value: Value{
Type: String,
Pos: mkpos(55, 5, 9),
StringValue: "stuffstuffstuff",
Expression: &Expression{
Args: [2]Value{
{
Type: String,
Pos: mkpos(55, 5, 9),
StringValue: "stuffstuff",
Variable: "baz",
Expression: &Expression{
Args: [2]Value{
{
Type: String,
Pos: mkpos(37, 4, 9),
StringValue: "stuff",
Variable: "foo",
},
{
Type: String,
Pos: mkpos(43, 4, 15),
StringValue: "stuff",
Variable: "bar",
},
},
Operator: '+',
Pos: mkpos(41, 4, 13),
},
},
{
Variable: "foo",
Type: String,
Pos: mkpos(68, 6, 10),
StringValue: "stuff",
},
},
Pos: mkpos(66, 6, 8),
Operator: '+',
},
},
OrigValue: Value{
Type: String,
Pos: mkpos(55, 5, 9),
StringValue: "stuffstuff",
Variable: "baz",
Expression: &Expression{
Args: [2]Value{
{
Type: String,
Pos: mkpos(37, 4, 9),
StringValue: "stuff",
Variable: "foo",
},
{
Type: String,
Pos: mkpos(43, 4, 15),
StringValue: "stuff",
Variable: "bar",
},
},
Operator: '+',
Pos: mkpos(41, 4, 13),
},
},
Assigner: "=",
},
&Assignment{
Name: Ident{"boo", mkpos(61, 6, 3)},
Pos: mkpos(66, 6, 8),
Value: Value{
Type: String,
Pos: mkpos(68, 6, 10),
StringValue: "stuff",
Variable: "foo",
},
OrigValue: Value{
Type: String,
Pos: mkpos(68, 6, 10),
StringValue: "stuff",
Variable: "foo",
},
Assigner: "+=",
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
},
},
nil,
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
},
}
func TestParseValidInput(t *testing.T) {
for _, testCase := range validParseTestCases {
r := bytes.NewBufferString(testCase.input)
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
file, errs := Parse("", r, NewScope(nil))
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
if len(errs) != 0 {
t.Errorf("test case: %s", testCase.input)
t.Errorf("unexpected errors:")
for _, err := range errs {
t.Errorf(" %s", err)
}
t.FailNow()
}
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
if len(file.Defs) == len(testCase.defs) {
for i := range file.Defs {
if !reflect.DeepEqual(file.Defs[i], testCase.defs[i]) {
t.Errorf("test case: %s", testCase.input)
t.Errorf("incorrect defintion %d:", i)
t.Errorf(" expected: %s", testCase.defs[i])
t.Errorf(" got: %s", file.Defs[i])
}
}
} else {
t.Errorf("test case: %s", testCase.input)
t.Errorf("length mismatch, expected %d definitions, got %d",
len(testCase.defs), len(file.Defs))
}
if len(file.Comments) == len(testCase.comments) {
for i := range file.Comments {
if !reflect.DeepEqual(file.Comments, testCase.comments) {
t.Errorf("test case: %s", testCase.input)
t.Errorf("incorrect comment %d:", i)
t.Errorf(" expected: %s", testCase.comments[i])
t.Errorf(" got: %s", file.Comments[i])
}
}
} else {
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
t.Errorf("test case: %s", testCase.input)
Return comment and position information from parser Return comment info from parser, which will be used later for pretty printing a parsed Blueprint file. Also add more position information to the AST. Change-Id: I3cf0ba8ea4ba5b931d032098ae5fdc350806ed98
2015-01-08 23:56:03 +01:00
t.Errorf("length mismatch, expected %d comments, got %d",
len(testCase.comments), len(file.Comments))
Initial Blueprint commit. Blueprint is a build system component that reads Blueprints files defining modules to be built, and generates a Ninja build manifest that can be used to perform all the build actions. It does not dictate or implement much build policy itself, but rather provides a framework to ease the process of defining build logic in Go. The "blueprint" and "blueprint/parser" Go packages contain the functionality for reading Blueprint files and invoking build logic functions defined in other Go packages. The "blueprint/bootstrap" Go package contains just enough build logic to build a binary that includes Blueprint and any pure-Go (i.e. no cgo) build logic defined in external Go packages. This can be used to create a minimal Ninja file that's capable of bootstrapping a Blueprint-based build system from source. The "blueprint/bootstrap/minibp" Go package contains code for a minimal binary that includes the build logic defined in the "blueprint/bootstrap" package. This binary can then create the Ninja file for the bootstrapping process. Change-Id: I8d8390042372a72d225785cda738525001b009f1
2014-05-28 01:34:41 +02:00
}
}
}
// TODO: Test error strings
Reference in a new issue Copy permalink