Current Path : /proc/2/root/usr/share/zsh/4.3.11/functions/

Upload File :

Current File : //proc/2/root/usr/share/zsh/4.3.11/functions/_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.

local prev="$words[CURRENT-1]" file expl tmp is_gnu dir incl match
local -A TARGETS VARIABLES

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}\$$(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}$(expandVars ${ret})"
}

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=$(expandVars $val)
      VARIABLES[$var]=$val
      ;;

      # TARGET: dependencies
      # TARGET1 TARGET2 TARGET3: dependencies
      ([[:alnum:]][^$TAB:=]#:[^=]*)
      input=$(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=$(expandVars $f)
      case $f in
        (/*) ;;
        (*) f=$dir/$f ;;
      esac

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

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
}

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

if [[ $is_gnu == gnu ]]
then
  incl="(-|)include"
else
  incl=.include
fi

if [[ "$prev" == -[CI] ]]
then
  _files -W ${(q)$(findBasedir ${words[1,CURRENT-1]})} -/
elif [[ "$prev" == -[foW] ]]
then
  _files -W ${(q)$(findBasedir $words)}
else
  file="$words[(I)-f]"
  if (( file ))
  then
    file=${~words[file+1]}
    [[ $file == [^/]* ]] && file=${(q)$(findBasedir $words)}/$file
    [[ -r $file ]] || file=
  else
    local basedir
    basedir=${(q)$(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
      parseMakefile $PWD < <(_call_program targets "$words[1]" -nsp --no-print-directory -f "$file" .PHONY 2> /dev/null)
    else
      case "$OSTYPE" in
        freebsd*)
        parseMakefile $PWD < <(_call_program targets "$words[1]" -nsp -f "$file" .PHONY 2> /dev/null)
	;;
	*)
        parseMakefile $PWD < $file
      esac
    fi
  fi

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

Copyright 2K16 - 2K18 Indonesian Hacker Rulez