merge from donut (34109de2) · Commits · e / tools / etwrp

Android.mk

+1 −3

Original line number	Diff line number	Diff line
		@@ -9,7 +9,6 @@ ifeq ($(TARGET_ARCH),arm)
		LOCAL_SRC_FILES := \
		recovery.c \
		bootloader.c \
		commands.c \
		firmware.c \
		install.c \
		roots.c \
		@@ -32,14 +31,13 @@ LOCAL_CFLAGS += -DRECOVERY_API_VERSION=$(RECOVERY_API_VERSION)

		LOCAL_MODULE_TAGS := eng

		LOCAL_STATIC_LIBRARIES := libminzip libunz libamend libmtdutils libmincrypt
		LOCAL_STATIC_LIBRARIES := libminzip libunz libmtdutils libmincrypt
		LOCAL_STATIC_LIBRARIES += libminui libpixelflinger_static libpng libcutils
		LOCAL_STATIC_LIBRARIES += libstdc++ libc

		include $(BUILD_EXECUTABLE)

		include $(commands_recovery_local_path)/minui/Android.mk
		include $(commands_recovery_local_path)/amend/Android.mk
		include $(commands_recovery_local_path)/minzip/Android.mk
		include $(commands_recovery_local_path)/mtdutils/Android.mk
		include $(commands_recovery_local_path)/tools/Android.mk

amend/Android.mk

deleted100644 → 0

+0 −51

Original line number	Diff line number	Diff line
		# Copyright 2007 The Android Open Source Project
		#

		LOCAL_PATH := $(call my-dir)

		amend_src_files := \
		amend.c \
		lexer.l \
		parser_y.y \
		ast.c \
		symtab.c \
		commands.c \
		execute.c

		amend_test_files := \
		test_symtab.c \
		test_commands.c

		# "-x c" forces the lex/yacc files to be compiled as c;
		# the build system otherwise forces them to be c++.
		amend_cflags := -Wall -x c

		#
		# Build the host-side command line tool
		#
		include $(CLEAR_VARS)

		LOCAL_SRC_FILES := \
		$(amend_src_files) \
		$(amend_test_files) \
		register.c \
		main.c

		LOCAL_CFLAGS := $(amend_cflags) -g -O0
		LOCAL_MODULE := amend
		LOCAL_YACCFLAGS := -v

		include $(BUILD_HOST_EXECUTABLE)

		#
		# Build the device-side library
		#
		include $(CLEAR_VARS)

		LOCAL_SRC_FILES := $(amend_src_files)
		LOCAL_SRC_FILES += $(amend_test_files)

		LOCAL_CFLAGS := $(amend_cflags)
		LOCAL_MODULE := libamend

		include $(BUILD_STATIC_LIBRARY)

amend/amend.c

deleted100644 → 0

+0 −33

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2007 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <stdlib.h>
		#include "amend.h"
		#include "lexer.h"
		#include "parser.h"

		extern const AmCommandList *gCommands;

		const AmCommandList *
		parseAmendScript(const char *buf, size_t bufLen)
		{
		setLexerInputBuffer(buf, bufLen);
		int ret = yyparse();
		if (ret != 0) {
		return NULL;
		}
		return gCommands;
		}

amend/amend.h

deleted100644 → 0

+0 −25

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2007 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef AMEND_H_
		#define AMEND_H_

		#include "ast.h"
		#include "execute.h"

		const AmCommandList parseAmendScript(const char buf, size_t bufLen);

		#endif // AMEND_H_

amend/ast.c

deleted100644 → 0

+0 −198

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2007 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <stdio.h>
		#include "ast.h"

		static const char gSpaces[] =
		" "
		" "
		" "
		" "
		" "
		" "
		" ";
		const int gSpacesMax = sizeof(gSpaces) - 1;

		static const char *
		pad(int level)
		{
		level *= 4;
		if (level > gSpacesMax) {
		level = gSpacesMax;
		}
		return gSpaces + gSpacesMax - level;
		}

		void dumpBooleanValue(int level, const AmBooleanValue *booleanValue);
		void dumpStringValue(int level, const AmStringValue *stringValue);

		void
		dumpBooleanExpression(int level, const AmBooleanExpression *booleanExpression)
		{
		const char *op;
		bool unary = false;

		switch (booleanExpression->op) {
		case AM_BOP_NOT:
		op = "NOT";
		unary = true;
		break;
		case AM_BOP_EQ:
		op = "EQ";
		break;
		case AM_BOP_NE:
		op = "NE";
		break;
		case AM_BOP_AND:
		op = "AND";
		break;
		case AM_BOP_OR:
		op = "OR";
		break;
		default:
		op = "??";
		break;
		}

		printf("%sBOOLEAN %s {\n", pad(level), op);
		dumpBooleanValue(level + 1, booleanExpression->arg1);
		if (!unary) {
		dumpBooleanValue(level + 1, booleanExpression->arg2);
		}
		printf("%s}\n", pad(level));
		}

		void
		dumpFunctionArguments(int level, const AmFunctionArguments *functionArguments)
		{
		int i;
		for (i = 0; i < functionArguments->argc; i++) {
		dumpStringValue(level, &functionArguments->argv[i]);
		}
		}

		void
		dumpFunctionCall(int level, const AmFunctionCall *functionCall)
		{
		printf("%sFUNCTION %s (\n", pad(level), functionCall->name);
		dumpFunctionArguments(level + 1, functionCall->args);
		printf("%s)\n", pad(level));
		}

		void
		dumpStringValue(int level, const AmStringValue *stringValue)
		{
		switch (stringValue->type) {
		case AM_SVAL_LITERAL:
		printf("%s\"%s\"\n", pad(level), stringValue->u.literal);
		break;
		case AM_SVAL_FUNCTION:
		dumpFunctionCall(level, stringValue->u.function);
		break;
		default:
		printf("%s<UNKNOWN SVAL TYPE %d>\n", pad(level), stringValue->type);
		break;
		}
		}

		void
		dumpStringComparisonExpression(int level,
		const AmStringComparisonExpression *stringComparisonExpression)
		{
		const char *op;

		switch (stringComparisonExpression->op) {
		case AM_SOP_LT:
		op = "LT";
		break;
		case AM_SOP_LE:
		op = "LE";
		break;
		case AM_SOP_GT:
		op = "GT";
		break;
		case AM_SOP_GE:
		op = "GE";
		break;
		case AM_SOP_EQ:
		op = "EQ";
		break;
		case AM_SOP_NE:
		op = "NE";
		break;
		default:
		op = "??";
		break;
		}
		printf("%sSTRING %s {\n", pad(level), op);
		dumpStringValue(level + 1, stringComparisonExpression->arg1);
		dumpStringValue(level + 1, stringComparisonExpression->arg2);
		printf("%s}\n", pad(level));
		}

		void
		dumpBooleanValue(int level, const AmBooleanValue *booleanValue)
		{
		switch (booleanValue->type) {
		case AM_BVAL_EXPRESSION:
		dumpBooleanExpression(level, &booleanValue->u.expression);
		break;
		case AM_BVAL_STRING_COMPARISON:
		dumpStringComparisonExpression(level,
		&booleanValue->u.stringComparison);
		break;
		default:
		printf("%s<UNKNOWN BVAL TYPE %d>\n", pad(1), booleanValue->type);
		break;
		}
		}

		void
		dumpWordList(const AmWordList *wordList)
		{
		int i;
		for (i = 0; i < wordList->argc; i++) {
		printf("%s\"%s\"\n", pad(1), wordList->argv[i]);
		}
		}

		void
		dumpCommandArguments(const AmCommandArguments *commandArguments)
		{
		if (commandArguments->booleanArgs) {
		dumpBooleanValue(1, commandArguments->u.b);
		} else {
		dumpWordList(commandArguments->u.w);
		}
		}

		void
		dumpCommand(const AmCommand *command)
		{
		printf("command \"%s\" {\n", command->name);
		dumpCommandArguments(command->args);
		printf("}\n");
		}

		void
		dumpCommandList(const AmCommandList *commandList)
		{
		int i;
		for (i = 0; i < commandList->commandCount; i++) {
		dumpCommand(commandList->commands[i]);
		}
		}