config.go

// Copyright 2015 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.

package main

import (
	"bytes"
	"fmt"
	"go/ast"
	"go/parser"
	"go/scanner"
	"go/token"
	"io/ioutil"
	"log"
	"path"
	"path/filepath"
	"runtime"
	"strings"

	"github.com/andybalholm/c2go/cc"
)

type Config struct {
	pkgRules   []pkgRule
	exports    []string
	replace    map[string]string
	delete     map[string]bool
	diffs      []diff
	slice      map[string]bool
	len        map[string]string
	cap        map[string]string
	typeMap    map[string]string
	bool       map[string]bool
	ptr        map[string]bool
	rename     map[string]string
	typedefs   []string
	exprMacros map[string]expressionMacro
	stmtMacros map[string]statementMacro

	// derived during analysis
	topDecls []*cc.Decl
}

type pkgRule struct {
	pattern string
	pkg     string
}

type diff struct {
	line   string
	before []byte
	after  []byte
	used   int
}

func (cfg *Config) filePackage(file string) (pkg string) {
	file = strings.TrimPrefix(file, "./")
	file = filepath.ToSlash(strings.TrimPrefix(file, runtime.GOROOT()+string(filepath.Separator)))
	pkg = "main"
	for _, rule := range cfg.pkgRules {
		matched, err := path.Match(rule.pattern, file)
		if err != nil {
			log.Printf("invalid pattern: %v", err)
			continue
		}
		if matched {
			pkg = rule.pkg
		}
	}
	return pkg
}

func (cfg *Config) read(file string) {
	data, err := ioutil.ReadFile(file)
	if err != nil {
		log.Fatal(err)
	}
	lineno := 0
	lines := strings.Split(string(data), "\n")
	cfg.replace = make(map[string]string)
	cfg.delete = make(map[string]bool)
	cfg.slice = make(map[string]bool)
	cfg.len = make(map[string]string)
	cfg.cap = make(map[string]string)
	cfg.typeMap = make(map[string]string)
	cfg.bool = make(map[string]bool)
	cfg.ptr = make(map[string]bool)
	cfg.rename = make(map[string]string)
	cfg.exprMacros = make(map[string]expressionMacro)
	cfg.stmtMacros = make(map[string]statementMacro)

	for len(lines) > 0 {
		line := lines[0]
		lines = lines[1:]
		lineno++
		line = strings.TrimSpace(line)
		if strings.HasPrefix(line, "#") {
			continue
		}
		f := strings.Fields(line)
		if len(f) == 0 {
			continue
		}
		switch f[0] {
		case "package":
			pkg := f[len(f)-1]
			for i := 1; i < len(f)-1; i++ {
				cfg.pkgRules = append(cfg.pkgRules, pkgRule{f[i], pkg})
			}

		case "export":
			cfg.exports = append(cfg.exports, f[1:]...)

		case "delete":
			for _, name := range f[1:] {
				cfg.delete[name] = true
			}

		case "bool":
			for _, name := range f[1:] {
				cfg.bool[name] = true
			}

		case "ptr":
			for _, name := range f[1:] {
				cfg.ptr[name] = true
			}

		case "string":
			if len(f) >= 3 {
				cfg.len[f[2]] = f[1]
			}

		case "slice":
			if len(f) >= 2 {
				cfg.slice[f[1]] = true
			}
			if len(f) >= 3 {
				cfg.len[f[2]] = f[1]
			}
			if len(f) >= 4 {
				cfg.cap[f[3]] = f[1]
			}
			if len(f) >= 5 {
				log.Printf("%s:%d: extra arguments for slice", file, lineno)
			}

		case "func", "type":
			if len(f) < 2 {
				log.Printf("%s:%d: short func/type declaration", file, lineno)
			}
			var buf bytes.Buffer
			buf.WriteString(line + "\n")
			if strings.HasSuffix(line, "{") {
				for {
					lineno++
					if len(lines) == 0 {
						log.Fatalf("%s:%d: unexpected EOF reading func/type body", file, lineno)
					}
					line = lines[0]
					lines = lines[1:]
					buf.WriteString(line + "\n")
					if line == "}" {
						break
					}
				}
			}
			name := f[1]
			if i := strings.Index(name, "("); i >= 0 {
				name = name[:i]
			}
			cfg.replace[name] = buf.String()

		case "macro":
			// Parse the macro signature (name and args).
			fs := token.NewFileSet()
			tf := fs.AddFile("", fs.Base(), len(line))
			var s scanner.Scanner
			s.Init(tf, []byte(line), nil, 0)
			_, tok, lit := s.Scan()
			if lit != "macro" {
				log.Fatalf("%s:%d: expected 'macro', found %v %q", file, lineno, tok, lit)
			}
			_, tok, lit = s.Scan()
			if tok != token.IDENT {
				log.Fatalf("%s:%d: expected macro name, found %v %q", file, lineno, tok, lit)
			}
			name := lit
			_, tok, lit = s.Scan()
			if tok != token.LPAREN {
				log.Fatalf("%s:%d: expected '(', found %v %q", file, lineno, tok, lit)
			}
			var args []string
			variadic := false
		argLoop:
			for {
				_, tok, lit = s.Scan()
				switch tok {
				case token.RPAREN:
					break argLoop
				case token.IDENT:
					args = append(args, lit)
				case token.ELLIPSIS:
					variadic = true
					_, tok, lit = s.Scan()
					if tok != token.RPAREN {
						log.Fatalf("%s:%d: expected ')', found %v %q", file, lineno, tok, lit)
					}
					break argLoop
				default:
					log.Fatalf("%s:%d: expected identifier, '...', or ')', found %v %q", file, lineno, tok, lit)
				}
				_, tok, lit = s.Scan()
				switch tok {
				case token.COMMA:
					continue argLoop
				case token.RPAREN:
					break argLoop
				default:
					log.Fatalf("%s:%d: expected ',' or ')', found %v %q", file, lineno, tok, lit)
				}
			}

			// Parse the body.
			pos, tok, lit := s.Scan()
			if tok == token.LBRACE {
				// statement macro, with a braced block
				var buf bytes.Buffer
				buf.WriteString("package main; func main() {\n")
				for {
					lineno++
					if len(lines) == 0 {
						log.Fatalf("%s:%d: unexpected EOF reading macro body", file, lineno)
					}
					line = lines[0]
					lines = lines[1:]
					buf.WriteString(line + "\n")
					if line == "}" {
						break
					}
				}
				macroFile, err := parser.ParseFile(fs, name, &buf, 0)
				if err != nil {
					log.Fatalf("%s:%d: error parsing macro body: %v", file, lineno, err)
				}
				main := macroFile.Decls[0].(*ast.FuncDecl)
				cfg.stmtMacros[name] = statementMacro{
					args:     args,
					variadic: variadic,
					stmts:    main.Body.List,
				}
			} else {
				// expression macro, just on the remainder of the line
				rest := line[int(pos)-tf.Base():]
				expr, err := parser.ParseExpr(rest)
				if err != nil {
					log.Fatalf("%s:%d: error parsing macro body: %v", file, lineno, err)
				}
				cfg.exprMacros[name] = expressionMacro{
					args:     args,
					variadic: variadic,
					expr:     expr,
				}
			}

		case "diff":
			if line != "diff {" {
				log.Printf("%s:%d: invalid diff opening", file, lineno)
				break
			}

			var old, new bytes.Buffer
			fileline := fmt.Sprintf("%s:%d", file, lineno)
			for {
				lineno++
				if len(lines) == 0 {
					log.Fatalf("%s:%d: unexpected EOF reading diff", file, lineno)
				}
				line = lines[0]
				lines = lines[1:]
				if line == "}" {
					break
				}
				switch {
				case strings.HasPrefix(line, "+"):
					line = strings.TrimPrefix(line[1:], " ")
					new.WriteString(line + "\n")

				case strings.HasPrefix(line, "-"):
					line = strings.TrimPrefix(line[1:], " ")
					old.WriteString(line + "\n")

				default:
					line = strings.TrimPrefix(strings.TrimPrefix(line, " "), " ")
					old.WriteString(line + "\n")
					new.WriteString(line + "\n")
				}
			}
			cfg.diffs = append(cfg.diffs, diff{
				line:   fileline,
				before: old.Bytes(),
				after:  new.Bytes(),
			})

		case "typemap":
			if len(f) != 3 {
				log.Printf("%s:%d: invalid typemap directive", file, lineno)
				continue
			}
			cfg.typeMap[f[1]] = f[2]

		case "rename":
			if len(f) != 3 {
				log.Printf("%s:%d: invalid rename directive", file, lineno)
				continue
			}
			cfg.rename[f[1]] = f[2]

		case "typedef":
			cfg.typedefs = append(cfg.typedefs, f[1:]...)

		default:
			log.Printf("%s:%d: unknown verb %s", file, lineno, f[0])
		}
	}
}

func declKey(d *cc.Decl) string {
	key := d.Name
	if t := d.OuterType; t != nil {
		name := t.Name
		if name == "" {
			name = t.Tag
		}
		if name == "" {
			name = t.String()
		}
		key = name + "." + key
	}
	if d.CurFn != nil {
		key = declKey(d.CurFn) + "." + key
	}
	return key
}