struct typedef without name

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

@@ -46,6 +46,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":
@@ -66,6 +68,8 @@ func Parse(line string) Node {
 		return parseCaseStmt(line)
 	case "CharacterLiteral":
 		return parseCharacterLiteral(line)
+	case "CompoundLiteralExpr":
+		return parseCompoundLiteralExpr(line)
 	case "CompoundStmt":
 		return parseCompoundStmt(line)
 	case "ConditionalOperator":
@@ -86,8 +90,12 @@ func Parse(line string) Node {
 		return parseDeclStmt(line)
 	case "DefaultStmt":
 		return parseDefaultStmt(line)
+	case "DisableTailCallsAttr":
+		return parseDisableTailCallsAttr(line)
 	case "DeprecatedAttr":
 		return parseDeprecatedAttr(line)
+	case "DisableTailCallsAttr":
+		return parseDisableTailCallsAttr(line)
 	case "DoStmt":
 		return parseDoStmt(line)
 	case "ElaboratedType":

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

@@ -0,0 +1,48 @@
+package ast
+
+// CompoundLiteralExpr C99 6.5.2.5
+type CompoundLiteralExpr struct {
+	Addr       Address
+	Pos        Position
+	Type1      string
+	Type2      string
+	ChildNodes []Node
+}
+
+func parseCompoundLiteralExpr(line string) *CompoundLiteralExpr {
+	groups := groupsFromRegex(
+		`<(?P<position>.*)> '(?P<type1>.*?)'(:'(?P<type2>.*)')? lvalue`,
+		line,
+	)
+
+	return &CompoundLiteralExpr{
+		Addr:       ParseAddress(groups["address"]),
+		Pos:        NewPositionFromString(groups["position"]),
+		Type1:      groups["type1"],
+		Type2:      groups["type2"],
+		ChildNodes: []Node{},
+	}
+}
+
+// AddChild adds a new child node. Child nodes can then be accessed with the
+// Children attribute.
+func (n *CompoundLiteralExpr) 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 *CompoundLiteralExpr) 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 *CompoundLiteralExpr) Children() []Node {
+	return n.ChildNodes
+}
+
+// Position returns the position in the original source code.
+func (n *CompoundLiteralExpr) Position() Position {
+	return n.Pos
+}

ast/compound_literal_expr_test.go

@@ -0,0 +1,19 @@
+package ast
+
+import (
+	"testing"
+)
+
+func TestCompoundLiteralExpr(t *testing.T) {
+	nodes := map[string]Node{
+		`0x5575acce81f0 <col:21, col:40> 'struct node':'struct node' lvalue`: &CompoundLiteralExpr{
+			Addr:       0x5575acce81f0,
+			Pos:        NewPositionFromString("col:21, col:40"),
+			Type1:      "struct node",
+			Type2:      "struct node",
+			ChildNodes: []Node{},
+		},
+	}
+
+	runNodeTests(t, nodes)
+}

ast/deprecated_attr.go

@@ -1,25 +1,27 @@
 package ast
 
 type DeprecatedAttr struct {
-	Addr       Address
-	Pos        Position
-	Message1   string
-	Message2   string
-	ChildNodes []Node
+	Addr        Address
+	Pos         Position
+	Message1    string
+	Message2    string
+	IsInherited bool
+	ChildNodes  []Node
 }
 
 func parseDeprecatedAttr(line string) *DeprecatedAttr {
 	groups := groupsFromRegex(
-		`<(?P<position>.*)> "(?P<message1>.*?)"(?P<message2> ".*?")?`,
+		`<(?P<position>.*)>(?P<inherited> Inherited)? "(?P<message1>.*?)"(?P<message2> ".*?")?`,
 		line,
 	)
 
 	return &DeprecatedAttr{
-		Addr:       ParseAddress(groups["address"]),
-		Pos:        NewPositionFromString(groups["position"]),
-		Message1:   removeQuotes(groups["message1"]),
-		Message2:   removeQuotes(groups["message2"]),
-		ChildNodes: []Node{},
+		Addr:        ParseAddress(groups["address"]),
+		Pos:         NewPositionFromString(groups["position"]),
+		Message1:    removeQuotes(groups["message1"]),
+		Message2:    removeQuotes(groups["message2"]),
+		IsInherited: len(groups["inherited"]) > 0,
+		ChildNodes:  []Node{},
 	}
 }
 

ast/deprecated_attr_test.go

@@ -7,11 +7,28 @@ import (
 func TestDeprecatedAttr(t *testing.T) {
 	nodes := map[string]Node{
 		`0x7fec4b0ab9c0 <line:180:48, col:63> "This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tempnam(3), it is highly recommended that you use mkstemp(3) instead." ""`: &DeprecatedAttr{
-			Addr:       0x7fec4b0ab9c0,
-			Pos:        NewPositionFromString("line:180:48, col:63"),
-			Message1:   "This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tempnam(3), it is highly recommended that you use mkstemp(3) instead.",
-			Message2:   "",
-			ChildNodes: []Node{},
+			Addr:        0x7fec4b0ab9c0,
+			Pos:         NewPositionFromString("line:180:48, col:63"),
+			Message1:    "This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tempnam(3), it is highly recommended that you use mkstemp(3) instead.",
+			Message2:    "",
+			IsInherited: false,
+			ChildNodes:  []Node{},
+		},
+		`0xb75d00 <line:1107:12> "This function or variable may be unsafe. Consider using _snwprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details." ""`: &DeprecatedAttr{
+			Addr:        0xb75d00,
+			Pos:         NewPositionFromString("line:1107:12"),
+			Message1:    "This function or variable may be unsafe. Consider using _snwprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.",
+			Message2:    "",
+			IsInherited: false,
+			ChildNodes:  []Node{},
+		},
+		`0xb75d00 <line:1107:12> Inherited "This function or variable may be unsafe. Consider using _snwprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details." ""`: &DeprecatedAttr{
+			Addr:        0xb75d00,
+			Pos:         NewPositionFromString("line:1107:12"),
+			Message1:    "This function or variable may be unsafe. Consider using _snwprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.",
+			Message2:    "",
+			IsInherited: true,
+			ChildNodes:  []Node{},
 		},
 	}
 

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_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:
@@ -245,6 +247,8 @@ func setPosition(node Node, position Position) {
 		n.Pos = position
 	case *CompoundAssignOperator:
 		n.Pos = position
+	case *CompoundLiteralExpr:
+		n.Pos = position
 	case *CStyleCastExpr:
 		n.Pos = position
 	case *DeclRefExpr:
@@ -255,6 +259,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: