Preprocessor

.snapshots/c2go-TestCLI-func1-TranspileHelpFlag

@@ -1,7 +1,9 @@
-([]string) (len=8) {
+([]string) (len=10) {
   (string) (len=59) "Usage: test transpile [-V] [-o file.go] [-p package] file.c",
   (string) (len=31) "  -V\tprint progress as comments",
   (string) (len=27) "  -h\tprint help information",
+  (string) (len=14) "  -keep-unused",
+  (string) (len=105) "    \tKeep unused constants, functions, variables, types and methods of unused types from C system headers",
   (string) (len=11) "  -o string",
   (string) (len=51) "    \toutput Go generated code to the specified file",
   (string) (len=11) "  -p string",

.snapshots/c2go-TestCLI-func1-TranspileNoFilesHelp

@@ -1,7 +1,9 @@
-([]string) (len=8) {
+([]string) (len=10) {
   (string) (len=59) "Usage: test transpile [-V] [-o file.go] [-p package] file.c",
   (string) (len=31) "  -V\tprint progress as comments",
   (string) (len=27) "  -h\tprint help information",
+  (string) (len=14) "  -keep-unused",
+  (string) (len=105) "    \tKeep unused constants, functions, variables, types and methods of unused types from C system headers",
   (string) (len=11) "  -o string",
   (string) (len=51) "    \toutput Go generated code to the specified file",
   (string) (len=11) "  -p string",

ast/alloc_size_attr.go

@@ -0,0 +1,57 @@
+package ast
+
+import (
+	"strings"
+
+	"github.com/elliotchance/c2go/util"
+)
+
+// AllocSizeAttr is a type of attribute that is optionally attached to a variable
+// or struct field definition.
+type AllocSizeAttr struct {
+	Addr       Address
+	Pos        Position
+	Inherited  bool
+	A          int
+	B          int
+	ChildNodes []Node
+}
+
+func parseAllocSizeAttr(line string) *AllocSizeAttr {
+	groups := groupsFromRegex(
+		`<(?P<position>.*)>(?P<inherited> Inherited)?(?P<a> \d+)(?P<b> \d+)?`,
+		line,
+	)
+
+	return &AllocSizeAttr{
+		Addr:       ParseAddress(groups["address"]),
+		Pos:        NewPositionFromString(groups["position"]),
+		Inherited:  len(groups["inherited"]) > 0,
+		A:          util.Atoi(strings.TrimSpace(groups["a"])),
+		B:          util.Atoi(strings.TrimSpace(groups["b"])),
+		ChildNodes: []Node{},
+	}
+}
+
+// AddChild adds a new child node. Child nodes can then be accessed with the
+// Children attribute.
+func (n *AllocSizeAttr) AddChild(node Node) {
+	n.ChildNodes = append(n.ChildNodes, node)
+}
+
+// Address returns the numeric address of the node. See the documentation for
+// the Address type for more information.
+func (n *AllocSizeAttr) Address() Address {
+	return n.Addr
+}
+
+// Children returns the child nodes. If this node does not have any children or
+// this node does not support children it will always return an empty slice.
+func (n *AllocSizeAttr) Children() []Node {
+	return n.ChildNodes
+}
+
+// Position returns the position in the original source code.
+func (n *AllocSizeAttr) Position() Position {
+	return n.Pos
+}

ast/alloc_size_attr_test.go

@@ -0,0 +1,27 @@
+package ast
+
+import (
+	"testing"
+)
+
+func TestAllocSizeAttr(t *testing.T) {
+	nodes := map[string]Node{
+		`0x7f8e390a5d38 <col:100, col:114> 1 2`: &AllocSizeAttr{
+			Addr:       0x7f8e390a5d38,
+			Pos:        NewPositionFromString("col:100, col:114"),
+			A:          1,
+			B:          2,
+			ChildNodes: []Node{},
+		},
+		`0x7fbd1a167f48 </usr/include/stdlib.h:342:37> Inherited 1 0`: &AllocSizeAttr{
+			Addr:       0x7fbd1a167f48,
+			Pos:        NewPositionFromString("/usr/include/stdlib.h:342:37"),
+			Inherited:  true,
+			A:          1,
+			B:          0,
+			ChildNodes: []Node{},
+		},
+	}
+
+	runNodeTests(t, nodes)
+}

ast/ast.go

@@ -45,6 +45,8 @@ func Parse(line string) Node {
 	switch nodeName {
 	case "AlignedAttr":
 		return parseAlignedAttr(line)
+	case "AllocSizeAttr":
+		return parseAllocSizeAttr(line)
 	case "AlwaysInlineAttr":
 		return parseAlwaysInlineAttr(line)
 	case "ArraySubscriptExpr":
@@ -85,6 +87,8 @@ func Parse(line string) Node {
 		return parseDeclStmt(line)
 	case "DefaultStmt":
 		return parseDefaultStmt(line)
+	case "DisableTailCallsAttr":
+		return parseDisableTailCallsAttr(line)
 	case "DeprecatedAttr":
 		return parseDeprecatedAttr(line)
 	case "DoStmt":

ast/ast_test.go

@@ -36,3 +36,23 @@ func runNodeTests(t *testing.T, tests map[string]Node) {
 		})
 	}
 }
+
+func TestPrint(t *testing.T) {
+	cond := &ConditionalOperator{}
+	cond.AddChild(&ImplicitCastExpr{})
+	cond.AddChild(&ImplicitCastExpr{})
+	s := Atos(cond)
+	if len(s) == 0 {
+		t.Fatalf("Cannot convert AST tree : %#v", cond)
+	}
+	lines := strings.Split(s, "\n")
+	var amount int
+	for _, l := range lines {
+		if strings.Contains(l, "ImplicitCastExpr") {
+			amount++
+		}
+	}
+	if amount != 2 {
+		t.Error("Not correct design of output")
+	}
+}

ast/disable_tail_calls_attr.go

@@ -0,0 +1,45 @@
+package ast
+
+// DisableTailCallsAttr is a type of attribute that is optionally attached to a variable
+// or struct field definition.
+type DisableTailCallsAttr struct {
+	Addr       Address
+	Pos        Position
+	ChildNodes []Node
+}
+
+func parseDisableTailCallsAttr(line string) *DisableTailCallsAttr {
+	groups := groupsFromRegex(
+		"<(?P<position>.*)>",
+		line,
+	)
+
+	return &DisableTailCallsAttr{
+		Addr:       ParseAddress(groups["address"]),
+		Pos:        NewPositionFromString(groups["position"]),
+		ChildNodes: []Node{},
+	}
+}
+
+// AddChild adds a new child node. Child nodes can then be accessed with the
+// Children attribute.
+func (n *DisableTailCallsAttr) AddChild(node Node) {
+	n.ChildNodes = append(n.ChildNodes, node)
+}
+
+// Address returns the numeric address of the node. See the documentation for
+// the Address type for more information.
+func (n *DisableTailCallsAttr) Address() Address {
+	return n.Addr
+}
+
+// Children returns the child nodes. If this node does not have any children or
+// this node does not support children it will always return an empty slice.
+func (n *DisableTailCallsAttr) Children() []Node {
+	return n.ChildNodes
+}
+
+// Position returns the position in the original source code.
+func (n *DisableTailCallsAttr) Position() Position {
+	return n.Pos
+}

ast/disable_tail_calls_attr_test.go

@@ -0,0 +1,17 @@
+package ast
+
+import (
+	"testing"
+)
+
+func TestDisableTailCallsAttr(t *testing.T) {
+	nodes := map[string]Node{
+		`0x7fc8fa094558 <col:107> `: &DisableTailCallsAttr{
+			Addr:       0x7fc8fa094558,
+			Pos:        NewPositionFromString("col:107"),
+			ChildNodes: []Node{},
+		},
+	}
+
+	runNodeTests(t, nodes)
+}

ast/floating_literal.go

@@ -3,8 +3,9 @@ package ast
 import (
 	"errors"
 	"fmt"
-	"github.com/elliotchance/c2go/cc"
 	"reflect"
+
+	"github.com/elliotchance/c2go/cc"
 )
 
 type FloatingLiteral struct {

ast/floating_literal_test.go

@@ -13,6 +13,13 @@ func TestFloatingLiteral(t *testing.T) {
 			Value:      1.23,
 			ChildNodes: []Node{},
 		},
+		`0x21c65b8 <col:41> 'double' 2.718282e+00`: &FloatingLiteral{
+			Addr:       0x21c65b8,
+			Pos:        NewPositionFromString("col:41"),
+			Type:       "double",
+			Value:      2.718282e+00,
+			ChildNodes: []Node{},
+		},
 	}
 
 	runNodeTests(t, nodes)

ast/position.go

@@ -217,6 +217,8 @@ func setPosition(node Node, position Position) {
 	switch n := node.(type) {
 	case *AlignedAttr:
 		n.Pos = position
+	case *AllocSizeAttr:
+		n.Pos = position
 	case *AlwaysInlineAttr:
 		n.Pos = position
 	case *ArraySubscriptExpr:
@@ -255,6 +257,8 @@ func setPosition(node Node, position Position) {
 		n.Pos = position
 	case *DeprecatedAttr:
 		n.Pos = position
+	case *DisableTailCallsAttr:
+		n.Pos = position
 	case *DoStmt:
 		n.Pos = position
 	case *EnumConstantDecl:

ast/util.go

@@ -1,6 +1,9 @@
 package ast
 
 import (
+	"bytes"
+	"encoding/json"
+	"fmt"
 	"strconv"
 	"strings"
 )
@@ -33,3 +36,41 @@ func atof(s string) float64 {
 
 	return f
 }
+
+// Atos - ASTree to string
+// Typically using for debug
+func Atos(node Node) string {
+	j, err := json.Marshal(node)
+	if err != nil {
+		panic(err)
+	}
+	var out bytes.Buffer
+	err = json.Indent(&out, j, "", "\t")
+	if err != nil {
+		panic(err)
+	}
+	var str string
+	str += fmt.Sprint("==== START OF AST tree ====\n")
+	str += out.String()
+	str += fmt.Sprintf("\nTypes tree:\n")
+	str += typesTree(node, 0)
+	str += fmt.Sprint("==== END OF AST tree ====\n")
+	return str
+}
+
+func typesTree(node Node, depth int) (str string) {
+	if node == (Node)(nil) {
+		return ""
+	}
+	for i := 0; i < depth; i++ {
+		str += "\t"
+	}
+	str += fmt.Sprintf("%T\n", node)
+	depth++
+	if len(node.Children()) > 0 {
+		for _, n := range node.Children() {
+			str += typesTree(n, depth)
+		}
+	}
+	return str
+}