/*
 * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * author: Jerome Glisse
 */
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "rdb.h"

int main(int argc, char *argv[])
{
    struct rdb rdb, rdb2;
    FILE *file;
    struct rdb_value *value, *value2, *value2t, *valuet;
    struct rdb_field *field, *field2, *field2t, *fieldt;
    struct rdb_it *it, *it2, *it2t, *itt;
    struct rdb_reg *reg, *reg2, *reg2t, *regt;
    struct rdb_range *range, *range2, *range2t, *ranget;
    unsigned add, add2, add3;

    if (argc != 3) {
        printf("usage %s rdb1 rdb2\n", argv[0]);
        return -1;
    }

    file = fopen(argv[1], "r");
    if (file == NULL) {
        fprintf(stderr, "failed reading %s\n", argv[1]);
        return -1;
    }
    rdb_init(&rdb);
    if (rdb_read(&rdb, file)) {
        fprintf(stderr, "failed reading %s\n", argv[1]);
        return -1;
    }

    file = fopen(argv[2], "r");
    if (file == NULL) {
        fprintf(stderr, "failed reading %s\n", argv[2]);
        return -1;
    }
    rdb_init(&rdb2);
    if (rdb_read(&rdb2, file)) {
        fprintf(stderr, "failed reading %s\n", argv[2]);
        return -1;
    }

    LIST_FOR_EACH_ENTRY_SAFE (it2, it2t, &rdb2.its, list) {
        add = 1;
        LIST_FOR_EACH_ENTRY_SAFE (it, itt, &rdb.its, list) {
            if (it2->it == it->it) {
                add = 0;
                if (strcmp(it2->name, it->name)) {
                    fprintf(stderr, "it %d name missmatch %s vs %s\n",
                            it->it, it->name, it2->name);
                }
            }
        }
        if (add) {
            list_del(&it2->list);
            list_add_tail(&it2->list, &rdb.its);
        }
    }

    LIST_FOR_EACH_ENTRY_SAFE (range2, range2t, &rdb2.ranges, list) {
        add = 1;
        LIST_FOR_EACH_ENTRY_SAFE (range, ranget, &rdb.ranges, list) {
            if (range->soffset == range2->soffset && range->eoffset == range2->eoffset) {
                add = 0;
                if (strcmp(range2->name, range->name)) {
                    fprintf(stderr, "range [0x%08x 0x%08x] name missmatch %s vs %s\n",
                            range->soffset, range->eoffset, range->name, range2->name);
                }
            } else if (range->soffset < range2->eoffset && range->eoffset >= range2->soffset) {
                    add = 0;
                    fprintf(stderr, "range [0x%08x 0x%08x] collide with [0x%08x 0x%08x]\n",
                            range->soffset, range->eoffset, range2->soffset, range2->eoffset);
            }
        }
        if (add) {
            list_del(&range2->list);
            list_add_tail(&range2->list, &rdb.ranges);
        }
    }

    LIST_FOR_EACH_ENTRY_SAFE (reg2, reg2t, &rdb2.regs, list) {
        add = 1;
        LIST_FOR_EACH_ENTRY_SAFE (reg, regt, &rdb.regs, list) {
            if (reg->offset == reg2->offset && reg->domain == reg2->domain) {
                add = 0;
                if (strcmp(reg2->name, reg->name)) {
                    fprintf(stderr, "reg [0x%08x 0x%08x] name missmatch %s vs %s\n",
                            reg->domain, reg->offset, reg->name, reg2->name);
                }
                LIST_FOR_EACH_ENTRY_SAFE (field2, field2t, &reg2->fields, list) {
                    add2 = 1;
                    LIST_FOR_EACH_ENTRY_SAFE (field, fieldt, &reg->fields, list) {
                        if (field->mask == field2->mask && field->shift == field2->shift) {
                            add2 = 0;
                            if (strcmp(field2->name, field->name)) {
                                fprintf(stderr, "reg %s field %d 0x%08x name missmatch %s vs %s\n",
                                        reg->name, field->shift, field->mask, field->name, field2->name);
                            }
                            LIST_FOR_EACH_ENTRY_SAFE (value2, value2t, &field2->values, list) {
                                add3 = 1;
                                LIST_FOR_EACH_ENTRY_SAFE (value, valuet, &field->values, list) {
                                    if (value->value == value2->value) {
                                        add3 = 0;
                                        if (strcmp(value2->name, value->name)) {
                                            fprintf(stderr, "reg %s field %s enum name missmatch %s vs %s\n",
                                                    reg->name, field->name, value->name, value2->name);
                                        }
                                    }
                                }
                                if (add3) {
                                    list_del(&value2->list);
                                    list_add_tail(&value2->list, &field->values);
                                }
                            }
                        } else if ((field->mask << field->shift) & (field2->mask << field2->shift)) {
                            add2 = 0;
                            fprintf(stderr, "reg %s field %d 0x%08x collide with %d 0x%08x\n",
                                    reg->name, field->shift, field->mask, field2->shift, field2->mask);
                        }
                    }
                    if (add2) {
                        list_del(&field2->list);
                        list_add_tail(&field2->list, &reg->fields);
                    }
                }
            }
        }
        if (add) {
            list_del(&reg2->list);
            list_add_tail(&reg2->list, &rdb.regs);
        }
    }

    rdb_write(stdout, &rdb);
}