zsh/Completion/Unix/Command/_make

#compdef make gmake pmake dmake

# TODO: Based on targets given on the command line, show only variables that
# are used in those targets and their dependencies.

_make-expandVars() {
  local open close var val front ret tmp=$1

  front=${tmp%%\$*}
  case $tmp in
    (\(*) # Variable of the form $(foobar)
    open='('
    close=')'
    ;;

    ({*) # ${foobar}
    open='{'
    close='}'
    ;;

    ([[:alpha:]]*) # $foobar. This is exactly $(f)oobar.
    open=''
    close=''
    var=${(s::)var[1]}
    ;;

    (\$*) # Escaped $.
    print -- "${front}\$$(_make-expandVars ${tmp#\$})"
    return
    ;;

    (*) # Nothing left to substitute.
    print -- $tmp
    return
    ;;
  esac

  if [[ -n $open ]]
  then
    var=${tmp#$open}
    var=${var%%$close*}
  fi

  case $var in
    ([[:alnum:]_]#)
    val=${VARIABLES[$var]}
    ret=${ret//\$$open$var$close/$val}
    ;;

    (*)
    # Improper variable name. No replacement.
    # I'm not sure if this is desired behavior.
    front+="\$$open$var$close"
    ret=${ret/\$$open$var$close/}
    ;;
  esac

  print -- "${front}$(_make-expandVars ${ret})"
}

_make-parseMakefile () {
  local input var val target dep TAB=$'\t' dir=$1 tmp

  while read input
  do
    case "$input " in
      # VARIABLE = value
      ([[:alnum:]][[:alnum:]_]#[ $TAB]#=*)
      var=${input%%[ $TAB]#=*}
      val=${input#*=}
      val=${val##[ $TAB]#}
      VARIABLES[$var]=$val
      ;;

      # VARIABLE := value
      # Evaluated immediately
      ([[:alnum:]][[:alnum:]_]#[ $TAB]#:=*)
      var=${input%%[ $TAB]#:=*}
      val=${input#*=}
      val=${val##[ $TAB]#}
      val=$(_make-expandVars $val)
      VARIABLES[$var]=$val
      ;;

      # TARGET: dependencies
      # TARGET1 TARGET2 TARGET3: dependencies
      ([[:alnum:]][^$TAB:=]#:[^=]*)
      input=$(_make-expandVars $input)
      target=${input%%:*}
      dep=${input#*:}
      dep=${(z)dep}
      dep="$dep"
      for tmp in ${(z)target}
      do
        TARGETS[$tmp]=$dep
      done
      ;;

      # Include another makefile
      (${~incl} *)
      local f=${input##${~incl} ##}
      if [[ $incl == '.include' ]]
      then
        f=${f#[\"<]}
        f=${f%[\">]}
      fi
      f=$(_make-expandVars $f)
      case $f in
        (/*) ;;
        (*) f=$dir/$f ;;
      esac

      if [[ -r $f ]]
      then
        _make-parseMakefile ${f%%/[^/]##} < $f
      fi
      ;;
    esac
  done
}

_make-findBasedir () {
  local file index basedir
  basedir=$PWD
  for (( index=0; index < $#@; index++ ))
  do
    if [[ $@[index] == -C ]]
    then
      file=${~@[index+1]};
      if [[ -z $file ]]
      then
        # make returns with an error if an empty arg is given
        # even if the concatenated path is a valid directory
        return
      elif [[ $file == /* ]]
      then
        # Absolute path, replace base directory
        basedir=$file
      else
        # Relative, concatenate path
        basedir=$basedir/$file
      fi
    fi
  done
  print -- $basedir
}

_make() {

  local prev="$words[CURRENT-1]" file expl tmp is_gnu dir incl match
  local context state line
  local -a option_specs
  local -A TARGETS VARIABLES opt_args
  local ret=1

  _pick_variant -r is_gnu gnu=GNU unix -v -f

  if [[ $is_gnu == gnu ]]
  then
    incl="(-|)include"
    # TBD: update option_specs
    option_specs=(
      '-C[change directory first]:directory:->dir'
      '-I[include directory for makefiles]:directory:->dir'
      '-f[specify makefile]:makefile:->file'
      '-o[specify file not to remake]:file not to remake:->file'
      '-W[pretend file was modified]:file to treat as modified:->file'
    )
  else
    # Basic make options only.
    incl=.include
    option_specs=(
      '-C[change directory first]:directory:->dir'
      '-I[include directory for makefiles]:directory:->dir'
      '-f[specify makefile]:makefile:->file'
      '-o[specify file not to remake]:file not to remake:->file'
      '-W[pretend file was modified]:file to treat as modified:->file'
    )
  fi

  _arguments -s $option_specs \
    '*:make target:->target' && ret=0

  case $state in
    (dir)
    _files -W ${(q)$(_make-findBasedir ${words[1,CURRENT-1]})} -/ && ret=0
    ;;

    (file)
    _files -W ${(q)$(_make-findBasedir $words)} && ret=0
    ;;

    (target)
    file=($opt_args[(K)(-f|--file|--makefile)])
    file=$file[1]
    if [[ -n $file ]]
    then
      [[ $file == [^/]* ]] && file=${(q)$(_make-findBasedir $words)}/$file
      [[ -r $file ]] || file=
    else
      local basedir
      basedir=${$(_make-findBasedir $words)}
      if [[ $is_gnu == gnu && -r $basedir/GNUmakefile ]]
      then
        file=$basedir/GNUmakefile
      elif [[ -r $basedir/makefile ]]
      then
        file=$basedir/makefile
      elif [[ -r $basedir/Makefile ]]
      then
        file=$basedir/Makefile
      else
        file=''
      fi
    fi

    if [[ -n "$file" ]]
    then
      if [[ $is_gnu == gnu ]] && zstyle -t ":completion:${curcontext}:targets" call-command
      then
        _make-parseMakefile $PWD < <(_call_program targets "$words[1]" -nsp --no-print-directory -f "$file" .PHONY 2> /dev/null)
      else
        case "$OSTYPE" in
          freebsd*)
          _make-parseMakefile $PWD < <(_call_program targets "$words[1]" -nsp -f "$file" .PHONY 2> /dev/null)
    ;;
    *)
          _make-parseMakefile $PWD < $file
        esac
      fi
    fi

    if [[ $PREFIX == *'='* ]]
    then
      # Complete make variable as if shell variable
      compstate[parameter]="${PREFIX%%\=*}"
      compset -P 1 '*='
      _value "$@" && ret=0
    else
      _tags targets variables
      while _tags
      do
        _requested targets expl 'make targets' \
          compadd -- ${(k)TARGETS} && ret=0
        _requested variables expl 'make variables' \
          compadd -S '=' -- ${(k)VARIABLES} && ret=0
      done
    fi
  esac

  return ret
}

_make "$@"