Konstantin8105/f4go

package main

import (
    "bytes"
    "flag"
    "fmt"
    "go/format"
    "go/token"
    "io/ioutil"
    "os"
    "os/exec"
    "regexp"
    "runtime"
    "runtime/debug"
    "strings"

    "github.com/Konstantin8105/f4go/fortran"
)

var (
    packageFlag  *string
    simplifyFlag *bool
    parallelFlag *int
    verboseFlag  *int
)

func init() {
    p := 1
    parallelFlag = &p
    v := 1
    verboseFlag = &v
}

func main() {
    packageFlag = flag.String("p",
        "main", "set the name of the generated package")
    simplifyFlag = flag.Bool("s",
        false, "simplify from (*I) to I of Golang file. NOT guaranteed to work correctly")
    parallelFlag = flag.Int("m",
        1, "enable parallelism in file processing. Default is only one core")
    verboseFlag = flag.Int("v",
        1, "0: error output, 1: print log, 2: print info, 3: print debug")
    run()
}

func run() {
    if packageFlag == nil {
        packageFlag = new(string)
    }

    // free 1 CPU for other computer stuff
    runtime.GOMAXPROCS(*parallelFlag)

    flag.Parse()
    fortran.Verbose = *verboseFlag
    if flag.NArg() < 1 {
        fortran.Errorf("Please run: f4go -h")
        return
    }

    if packageFlag == nil {
        var s string
        packageFlag = &s
    }
    var es []errorRow
    if *parallelFlag > 1 {
        es = parseParallel(flag.Args(), *packageFlag)
    } else {
        for _, s := range flag.Args() {
            fortran.Logf("parsing file %s\n", s)
            er := parse(s, *packageFlag, "")
            es = append(es, er...)
        }
    }

    for _, e := range es {
        fortran.Logf("%20s : %s\n", e.filename, e.err.Error())
    }
}

type errorRow struct {
    err      error
    filename string
}

func (err errorRow) Error() string {
    return fmt.Sprintf("%s : %v", err.filename, err.err)
}

// parsing to Go code
func parse(filename, packageName, goFilename string) (errR []errorRow) {
    defer func() {
        err := recover()
        if err != nil {
            fortran.Errorf("panic parsing %s: %s\n%s", filename, err, string(debug.Stack()))
            os.Exit(1)
        }
    }()

    if packageName == "" {
        packageName = "main"
    }

    // read fortran source
    dat, err := ioutil.ReadFile(filename)
    if err != nil {
        return []errorRow{
            {
                err:      fmt.Errorf("Cannot fortran source: %v", err),
                filename: filename,
            },
        }
    }

    // remove some end line symbols
    dat = bytes.Replace(dat, []byte{'\r'}, []byte{}, -1)
    dat = bytes.Replace(dat, []byte{'\015'}, []byte{}, -1)

    // parse fortran to go/ast
    ast, errs := fortran.Parse(dat, packageName)
    if len(errs) > 0 {
        for _, er := range errs {
            errR = append(errR, errorRow{
                err:      fmt.Errorf("Parsing error : %v", er.Error()),
                filename: filename,
            })
        }
    }

    // convert ast tree to string
    var buf bytes.Buffer
    if err = format.Node(&buf, token.NewFileSet(), &ast); err != nil {
        return []errorRow{{err: fmt.Errorf("Error go/format : %v", err), filename: filename}}
    }

    // generate filename of result
    if goFilename == "" {
        index := strings.LastIndex(filename, ".")
        goFilename = filename + ".go"
        if index > 0 {
            goFilename = filename[:index] + ".go"
        }
    }

    // save go source
    if err = ioutil.WriteFile(goFilename, buf.Bytes(), 0644); err != nil {
        return []errorRow{{err: fmt.Errorf("Cannot write Go source: %v", err), filename: filename}}
    }

    // gofmt simplification
    _, _ = exec.Command("gofmt", "-s", "-w", goFilename).CombinedOutput()

    // goimports
    _, _ = exec.Command("goimport", "-w", goFilename).CombinedOutput()

    if simplifyFlag == nil {
        simplifyFlag = new(bool)
    }
    if *simplifyFlag {
        simplify(goFilename)
    }

    return
}

func parseParallel(filenames []string, packageName string) (ess []errorRow) {
    var (
        jobs    = make(chan string, len(filenames))
        results = make(chan []errorRow, len(filenames))
    )

    for w := 1; w <= 2*runtime.NumCPU(); w++ {
        go func(jobs <-chan string, results chan<- []errorRow) {
            for job := range jobs {
                results <- parse(job, packageName, "")
            }
        }(jobs, results)
    }

    for _, f := range filenames {
        jobs <- f
    }
    close(jobs)

    for range filenames {
        ess = append(ess, <-results...)
    }
    return
}

func simplify(filename string) {
    // read file
    content, err := ioutil.ReadFile(filename)
    if err != nil {
        panic(err)
    }

    {
        // from : (*(L)) -> L
        re := regexp.MustCompile(`\(\*\((?P<name>[[:word:]]*)\)\)`)
        content = re.ReplaceAll(content, []byte("$1"))
    }
    {
        // from : (*K)   -> K
        re := regexp.MustCompile(`\(\*(?P<name>[[:word:]]*)\)`)
        content = re.ReplaceAll(content, []byte("$1"))
    }
    {
        // from: A := new(int) -> var A int
        re := regexp.MustCompile(`(?P<name>[[:word:]]*) := new\((?P<typ>[[:word:]]*)\)`)
        content = re.ReplaceAll(content, []byte("var $1 $2"))
    }
    {
        // from: (123) -> 123
        re := regexp.MustCompile(`\((?P<name>[[:digit:]]*)\)`)
        content = re.ReplaceAll(content, []byte("$1"))
    }
    {
        // *int
        content = bytes.ReplaceAll(content, []byte("*int"), []byte("int"))
        content = bytes.ReplaceAll(content, []byte("*float"), []byte("float"))
    }
    {
        // *[]int
        content = bytes.ReplaceAll(content, []byte("*[]"), []byte("[]"))
    }

    // write file
    err = ioutil.WriteFile(filename, content, 0644)
    if err != nil {
        panic(err)
    }
}