gitorious.org Git - 0xdroid:build.git/blob

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.

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 }

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 }

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 }

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 }

64 VARIANT_CHOICES=(user userdebug eng)

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 }

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

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 ##################################################################

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 {

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 {

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