AXMLTemplate.bt

//--------------------------------------
//--- 010 Editor v3.1.3 Binary Template
//
// File:
// Author:
// Revision:
// Purpose:
//--------------------------------------

LittleEndian();

local int g_offset = 0;

enum {
    RES_NULL_TYPE               = 0x0000,
    RES_STRING_POOL_TYPE        = 0x0001,
    RES_TABLE_TYPE              = 0x0002,
    RES_XML_TYPE                = 0x0003,

    // Chunk types in RES_XML_TYPE
    RES_XML_FIRST_CHUNK_TYPE    = 0x0100,
    RES_XML_START_NAMESPACE_TYPE= 0x0100,
    RES_XML_END_NAMESPACE_TYPE  = 0x0101,
    RES_XML_START_ELEMENT_TYPE  = 0x0102,
    RES_XML_END_ELEMENT_TYPE    = 0x0103,
    RES_XML_CDATA_TYPE          = 0x0104,
    RES_XML_LAST_CHUNK_TYPE     = 0x017f,
    // This contains a uint32_t array mapping strings in the string
    // pool back to resource identifiers.  It is optional.
    RES_XML_RESOURCE_MAP_TYPE   = 0x0180,

    // Chunk types in RES_TABLE_TYPE
    RES_TABLE_PACKAGE_TYPE      = 0x0200,
    RES_TABLE_TYPE_TYPE         = 0x0201,
    RES_TABLE_TYPE_SPEC_TYPE    = 0x0202
};

typedef enum <uint> {
    CHUNK_HEAD	   = 0x00080003,
    CHUNK_STRING   = 0x001c0001,
    CHUNK_RESOURCE = 0x00080180,
	CHUNK_STARTNS  = 0x00100100,
	CHUNK_ENDNS    = 0x00100101,
	CHUNK_STARTTAG = 0x00100102,
	CHUNK_ENDTAG   = 0x00100103,
	CHUNK_TEXT     = 0x00100104
} axml_type;

// DimemsionTable[8] = {"px", "dip", "sp", "pt", "in", "mm", "", ""};
typedef enum <uint> {
    px = 0,
    dip,
    sp,
    pt,
    in,
    mm
} axml_dimension;

local float RadixTable[8] = {0.00390625f, 3.051758E-005f, 1.192093E-007f, 4.656613E-010f};

/* attributes' types */
typedef enum<uint> {

	ATTR_NULL 	= 0,
	ATTR_REFERENCE 	= 1,
	ATTR_ATTRIBUTE 	= 2,
	ATTR_STRING 	= 3,
	ATTR_FLOAT 	= 4,
	ATTR_DIMENSION 	= 5,
	ATTR_FRACTION 	= 6,
	
	ATTR_FIRSTINT 	= 16,

	ATTR_DEC 	= 16,
	ATTR_HEX	= 17,
	ATTR_BOOLEAN	= 18,

	ATTR_FIRSTCOLOR	= 28,
	ATTR_ARGB8 	= 28,
	ATTR_RGB8	= 29,
	ATTR_ARGB4	= 30,
	ATTR_RGB4	= 31,
	ATTR_LASTCOLOR	= 31,

	ATTR_LASTINT	= 31,
} axml_attr_type;

typedef struct {
    ushort type <format=hex>;
    ushort head_size;
    int size;
} axml_header;

typedef struct {
    uchar len;
    uchar enc_len;
    if (len > 0) {
        char data[len];
    }
} axml_string8;

typedef struct {
    ushort len;
    if (len > 0) {
        wchar_t data[len];
    }
} axml_string16;

typedef struct {
    uint offset;

    local int64 pos = FTell();
    local int off = sizeof(file.header) + file.strings.string_offset + offset;
    FSeek(g_offset + off);
//    Printf("offset=%x\n", off);

    local int isUtf8 = parentof(this).flag & (1<<8);
    if (isUtf8)
        axml_string8 astr;
    else
        axml_string16 astr;

    FSeek(pos);
} axml_string_offset <read=AxmlStringRead, optimize=false>;

string AxmlStringRead(axml_string_offset &o) {
    if (o.astr.len > 0)
        return o.astr.data;
    else
        return "NULL String";
}

typedef struct {
    axml_header header;
    int string_count;
    int style_count;
    int flag;
    int string_offset;
    int style_offset;
    if (string_count > 0) {
        axml_string_offset string_offsets[string_count] <comment="String item">;
    }

    if (style_count > 0) {
        uint style_offsets[style_count];
        off = style_offset - string_offset;
    } else {
        off = header.size - string_offset;
    }

    FSkip(off);
} axml_strings;

typedef struct {
    axml_header header;
    
    local int count = (header.size-8) / 4;
    uint ids[count] <format=hex>;
} axml_resources;

typedef struct {
    ushort size;
    uchar  res0;
    uchar  dateType <read=AxmlAttrTypeRead>;
    uint   data;
} axml_value;

typedef struct {
    int url <read=AxmlStringById>;
    int name <read=AxmlStringById>;
    int str <read=AxmlStringById>;

    axml_value value;
} axml_attr <read=AxmlAttrRead>;

string AxmlAttrTypeRead(uchar type) {
    if (type == ATTR_NULL)
        return EnumToString( ATTR_NULL );
    else if (type == ATTR_REFERENCE)
        return EnumToString( ATTR_REFERENCE );
    else if (type == ATTR_ATTRIBUTE)
        return EnumToString( ATTR_ATTRIBUTE );
    else if (type == ATTR_STRING)
        return EnumToString( ATTR_STRING );
    else if (type == ATTR_FLOAT)
        return EnumToString( ATTR_FLOAT );
    else if (type == ATTR_DIMENSION)
        return EnumToString( ATTR_DIMENSION );
    else if (type == ATTR_FRACTION)
        return EnumToString( ATTR_FRACTION );
    else if (type == ATTR_DEC)
        return EnumToString( ATTR_DEC );
    else if (type == ATTR_HEX)
        return EnumToString( ATTR_HEX );
    else if (type == ATTR_BOOLEAN)
        return EnumToString( ATTR_BOOLEAN );
    else if (type == ATTR_ARGB8)
        return EnumToString( ATTR_ARGB8 );
    else if (type == ATTR_RGB8)
        return EnumToString( ATTR_RGB8 );
    else if (type == ATTR_ARGB4)
        return EnumToString( ATTR_ARGB4 );
    else if (type == ATTR_RGB4)
        return EnumToString( ATTR_RGB4 );
    else if (type >= ATTR_FIRSTCOLOR && type <= ATTR_LASTCOLOR4)
        return "ATTR_COLOR";
    else if (type >= ATTR_FIRSTINT && type <= ATTR_LASTINT)
        return "ATTR_INT";
    else
        return "ATTR_UNKNOW";
}

string AxmlAttrRead(axml_attr &attr) {
    local uchar type = attr.value.dateType;
    string name = AxmlStringById(attr.name);
    string buf = "Unknow";

    if (type == ATTR_STRING) {
        local string val = AxmlStringById(attr.str);
        SPrintf(buf, "%s=%s", name, val);
    } else if (type == ATTR_NULL) {
        SPrintf(buf, "%s=NULL", name);
    } else if (type == ATTR_REFERENCE) {
        if (attr.value.data>>24 == 1) {
            SPrintf(buf, "%s=@android:%08X", name, attr.value.data);
        } else {
            SPrintf(buf, "%s=@%08X", name, attr.value.data);
        }
    } else if (type == ATTR_ATTRIBUTE) {
        if (attr.value.data>>24 == 1) {
            SPrintf(buf, "%s=?android:%08X", name, attr.value.data);
        } else {
            SPrintf(buf, "%s=?%08X", name, attr.value.data);
        }
    } else if (type == ATTR_FLOAT) {
        SPrintf(buf, "%s=%g", name, (float)attr.value.data);
    } else if (type == ATTR_DIMENSION) {
        SPrintf(buf, "%s=%f%s", name,
				(float)(attr.value.data & 0xffffff00) * RadixTable[(attr.data >> 4) & 0x03],
				DimemsionTable[attr.data & 0x0f] );
    } else if (type == ATTR_FRACTION) {
        SPrintf(buf, "%s=%f%s", name,
				(float)(attr.value.data & 0xffffff00) * RadixTable[(attr.value.data >> 4) & 0x03],
				FractionTable[attr.value.data & 0x0f] );
    } else if (type == ATTR_HEX) {
        SPrintf(buf, "%s=0x%08x", name, attr.value.data);
    } else if (type == ATTR_BOOLEAN) {
        if (attr.value.data == 0) {
            SPrintf(buf, "%s=false", name);
        } else {
            SPrintf(buf, "%s=true", name);
        }
    } else if (type >= ATTR_FIRSTCOLOR && type <= ATTR_LASTCOLOR) {
        SPrintf(buf, "%s=#%08x", name, attr.value.data);
    } else if (type >= ATTR_FIRSTINT && type <= ATTR_LASTINT) {
        SPrintf(buf, "%s=%d", name, attr.value.data);
    } else {
        SPrintf(buf, "%s=UNKNOW", name);
    }

    return buf;
}

typedef struct {
    uint type <format=hex, read=AxmlTypeString, comment="Chunk Type">;
    int chunk_size;
    int linenumber;
    int comment;

    if (type == CHUNK_STARTTAG) {
        int uri <read=AxmlStringById>;
        int name <read=AxmlStringById>;
        ushort attr_start;
        ushort attr_size;
        ushort attr_count;
        ushort idIndex;
        ushort classIndex;
        ushort styleIndex;
        if (attr_count > 0) {
            axml_attr attrs[attr_count];
        }
    } else if (type == CHUNK_ENDTAG) {
        int url;
        int name <read=AxmlStringById>;
    } else if (type == CHUNK_STARTNS) {
        int prefix <read=AxmlStringById>;
        int uri <read=AxmlStringById>;
    } else if (type == CHUNK_ENDNS) {
        int prefix <read=AxmlStringById>;
        int uri <read=AxmlStringById>;
    } else if (type == CHUNK_TEXT) {
        int text;
        int unknow;
    }
} axml_node <read=AxmlNodeRead>;

string AxmlNodeRead(axml_node &node) {
    string buf = AxmlTypeString(node.type);
    if (node.type == CHUNK_STARTNS) {
        SPrintf(buf, "<xmlns:%s>", AxmlStringById(node.prefix));
    } else if (node.type == CHUNK_ENDNS) {
        SPrintf(buf, "</xmlns:%s>", AxmlStringById(node.prefix));
    } else if (node.type == CHUNK_STARTTAG) {
        SPrintf(buf, "<%s>", AxmlStringById(node.name));
    } else if (node.type == CHUNK_ENDTAG) {
        SPrintf(buf, "</%s>", AxmlStringById(node.name));
    }
    return buf;
}

string AxmlTypeString(uint &type) {
    if (type == CHUNK_HEAD)
        return "TYPE_HEAD";
    else if (type == CHUNK_STRING)
        return "TYPE_STRINGS";
    else if (type == CHUNK_RESOURCE)
        return "TYPE_RESOURCES";
    else if (type == CHUNK_STARTNS)
        return "TYPE_NS_START";
    else if (type == CHUNK_ENDNS)
        return "TYPE_NS_END";
    else if (type == CHUNK_STARTTAG)
        return "TYPE_TAG_START";
    else if (type == CHUNK_ENDTAG)
        return "TYPE_TAG_END";
    else if (type == CHUNK_TEXT)
        return "TYPE_TEXT";
    else
        return "TYPE_UNKNOW";
}

struct FILE {
    local int off;
    local int total;

    axml_header header;
    axml_strings strings;
    axml_resources resources;

    total = 0;
    do {
        total += 1;
//        Printf("total=%d\n", total);
        
        axml_node node;
    } while (!FEof());

} file;

string AxmlStringById(int &index) {
    string ret = "";
    if (index >= 0 && index < file.strings.string_count) {
        return file.strings.string_offsets[index].astr.data;
    } else {
        SPrintf(ret, "NULL Out off strings[%d] range %d", file.strings.string_count, index);
        return ret;
    }
}