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 30a5cd6520ff59b7e4c13010d7a2e5f22a788cdd..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,21 +22,18 @@ 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"
 )
 
-const EnvNoHash = "REDO_NO_HASH"
-
-var NoHash bool
-
 func recfileWrite(fdDep *os.File, fields ...recfile.Field) error {
        w := recfile.NewWriter(fdDep)
        if _, err := w.RecordStart(); err != nil {
@@ -68,25 +65,20 @@ func stamp(fdDep, src *os.File) error {
        if err != nil {
                return err
        }
-       fields := []recfile.Field{
+       trace(CDebug, "stamp: %s <- %s", fdDep.Name(), hsh)
+       return recfileWrite(
+               fdDep,
                recfile.Field{Name: "Type", Value: DepTypeStamp},
                recfile.Field{Name: "Hash", Value: hsh},
-       }
-       same := StampPrev == hsh
-       if same {
-               fields = append(fields, recfile.Field{Name: "Same", Value: "true"})
-       }
-       trace(CDebug, "stamp: %s <- %s (%v)", fdDep.Name(), hsh, same)
-       return recfileWrite(fdDep, fields...)
+       )
 }
 
 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
 }
 
@@ -108,24 +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{
+       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})
-       }
-       return recfileWrite(fdDep, fields...)
+               recfile.Field{Name: "Hash", Value: hsh},
+       )
 }
 
 func writeDeps(fdDep *os.File, tgts []string) error {
@@ -148,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
+}