Maque

#!/bin/sh

printUsage(){
    cat <<EOL
Usage: $(basename $0) [-kn] [-f path] target
Options:
    -f Use "path" as a makefile
    -k Ignore potential errors when executing the makefile's commands
    -n Print the makefile's commands instead of running them
EOL
}

debug(){
    local DEBUG=true
    $DEBUG && echo "$*"
}

stringContain() {
    #$1 une chaîne et $2 une recherche
    if echo "$1" | grep "$2">/dev/null
    then
        return 0
    else
        return 1
    fi
}

getDependenciesInString(){
    #dependencies=$(echo $1 | sed "s/^.*:\(.*$\)/\1/" | sed "s/[[:space:]]*$//")
    local dependencies=$(echo $1 | sed "s/.*:[[:space:]]*//")
    echo $dependencies
}

getDependenciesForTarget(){
    local dependencies=$(cat $makefile | grep -e "^$1:" | sed "s/.*:[[:space:]]*//")
    echo $dependencies
}

needsAnUpdate(){
    local target="$1"
    local dependency="$2"

    if [ -f "$dependency" ]
    then
        if ! [ -f "$target" ]
        then
            debug "'$dependency existe mais pas '$target'"
            return 0 #la dépendance existe mais sa cible non: je choisis de ne pas retélécharger la dépendance
        fi

        if [ $(find $dependency -newer $target | wc -l) -le 0 ] #Si cible >=récente que dépendance
        then
            debug "'$target' plus récent que '$dependency'"
            return 1 #pas d'update
        else
            debug "'$target' moins récent que '$dependency'"
            return 0 #besoin d'update
        fi
    else
        debug "'$dependency' n'existe pas et pas moyen de le créer"
        return 2 #dépendance manquante (pas d'update donc)
    fi
}

isATarget(){
    local target=$1
    if cat "$makefile" | grep -e "^$target\:" > /dev/null
    then
        return 0
    else
        return 1
    fi
}

dummy(){
    #Parfois,j'ai besoin d'une fonction qui ne fait rien
    return 0
}

readOptions(){
    ARGU=$(getopt "f:kn" $*)
    set - $ARGU
    for i
    do
            #debug "$i"
            case "$i" in
            -f) makefile="$2"
                shift
                shift;;
            -k) runBlindly=false
                shift;;
            -n) runInVain=true
                shift;;
            \?) echo "Option $i was not recognized"
            exit 1;;
            --) shift
                break;;
            esac
    done
    return 0
}

myMake(){
    debug ""
    debug "myMake '$1'"
    local dependencies=$(getDependenciesForTarget "$1")
    debug "Dependencies:    '$dependencies'"
    if ! [ -z "$dependencies" ]
    then
        local i
        local hasUpdated=0
        for i in "$dependencies"
        do
            debug "for '$i' do"
            if isATarget "$i"
            then
                debug "$i est une cible"
                if myMake "$i"
                then
                    hasUpdated=$(expr $hasUpdated + 1)
                fi
            else
                if needsAnUpdate "$1" "$i"
                then #besoin d'update
                    hasUpdated=$(expr $hasUpdated + 1)
                else #pas besoin d'update
                    dummy
                fi
            fi
        done

        if [ "$hasUpdated" -eq 0 ]
        then
            debug "Pas besoin de mettre à jour '$1'"
            return 1
        fi
    fi

    update "$1"
    ret=$?
    if $runBlindly #si option -k: ignorer les erreurs
    then
        return 0
    else #pas d'option -k: vérifier si tout a marché
        if [ "$ret" -ne 0 ]
        then
            error "Error: couldn't update $i."
            exit 1
        else
            return 0
        fi
    fi
}

update(){
    local currentTarget="$tmpdir/$1.tmp"
    debug "J'update '$currentTarget'"
    if ! [ -z "$1" ]
    then
        if $runInVain
        then
            cat "$currentTarget"
            return 0
        else
            sh "$currentTarget"
            return $?
        fi
    fi
}

#Ici on gère les options, j'assigne à des variables des valeurs par défaut qui sont ensuite
#modifiées ou pas par la fonction readOptions()
runBlindly=true
runInVain=false
makefile=$(find . -name [mM]akefile -maxdepth 1) #Cherche un makefile
readOptions $*
if ! [ -z $makefile ] && ls $makefile #Si $makefile non vide et fichier trouvable
then
    dummy #Ne fait rien
else
    error "Error: 404: makefile not found"
    exit 1
fi

#Vrai code
tmpdir="/tmp/$(basename $0)-$$" #ex: /tmp/myMake.sh-3645
if $DEBUG
then
    rm -r /tmp/t.sh-*
else
    trap "rm -r $tmpdir" EXIT
fi
mkdir "$tmpdir"

#Ici on parse le fichier
cat "$makefile" | while read -r i
do
    i=$(echo $i | sed "s/#.*//g") #Remplace tout ce qui est après # par rien du tout
    if ! [ -z "$i" ]; then
        #ici on traite toutes les lignes intéressantes du makefile par le biais de $i
        #(non vides, sans les commentaires...)
        #debug "    [$i]"
        if stringContain "$i" ':' #ligne contenant une cible
        then
            currentTarget=$(echo "$i" | sed 's/:.*//g') #juste le path de la cible
            debug "Target:              [$currentTarget]"
            dependencies=$(getDependenciesInString "$i")
            debug "Dependencies:        [$dependencies]"
        else
            debug "Commands:            [$i]"
            echo "$i" >> "$tmpdir/$currentTarget.tmp" #ex: /tmp/myMake.sh-3645/toto.o.tmp
        fi
    fi
done #< $makefile

if [ "$#" -ne 1 ] && ! $DEBUG
then
    printUsage
    exit 1
fi

#Code de test


#Vrai code

if $DEBUG
then
    myMake "clean"
    exit 0
fi


myMake "$1"