Fix workability under GNU/Linux and other systems because of different syscall

[goredo.git] / dep.go

diff --git a/dep.go b/dep.go
index 8749f093dfd8306e9dcb550182e292cf40eac707..38d8bb79c200ede2acedeb9ce357fe313211d7c2 100644 (file)
--- a/dep.go
+++ b/dep.go
@@ -1,6 +1,6 @@
 /*
 goredo -- redo implementation on pure Go
-Copyright (C) 2020 Sergey Matveev <stargrave@stargrave.org>
+Copyright (C) 2020-2021 Sergey Matveev <stargrave@stargrave.org>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -22,15 +22,16 @@ package main
 import (
        "bufio"
        "encoding/hex"
+       "errors"
        "fmt"
        "io"
        "os"
        "path"
        "strings"
-       "syscall"
 
        "go.cypherpunks.ru/recfile"
        "golang.org/x/crypto/blake2b"
+       "golang.org/x/sys/unix"
 )
 
 func recfileWrite(fdDep *os.File, fields ...recfile.Field) error {
@@ -48,14 +49,14 @@ func ifcreate(fdDep *os.File, tgt string) error {
        trace(CDebug, "ifcreate: %s <- %s", fdDep.Name(), tgt)
        return recfileWrite(
                fdDep,
-               recfile.Field{Name: "Type", Value: "ifcreate"},
+               recfile.Field{Name: "Type", Value: DepTypeIfcreate},
                recfile.Field{Name: "Target", Value: tgt},
        )
 }
 
 func always(fdDep *os.File) error {
        trace(CDebug, "always: %s", fdDep.Name())
-       return recfileWrite(fdDep, recfile.Field{Name: "Type", Value: "always"})
+       return recfileWrite(fdDep, recfile.Field{Name: "Type", Value: DepTypeAlways})
 }
 
 func stamp(fdDep, src *os.File) error {
@@ -67,18 +68,17 @@ func stamp(fdDep, src *os.File) error {
        trace(CDebug, "stamp: %s <- %s", fdDep.Name(), hsh)
        return recfileWrite(
                fdDep,
-               recfile.Field{Name: "Type", Value: "stamp"},
+               recfile.Field{Name: "Type", Value: DepTypeStamp},
                recfile.Field{Name: "Hash", Value: hsh},
        )
 }
 
 func fileCtime(fd *os.File) (string, error) {
-       fi, err := fd.Stat()
-       if err != nil {
+       var stat unix.Stat_t
+       if err := unix.Fstat(int(fd.Fd()), &stat); err != nil {
                return "", err
        }
-       stat := fi.Sys().(*syscall.Stat_t)
-       sec, nsec := stat.Ctimespec.Unix()
+       sec, nsec := stat.Ctim.Unix()
        return fmt.Sprintf("%d.%d", sec, nsec), nil
 }
 
@@ -100,25 +100,28 @@ func writeDep(fdDep *os.File, cwd, tgt string) error {
                return err
        }
        defer fd.Close()
+       fi, err := fd.Stat()
+       if err != nil {
+               return err
+       }
+       if fi.IsDir() {
+               return nil
+       }
        ts, err := fileCtime(fd)
        if err != nil {
                return err
        }
-       fields := []recfile.Field{
-               recfile.Field{Name: "Type", Value: "ifchange"},
+       hsh, err := fileHash(fd)
+       if err != nil {
+               return err
+       }
+       return recfileWrite(
+               fdDep,
+               recfile.Field{Name: "Type", Value: DepTypeIfchange},
                recfile.Field{Name: "Target", Value: tgt},
                recfile.Field{Name: "Ctime", Value: ts},
-       }
-       var hsh string
-       if !NoHash {
-               hsh, err = fileHash(fd)
-               if err != nil {
-                       return err
-               }
-               fields = append(fields, recfile.Field{Name: "Hash", Value: hsh})
-       }
-       err = recfileWrite(fdDep, fields...)
-       return err
+               recfile.Field{Name: "Hash", Value: hsh},
+       )
 }
 
 func writeDeps(fdDep *os.File, tgts []string) error {
@@ -127,7 +130,7 @@ func writeDeps(fdDep *os.File, tgts []string) error {
                return nil
        }
        ups := []string{}
-       upLevels := strings.Count(os.Getenv(RedoDirPrefixEnv), "/")
+       upLevels := strings.Count(os.Getenv(EnvDirPrefix), "/")
        for i := 0; i < upLevels; i++ {
                ups = append(ups, "..")
        }
@@ -141,3 +144,56 @@ func writeDeps(fdDep *os.File, tgts []string) error {
        }
        return nil
 }
+
+type DepInfo struct {
+       build     string
+       always    bool
+       stamp     string
+       ifcreates []string
+       ifchanges []map[string]string
+}
+
+func depRead(fdDep *os.File) (*DepInfo, error) {
+       r := recfile.NewReader(fdDep)
+       m, err := r.NextMap()
+       if err != nil {
+               return nil, err
+       }
+       depInfo := DepInfo{}
+       if b := m["Build"]; b == "" {
+               return nil, errors.New(".dep missing Build:")
+       } else {
+               depInfo.build = b
+       }
+       for {
+               m, err := r.NextMap()
+               if err != nil {
+                       if err == io.EOF {
+                               break
+                       }
+                       return nil, err
+               }
+               switch m["Type"] {
+               case DepTypeAlways:
+                       depInfo.always = true
+               case DepTypeIfcreate:
+                       dep := m["Target"]
+                       if dep == "" {
+                               return nil, errors.New("invalid format of .dep")
+                       }
+                       depInfo.ifcreates = append(depInfo.ifcreates, dep)
+               case DepTypeIfchange:
+                       delete(m, "Type")
+                       depInfo.ifchanges = append(depInfo.ifchanges, m)
+               case DepTypeStamp:
+                       hsh := m["Hash"]
+                       if hsh == "" {
+                               return nil, errors.New("invalid format of .dep")
+                       }
+                       depInfo.stamp = hsh
+               default:
+                       return nil, errors.New("invalid format of .dep")
+               }
+       }
+       return &depInfo, nil
+}