[showlog] adding envsetup.sh command showlog
[0xdroid:build.git] / envsetup.sh
1 function help() {
2 cat <<EOF
3 Invoke ". build/envsetup.sh" from your shell to add the following functions to your environment:
4 - croot:   Changes directory to the top of the tree.
5 - m:       Makes from the top of the tree.
6 - mm:      Builds all of the modules in the current directory.
7 - mmm:     Builds all of the modules in the supplied directories.
8 - cgrep:   Greps on all local C/C++ files.
9 - jgrep:   Greps on all local Java files.
10 - resgrep: Greps on all local res/*.xml files.
11 - godir:   Go to the directory containing a file.
12
13 Look at the source to view more functions. The complete list is:
14 EOF
15     T=$(gettop)
16     local A
17     A=""
18     for i in `cat $T/build/envsetup.sh | sed -n "/^function /s/function \([a-z_]*\).*/\1/p" | sort`; do
19       A="$A $i"
20     done
21     echo $A
22 }
23
24 # Get the value of a build variable as an absolute path.
25 function get_abs_build_var()
26 {
27     T=$(gettop)
28     if [ ! "$T" ]; then
29         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
30         return
31     fi
32     CALLED_FROM_SETUP=true BUILD_SYSTEM=build/core \
33       make --no-print-directory -C "$T" -f build/core/config.mk dumpvar-abs-$1
34 }
35
36 # Get the exact value of a build variable.
37 function get_build_var()
38 {
39     T=$(gettop)
40     if [ ! "$T" ]; then
41         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
42         return
43     fi
44     CALLED_FROM_SETUP=true BUILD_SYSTEM=build/core \
45       make --no-print-directory -C "$T" -f build/core/config.mk dumpvar-$1
46 }
47
48 # check to see if the supplied product is one we can build
49 function check_product()
50 {
51     T=$(gettop)
52     if [ ! "$T" ]; then
53         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
54         return
55     fi
56     CALLED_FROM_SETUP=true BUILD_SYSTEM=build/core \
57         TARGET_PRODUCT=$1 TARGET_BUILD_VARIANT= \
58         TARGET_SIMULATOR= TARGET_BUILD_TYPE= \
59         TARGET_BUILD_APPS= \
60         get_build_var TARGET_DEVICE > /dev/null
61     # hide successful answers, but allow the errors to show
62 }
63
64 VARIANT_CHOICES=(user userdebug eng)
65
66 # check to see if the supplied variant is valid
67 function check_variant()
68 {
69     for v in ${VARIANT_CHOICES[@]}
70     do
71         if [ "$v" = "$1" ]
72         then
73             return 0
74         fi
75     done
76     return 1
77 }
78
79 function setpaths()
80 {
81     T=$(gettop)
82     if [ ! "$T" ]; then
83         echo "Couldn't locate the top of the tree.  Try setting TOP."
84         return
85     fi
86
87     ##################################################################
88     #                                                                #
89     #              Read me before you modify this code               #
90     #                                                                #
91     #   This function sets ANDROID_BUILD_PATHS to what it is adding  #
92     #   to PATH, and the next time it is run, it removes that from   #
93     #   PATH.  This is required so lunch can be run more than once   #
94     #   and still have working paths.                                #
95     #                                                                #
96     ##################################################################
97
98     # out with the old
99     if [ -n $ANDROID_BUILD_PATHS ] ; then
100         export PATH=${PATH/$ANDROID_BUILD_PATHS/}
101     fi
102     if [ -n $ANDROID_PRE_BUILD_PATHS ] ; then
103         export PATH=${PATH/$ANDROID_PRE_BUILD_PATHS/}
104     fi
105
106     # and in with the new
107     CODE_REVIEWS=
108     prebuiltdir=$(getprebuilt)
109     export ANDROID_EABI_TOOLCHAIN=$prebuiltdir/toolchain/arm-eabi-4.4.3/bin
110     export ANDROID_TOOLCHAIN=$ANDROID_EABI_TOOLCHAIN
111     export ANDROID_QTOOLS=$T/development/emulator/qtools
112     export ANDROID_BUILD_PATHS=:$(get_build_var ANDROID_BUILD_PATHS):$ANDROID_QTOOLS:$ANDROID_TOOLCHAIN:$ANDROID_EABI_TOOLCHAIN$CODE_REVIEWS
113     export PATH=$PATH$ANDROID_BUILD_PATHS
114
115     unset ANDROID_JAVA_TOOLCHAIN
116     if [ -n "$JAVA_HOME" ]; then
117         export ANDROID_JAVA_TOOLCHAIN=$JAVA_HOME/bin
118     fi
119     export ANDROID_PRE_BUILD_PATHS=$ANDROID_JAVA_TOOLCHAIN
120     if [ -n "$ANDROID_PRE_BUILD_PATHS" ]; then
121         export PATH=$ANDROID_PRE_BUILD_PATHS:$PATH
122     fi
123
124     unset ANDROID_PRODUCT_OUT
125     export ANDROID_PRODUCT_OUT=$(get_abs_build_var PRODUCT_OUT)
126     export OUT=$ANDROID_PRODUCT_OUT
127
128     # needed for building linux on MacOS
129     # TODO: fix the path
130     #export HOST_EXTRACFLAGS="-I "$T/system/kernel_headers/host_include
131
132     # needed for OProfile to post-process collected samples
133     export OPROFILE_EVENTS_DIR=$prebuiltdir/oprofile
134 }
135
136 function printconfig()
137 {
138     T=$(gettop)
139     if [ ! "$T" ]; then
140         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
141         return
142     fi
143     get_build_var report_config
144 }
145
146 function set_stuff_for_environment()
147 {
148     settitle
149     set_java_home
150     setpaths
151     set_sequence_number
152
153     export ANDROID_BUILD_TOP=$(gettop)
154 }
155
156 function set_sequence_number()
157 {
158     export BUILD_ENV_SEQUENCE_NUMBER=10
159 }
160
161 function settitle()
162 {
163     if [ "$STAY_OFF_MY_LAWN" = "" ]; then
164         local product=$TARGET_PRODUCT
165         local variant=$TARGET_BUILD_VARIANT
166         local apps=$TARGET_BUILD_APPS
167         if [ -z "$apps" ]; then
168             export PROMPT_COMMAND="echo -ne \"\033]0;[${product}-${variant}] ${USER}@${HOSTNAME}: ${PWD}\007\""
169         else
170             export PROMPT_COMMAND="echo -ne \"\033]0;[$apps $variant] ${USER}@${HOSTNAME}: ${PWD}\007\""
171         fi
172     fi
173 }
174
175 case `uname -s` in
176     Linux)
177         function choosesim()
178         {
179             echo "Build for the simulator or the device?"
180             echo "     1. Device"
181             echo "     2. Simulator"
182             echo
183
184             export TARGET_SIMULATOR=
185             local ANSWER
186             while [ -z $TARGET_SIMULATOR ]
187             do
188                 echo -n "Which would you like? [1] "
189                 if [ -z "$1" ] ; then
190                     read ANSWER
191                 else
192                     echo $1
193                     ANSWER=$1
194                 fi
195                 case $ANSWER in
196                 "")
197                     export TARGET_SIMULATOR=false
198                     ;;
199                 1)
200                     export TARGET_SIMULATOR=false
201                     ;;
202                 Device)
203                     export TARGET_SIMULATOR=false
204                     ;;
205                 2)
206                     export TARGET_SIMULATOR=true
207                     ;;
208                 Simulator)
209                     export TARGET_SIMULATOR=true
210                     ;;
211                 *)
212                     echo
213                     echo "I didn't understand your response.  Please try again."
214                     echo
215                     ;;
216                 esac
217                 if [ -n "$1" ] ; then
218                     break
219                 fi
220             done
221
222             set_stuff_for_environment
223         }
224         ;;
225     *)
226         function choosesim()
227         {
228             echo "Only device builds are supported for" `uname -s`
229             echo "     Forcing TARGET_SIMULATOR=false"
230             echo
231             if [ -z "$1" ]
232             then
233                 echo -n "Press enter: "
234                 read
235             fi
236
237             export TARGET_SIMULATOR=false
238             set_stuff_for_environment
239         }
240         ;;
241 esac
242
243 function choosetype()
244 {
245     echo "Build type choices are:"
246     echo "     1. release"
247     echo "     2. debug"
248     echo
249
250     local DEFAULT_NUM DEFAULT_VALUE
251     if [ $TARGET_SIMULATOR = "false" ] ; then
252         DEFAULT_NUM=1
253         DEFAULT_VALUE=release
254     else
255         DEFAULT_NUM=2
256         DEFAULT_VALUE=debug
257     fi
258
259     export TARGET_BUILD_TYPE=
260     local ANSWER
261     while [ -z $TARGET_BUILD_TYPE ]
262     do
263         echo -n "Which would you like? ["$DEFAULT_NUM"] "
264         if [ -z "$1" ] ; then
265             read ANSWER
266         else
267             echo $1
268             ANSWER=$1
269         fi
270         case $ANSWER in
271         "")
272             export TARGET_BUILD_TYPE=$DEFAULT_VALUE
273             ;;
274         1)
275             export TARGET_BUILD_TYPE=release
276             ;;
277         release)
278             export TARGET_BUILD_TYPE=release
279             ;;
280         2)
281             export TARGET_BUILD_TYPE=debug
282             ;;
283         debug)
284             export TARGET_BUILD_TYPE=debug
285             ;;
286         *)
287             echo
288             echo "I didn't understand your response.  Please try again."
289             echo
290             ;;
291         esac
292         if [ -n "$1" ] ; then
293             break
294         fi
295     done
296
297     set_stuff_for_environment
298 }
299
300 #
301 # This function isn't really right:  It chooses a TARGET_PRODUCT
302 # based on the list of boards.  Usually, that gets you something
303 # that kinda works with a generic product, but really, you should
304 # pick a product by name.
305 #
306 function chooseproduct()
307 {
308     if [ "x$TARGET_PRODUCT" != x ] ; then
309         default_value=$TARGET_PRODUCT
310     else
311         if [ "$TARGET_SIMULATOR" = true ] ; then
312             default_value=sim
313         else
314             default_value=generic
315         fi
316     fi
317
318     export TARGET_PRODUCT=
319     local ANSWER
320     while [ -z "$TARGET_PRODUCT" ]
321     do
322         echo -n "Which product would you like? [$default_value] "
323         if [ -z "$1" ] ; then
324             read ANSWER
325         else
326             echo $1
327             ANSWER=$1
328         fi
329
330         if [ -z "$ANSWER" ] ; then
331             export TARGET_PRODUCT=$default_value
332         else
333             if check_product $ANSWER
334             then
335                 export TARGET_PRODUCT=$ANSWER
336             else
337                 echo "** Not a valid product: $ANSWER"
338             fi
339         fi
340         if [ -n "$1" ] ; then
341             break
342         fi
343     done
344
345     set_stuff_for_environment
346 }
347
348 function choosevariant()
349 {
350     echo "Variant choices are:"
351     local index=1
352     local v
353     for v in ${VARIANT_CHOICES[@]}
354     do
355         # The product name is the name of the directory containing
356         # the makefile we found, above.
357         echo "     $index. $v"
358         index=$(($index+1))
359     done
360
361     local default_value=eng
362     local ANSWER
363
364     export TARGET_BUILD_VARIANT=
365     while [ -z "$TARGET_BUILD_VARIANT" ]
366     do
367         echo -n "Which would you like? [$default_value] "
368         if [ -z "$1" ] ; then
369             read ANSWER
370         else
371             echo $1
372             ANSWER=$1
373         fi
374
375         if [ -z "$ANSWER" ] ; then
376             export TARGET_BUILD_VARIANT=$default_value
377         elif (echo -n $ANSWER | grep -q -e "^[0-9][0-9]*$") ; then
378             if [ "$ANSWER" -le "${#VARIANT_CHOICES[@]}" ] ; then
379                 export TARGET_BUILD_VARIANT=${VARIANT_CHOICES[$(($ANSWER-$_arrayoffset))]}
380             fi
381         else
382             if check_variant $ANSWER
383             then
384                 export TARGET_BUILD_VARIANT=$ANSWER
385             else
386                 echo "** Not a valid variant: $ANSWER"
387             fi
388         fi
389         if [ -n "$1" ] ; then
390             break
391         fi
392     done
393 }
394
395 function choosecombo()
396 {
397     choosesim $1
398
399     echo
400     echo
401     choosetype $2
402
403     echo
404     echo
405     chooseproduct $3
406
407     echo
408     echo
409     choosevariant $4
410
411     echo
412     set_stuff_for_environment
413     printconfig
414 }
415
416 # Clear this variable.  It will be built up again when the vendorsetup.sh
417 # files are included at the end of this file.
418 unset LUNCH_MENU_CHOICES
419 function add_lunch_combo()
420 {
421     local new_combo=$1
422     local c
423     for c in ${LUNCH_MENU_CHOICES[@]} ; do
424         if [ "$new_combo" = "$c" ] ; then
425             return
426         fi
427     done
428     LUNCH_MENU_CHOICES=(${LUNCH_MENU_CHOICES[@]} $new_combo)
429 }
430
431 # add the default one here
432 add_lunch_combo generic-eng
433
434 # if we're on linux, add the simulator.  There is a special case
435 # in lunch to deal with the simulator
436 if [ "$(uname)" = "Linux" ] ; then
437     add_lunch_combo simulator
438 fi
439
440 function print_lunch_menu()
441 {
442     local uname=$(uname)
443     echo
444     echo "You're building on" $uname
445     echo
446     echo "Lunch menu... pick a combo:"
447
448     local i=1
449     local choice
450     for choice in ${LUNCH_MENU_CHOICES[@]}
451     do
452         echo "     $i. $choice"
453         i=$(($i+1))
454     done
455
456     echo
457 }
458
459 function lunch()
460 {
461     local answer
462
463     if [ "$1" ] ; then
464         answer=$1
465     else
466         print_lunch_menu
467         echo -n "Which would you like? [generic-eng] "
468         read answer
469     fi
470
471     local selection=
472
473     if [ -z "$answer" ]
474     then
475         selection=generic-eng
476     elif [ "$answer" = "simulator" ]
477     then
478         selection=simulator
479     elif (echo -n $answer | grep -q -e "^[0-9][0-9]*$")
480     then
481         if [ $answer -le ${#LUNCH_MENU_CHOICES[@]} ]
482         then
483             selection=${LUNCH_MENU_CHOICES[$(($answer-$_arrayoffset))]}
484         fi
485     elif (echo -n $answer | grep -q -e "^[^\-][^\-]*-[^\-][^\-]*$")
486     then
487         selection=$answer
488     fi
489
490     if [ -z "$selection" ]
491     then
492         echo
493         echo "Invalid lunch combo: $answer"
494         return 1
495     fi
496
497     export TARGET_BUILD_APPS=
498
499     # special case the simulator
500     if [ "$selection" = "simulator" ]
501     then
502         export TARGET_PRODUCT=sim
503         export TARGET_BUILD_VARIANT=eng
504         export TARGET_SIMULATOR=true
505         export TARGET_BUILD_TYPE=debug
506     else
507         local product=$(echo -n $selection | sed -e "s/-.*$//")
508         check_product $product
509         if [ $? -ne 0 ]
510         then
511             echo
512             echo "** Don't have a product spec for: '$product'"
513             echo "** Do you have the right repo manifest?"
514             product=
515         fi
516
517         local variant=$(echo -n $selection | sed -e "s/^[^\-]*-//")
518         check_variant $variant
519         if [ $? -ne 0 ]
520         then
521             echo
522             echo "** Invalid variant: '$variant'"
523             echo "** Must be one of ${VARIANT_CHOICES[@]}"
524             variant=
525         fi
526
527         if [ -z "$product" -o -z "$variant" ]
528         then
529             echo
530             return 1
531         fi
532
533         export TARGET_PRODUCT=$product
534         export TARGET_BUILD_VARIANT=$variant
535         export TARGET_SIMULATOR=false
536         export TARGET_BUILD_TYPE=release
537     fi # !simulator
538
539     echo
540
541     set_stuff_for_environment
542     printconfig
543 }
544
545 # Configures the build to build unbundled apps.
546 # Run tapas with one ore more app names (from LOCAL_PACKAGE_NAME)
547 function tapas()
548 {
549     local variant=$(echo -n $(echo $* | xargs -n 1 echo | grep -E '^(user|userdebug|eng)$'))
550     local apps=$(echo -n $(echo $* | xargs -n 1 echo | grep -E -v '^(user|userdebug|eng)$'))
551
552     if [ $(echo $variant | wc -w) -gt 1 ]; then
553         echo "tapas: Error: Multiple build variants supplied: $variant"
554         return
555     fi
556     if [ -z "$variant" ]; then
557         variant=eng
558     fi
559     if [ -z "$apps" ]; then
560         apps=all
561     fi
562
563     export TARGET_PRODUCT=generic
564     export TARGET_BUILD_VARIANT=$variant
565     export TARGET_SIMULATOR=false
566     export TARGET_BUILD_TYPE=release
567     export TARGET_BUILD_APPS=$apps
568
569     set_stuff_for_environment
570     printconfig
571 }
572
573 function gettop
574 {
575     local TOPFILE=build/core/envsetup.mk
576     if [ -n "$TOP" -a -f "$TOP/$TOPFILE" ] ; then
577         echo $TOP
578     else
579         if [ -f $TOPFILE ] ; then
580             # The following circumlocution (repeated below as well) ensures
581             # that we record the true directory name and not one that is
582             # faked up with symlink names.
583             PWD= /bin/pwd
584         else
585             # We redirect cd to /dev/null in case it's aliased to
586             # a command that prints something as a side-effect
587             # (like pushd)
588             local HERE=$PWD
589             T=
590             while [ \( ! \( -f $TOPFILE \) \) -a \( $PWD != "/" \) ]; do
591                 cd .. > /dev/null
592                 T=`PWD= /bin/pwd`
593             done
594             cd $HERE > /dev/null
595             if [ -f "$T/$TOPFILE" ]; then
596                 echo $T
597             fi
598         fi
599     fi
600 }
601
602 function m()
603 {
604     T=$(gettop)
605     if [ "$T" ]; then
606         make -C $T $@
607     else
608         echo "Couldn't locate the top of the tree.  Try setting TOP."
609     fi
610 }
611
612 function findmakefile()
613 {
614     TOPFILE=build/core/envsetup.mk
615     # We redirect cd to /dev/null in case it's aliased to
616     # a command that prints something as a side-effect
617     # (like pushd)
618     local HERE=$PWD
619     T=
620     while [ \( ! \( -f $TOPFILE \) \) -a \( $PWD != "/" \) ]; do
621         T=$PWD
622         if [ -f "$T/Android.mk" ]; then
623             echo $T/Android.mk
624             cd $HERE > /dev/null
625             return
626         fi
627         cd .. > /dev/null
628     done
629     cd $HERE > /dev/null
630 }
631
632 function mm()
633 {
634     # If we're sitting in the root of the build tree, just do a
635     # normal make.
636     if [ -f build/core/envsetup.mk -a -f Makefile ]; then
637         make $@
638     else
639         # Find the closest Android.mk file.
640         T=$(gettop)
641         local M=$(findmakefile)
642         # Remove the path to top as the makefilepath needs to be relative
643         local M=`echo $M|sed 's:'$T'/::'`
644         if [ ! "$T" ]; then
645             echo "Couldn't locate the top of the tree.  Try setting TOP."
646         elif [ ! "$M" ]; then
647             echo "Couldn't locate a makefile from the current directory."
648         else
649             ONE_SHOT_MAKEFILE=$M make -C $T all_modules $@
650         fi
651     fi
652 }
653
654 function mmm()
655 {
656     T=$(gettop)
657     if [ "$T" ]; then
658         local MAKEFILE=
659         local ARGS=
660         local DIR TO_CHOP
661         local DASH_ARGS=$(echo "$@" | awk -v RS=" " -v ORS=" " '/^-.*$/')
662         local DIRS=$(echo "$@" | awk -v RS=" " -v ORS=" " '/^[^-].*$/')
663         for DIR in $DIRS ; do
664             DIR=`echo $DIR | sed -e 's:/$::'`
665             if [ -f $DIR/Android.mk ]; then
666                 TO_CHOP=`(cd -P -- $T && pwd -P) | wc -c | tr -d ' '`
667                 TO_CHOP=`expr $TO_CHOP + 1`
668                 START=`PWD= /bin/pwd`
669                 MFILE=`echo $START | cut -c${TO_CHOP}-`
670                 if [ "$MFILE" = "" ] ; then
671                     MFILE=$DIR/Android.mk
672                 else
673                     MFILE=$MFILE/$DIR/Android.mk
674                 fi
675                 MAKEFILE="$MAKEFILE $MFILE"
676             else
677                 if [ "$DIR" = snod ]; then
678                     ARGS="$ARGS snod"
679                 elif [ "$DIR" = showcommands ]; then
680                     ARGS="$ARGS showcommands"
681                 elif [ "$DIR" = dist ]; then
682                     ARGS="$ARGS dist"
683                 else
684                     echo "No Android.mk in $DIR."
685                     return 1
686                 fi
687             fi
688         done
689         ONE_SHOT_MAKEFILE="$MAKEFILE" make -C $T $DASH_ARGS all_modules $ARGS
690     else
691         echo "Couldn't locate the top of the tree.  Try setting TOP."
692     fi
693 }
694
695 function croot()
696 {
697     T=$(gettop)
698     if [ "$T" ]; then
699         cd $(gettop)
700     else
701         echo "Couldn't locate the top of the tree.  Try setting TOP."
702     fi
703 }
704
705 function cproj()
706 {
707     TOPFILE=build/core/envsetup.mk
708     # We redirect cd to /dev/null in case it's aliased to
709     # a command that prints something as a side-effect
710     # (like pushd)
711     local HERE=$PWD
712     T=
713     while [ \( ! \( -f $TOPFILE \) \) -a \( $PWD != "/" \) ]; do
714         T=$PWD
715         if [ -f "$T/Android.mk" ]; then
716             cd $T
717             return
718         fi
719         cd .. > /dev/null
720     done
721     cd $HERE > /dev/null
722     echo "can't find Android.mk"
723 }
724
725 function pid()
726 {
727    local EXE="$1"
728    if [ "$EXE" ] ; then
729        local PID=`adb shell ps | fgrep $1 | sed -e 's/[^ ]* *\([0-9]*\).*/\1/'`
730        echo "$PID"
731    else
732        echo "usage: pid name"
733    fi
734 }
735
736 # systemstack - dump the current stack trace of all threads in the system process
737 # to the usual ANR traces file
738 function systemstack()
739 {
740     adb shell echo '""' '>>' /data/anr/traces.txt && adb shell chmod 776 /data/anr/traces.txt && adb shell kill -3 $(pid system_server)
741 }
742
743 function gdbclient()
744 {
745    local OUT_ROOT=$(get_abs_build_var PRODUCT_OUT)
746    local OUT_SYMBOLS=$(get_abs_build_var TARGET_OUT_UNSTRIPPED)
747    local OUT_SO_SYMBOLS=$(get_abs_build_var TARGET_OUT_SHARED_LIBRARIES_UNSTRIPPED)
748    local OUT_EXE_SYMBOLS=$(get_abs_build_var TARGET_OUT_EXECUTABLES_UNSTRIPPED)
749    local PREBUILTS=$(get_abs_build_var ANDROID_PREBUILTS)
750    if [ "$OUT_ROOT" -a "$PREBUILTS" ]; then
751        local EXE="$1"
752        if [ "$EXE" ] ; then
753            EXE=$1
754        else
755            EXE="app_process"
756        fi
757
758        local PORT="$2"
759        if [ "$PORT" ] ; then
760            PORT=$2
761        else
762            PORT=":5039"
763        fi
764
765        local PID
766        local PROG="$3"
767        if [ "$PROG" ] ; then
768            PID=`pid $3`
769            adb forward "tcp$PORT" "tcp$PORT"
770            adb shell gdbserver $PORT --attach $PID &
771            sleep 2
772        else
773                echo ""
774                echo "If you haven't done so already, do this first on the device:"
775                echo "    gdbserver $PORT /system/bin/$EXE"
776                    echo " or"
777                echo "    gdbserver $PORT --attach $PID"
778                echo ""
779        fi
780
781        echo >|"$OUT_ROOT/gdbclient.cmds" "set solib-absolute-prefix $OUT_SYMBOLS"
782        echo >>"$OUT_ROOT/gdbclient.cmds" "set solib-search-path $OUT_SO_SYMBOLS"
783        echo >>"$OUT_ROOT/gdbclient.cmds" "target remote $PORT"
784        echo >>"$OUT_ROOT/gdbclient.cmds" ""
785
786        arm-eabi-gdb -x "$OUT_ROOT/gdbclient.cmds" "$OUT_EXE_SYMBOLS/$EXE"
787   else
788        echo "Unable to determine build system output dir."
789    fi
790
791 }
792
793 case `uname -s` in
794     Darwin)
795         function sgrep()
796         {
797             find -E . -type f -iregex '.*\.(c|h|cpp|S|java|xml|sh|mk)' -print0 | xargs -0 grep --color -n "$@"
798         }
799
800         ;;
801     *)
802         function sgrep()
803         {
804             find . -type f -iregex '.*\.\(c\|h\|cpp\|S\|java\|xml\|sh\|mk\)' -print0 | xargs -0 grep --color -n "$@"
805         }
806         ;;
807 esac
808
809 function jgrep()
810 {
811     find . -type f -name "*\.java" -print0 | xargs -0 grep --color -n "$@"
812 }
813
814 function cgrep()
815 {
816     find . -type f \( -name '*.c' -o -name '*.cc' -o -name '*.cpp' -o -name '*.h' \) -print0 | xargs -0 grep --color -n "$@"
817 }
818
819 function resgrep()
820 {
821     for dir in `find . -name res -type d`; do find $dir -type f -name '*\.xml' -print0 | xargs -0 grep --color -n "$@"; done;
822 }
823
824 case `uname -s` in
825     Darwin)
826         function mgrep()
827         {
828             find -E . -type f -iregex '.*/(Makefile|Makefile\..*|.*\.make|.*\.mak|.*\.mk)' -print0 | xargs -0 grep --color -n "$@"
829         }
830
831         function treegrep()
832         {
833             find -E . -type f -iregex '.*\.(c|h|cpp|S|java|xml)' -print0 | xargs -0 grep --color -n -i "$@"
834         }
835
836         ;;
837     *)
838         function mgrep()
839         {
840             find . -regextype posix-egrep -iregex '(.*\/Makefile|.*\/Makefile\..*|.*\.make|.*\.mak|.*\.mk)' -type f -print0 | xargs -0 grep --color -n "$@"
841         }
842
843         function treegrep()
844         {
845             find . -regextype posix-egrep -iregex '.*\.(c|h|cpp|S|java|xml)' -type f -print0 | xargs -0 grep --color -n -i "$@"
846         }
847
848         ;;
849 esac
850
851 function getprebuilt
852 {
853     get_abs_build_var ANDROID_PREBUILTS
854 }
855
856 function tracedmdump()
857 {
858     T=$(gettop)
859     if [ ! "$T" ]; then
860         echo "Couldn't locate the top of the tree.  Try setting TOP."
861         return
862     fi
863     local prebuiltdir=$(getprebuilt)
864     local KERNEL=$T/prebuilt/android-arm/kernel/vmlinux-qemu
865
866     local TRACE=$1
867     if [ ! "$TRACE" ] ; then
868         echo "usage:  tracedmdump  tracename"
869         return
870     fi
871
872     if [ ! -r "$KERNEL" ] ; then
873         echo "Error: cannot find kernel: '$KERNEL'"
874         return
875     fi
876
877     local BASETRACE=$(basename $TRACE)
878     if [ "$BASETRACE" = "$TRACE" ] ; then
879         TRACE=$ANDROID_PRODUCT_OUT/traces/$TRACE
880     fi
881
882     echo "post-processing traces..."
883     rm -f $TRACE/qtrace.dexlist
884     post_trace $TRACE
885     if [ $? -ne 0 ]; then
886         echo "***"
887         echo "*** Error: malformed trace.  Did you remember to exit the emulator?"
888         echo "***"
889         return
890     fi
891     echo "generating dexlist output..."
892     /bin/ls $ANDROID_PRODUCT_OUT/system/framework/*.jar $ANDROID_PRODUCT_OUT/system/app/*.apk $ANDROID_PRODUCT_OUT/data/app/*.apk 2>/dev/null | xargs dexlist > $TRACE/qtrace.dexlist
893     echo "generating dmtrace data..."
894     q2dm -r $ANDROID_PRODUCT_OUT/symbols $TRACE $KERNEL $TRACE/dmtrace || return
895     echo "generating html file..."
896     dmtracedump -h $TRACE/dmtrace >| $TRACE/dmtrace.html || return
897     echo "done, see $TRACE/dmtrace.html for details"
898     echo "or run:"
899     echo "    traceview $TRACE/dmtrace"
900 }
901
902 # communicate with a running device or emulator, set up necessary state,
903 # and run the hat command.
904 function runhat()
905 {
906     # process standard adb options
907     local adbTarget=""
908     if [ $1 = "-d" -o $1 = "-e" ]; then
909         adbTarget=$1
910         shift 1
911     elif [ $1 = "-s" ]; then
912         adbTarget="$1 $2"
913         shift 2
914     fi
915     local adbOptions=${adbTarget}
916     echo adbOptions = ${adbOptions}
917
918     # runhat options
919     local targetPid=$1
920     local outputFile=$2
921
922     if [ "$targetPid" = "" ]; then
923         echo "Usage: runhat [ -d | -e | -s serial ] target-pid [output-file]"
924         return
925     fi
926
927     # confirm hat is available
928     if [ -z $(which hat) ]; then
929         echo "hat is not available in this configuration."
930         return
931     fi
932
933     adb ${adbOptions} shell >/dev/null mkdir /data/misc
934     adb ${adbOptions} shell chmod 777 /data/misc
935
936     # send a SIGUSR1 to cause the hprof dump
937     echo "Poking $targetPid and waiting for data..."
938     adb ${adbOptions} shell kill -10 $targetPid
939     echo "Press enter when logcat shows \"hprof: heap dump completed\""
940     echo -n "> "
941     read
942
943     local availFiles=( $(adb ${adbOptions} shell ls /data/misc | grep '^heap-dump' | sed -e 's/.*heap-dump-/heap-dump-/' | sort -r | tr '[:space:][:cntrl:]' ' ') )
944     local devFile=/data/misc/${availFiles[0]}
945     local localFile=/tmp/$$-hprof
946
947     echo "Retrieving file $devFile..."
948     adb ${adbOptions} pull $devFile $localFile
949
950     adb ${adbOptions} shell rm $devFile
951
952     echo "Running hat on $localFile"
953     echo "View the output by pointing your browser at http://localhost:7000/"
954     echo ""
955     hat $localFile
956 }
957
958 function getbugreports()
959 {
960     local reports=(`adb shell ls /sdcard/bugreports | tr -d '\r'`)
961
962     if [ ! "$reports" ]; then
963         echo "Could not locate any bugreports."
964         return
965     fi
966
967     local report
968     for report in ${reports[@]}
969     do
970         echo "/sdcard/bugreports/${report}"
971         adb pull /sdcard/bugreports/${report} ${report}
972         gunzip ${report}
973     done
974 }
975
976 function startviewserver()
977 {
978     local port=4939
979     if [ $# -gt 0 ]; then
980             port=$1
981     fi
982     adb shell service call window 1 i32 $port
983 }
984
985 function stopviewserver()
986 {
987     adb shell service call window 2
988 }
989
990 function isviewserverstarted()
991 {
992     adb shell service call window 3
993 }
994
995 function smoketest()
996 {
997     if [ ! "$ANDROID_PRODUCT_OUT" ]; then
998         echo "Couldn't locate output files.  Try running 'lunch' first." >&2
999         return
1000     fi
1001     T=$(gettop)
1002     if [ ! "$T" ]; then
1003         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
1004         return
1005     fi
1006
1007     (cd "$T" && mmm tests/SmokeTest) &&
1008       adb uninstall com.android.smoketest > /dev/null &&
1009       adb uninstall com.android.smoketest.tests > /dev/null &&
1010       adb install $ANDROID_PRODUCT_OUT/data/app/SmokeTestApp.apk &&
1011       adb install $ANDROID_PRODUCT_OUT/data/app/SmokeTest.apk &&
1012       adb shell am instrument -w com.android.smoketest.tests/android.test.InstrumentationTestRunner
1013 }
1014
1015 # simple shortcut to the runtest command
1016 function runtest()
1017 {
1018     T=$(gettop)
1019     if [ ! "$T" ]; then
1020         echo "Couldn't locate the top of the tree.  Try setting TOP." >&2
1021         return
1022     fi
1023     ("$T"/development/testrunner/runtest.py $@)
1024 }
1025
1026 function godir () {
1027     if [[ -z "$1" ]]; then
1028         echo "Usage: godir <regex>"
1029         return
1030     fi
1031     T=$(gettop)
1032     if [[ ! -f $T/filelist ]]; then
1033         echo -n "Creating index..."
1034         (cd $T; find . -wholename ./out -prune -o -wholename ./.repo -prune -o -type f > filelist)
1035         echo " Done"
1036         echo ""
1037     fi
1038     local lines
1039     lines=($(grep "$1" $T/filelist | sed -e 's/\/[^/]*$//' | sort | uniq)) 
1040     if [[ ${#lines[@]} = 0 ]]; then
1041         echo "Not found"
1042         return
1043     fi
1044     local pathname
1045     local choice
1046     if [[ ${#lines[@]} > 1 ]]; then
1047         while [[ -z "$pathname" ]]; do
1048             local index=1
1049             local line
1050             for line in ${lines[@]}; do
1051                 printf "%6s %s\n" "[$index]" $line
1052                 index=$(($index + 1)) 
1053             done
1054             echo
1055             echo -n "Select one: "
1056             unset choice
1057             read choice
1058             if [[ $choice -gt ${#lines[@]} || $choice -lt 1 ]]; then
1059                 echo "Invalid choice"
1060                 continue
1061             fi
1062             pathname=${lines[$(($choice-$_arrayoffset))]}
1063         done
1064     else
1065         # even though zsh arrays are 1-based, $foo[0] is an alias for $foo[1]
1066         pathname=${lines[0]}
1067     fi
1068     cd $T/$pathname
1069 }
1070
1071 # Force JAVA_HOME to point to java 1.6 if it isn't already set
1072 function set_java_home() {
1073     if [ ! "$JAVA_HOME" ]; then
1074         case `uname -s` in
1075             Darwin)
1076                 export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home
1077                 ;;
1078             *)
1079                 export JAVA_HOME=/usr/lib/jvm/java-6-sun
1080                 ;;
1081         esac
1082     fi
1083 }
1084
1085 # determine whether arrays are zero-based (bash) or one-based (zsh)
1086 _xarray=(a b c)
1087 if [ -z "${_xarray[${#_xarray[@]}]}" ]
1088 then
1089     _arrayoffset=1
1090 else
1091     _arrayoffset=0
1092 fi
1093 unset _xarray
1094
1095 # Execute the contents of any vendorsetup.sh files we can find.
1096 for f in `/bin/ls vendor/*/vendorsetup.sh vendor/*/build/vendorsetup.sh device/*/*/vendorsetup.sh 2> /dev/null`
1097 do
1098     echo "including $f"
1099     . $f
1100 done
1101 unset f
1102
1103
1104 # showlog
1105 function showlog() {
1106     if (( $# >= 1 ));then
1107         DAY=$1
1108     else
1109         DAY=1
1110     fi
1111     GIT_PAGER=less repo forall -c "git config --get-regexp 'remote.*.url' && git log --since=\"${DAY} days ago\"" 
1112 }