Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 64893ccc authored by Doug Zongker's avatar Doug Zongker
Browse files

remove amend 

Yank all the code to install OTA packages out of the recovery binary
itself.  Now packages are installed by a binary included in the
package (run as a child of recovery), so we can make improvements in
the installation process without waiting for a new release to use
them.
parent bec02d57

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]);

    }

}