par.c

进行Palm开发时

    if (PRC_IS_RESOURCE(prc)) {
        return extract_resources(prc, argv);
    } else if (PRC_IS_STREAM(prc)) {
        return extract_stream(prc, argv);
    } else {
        int n = extract_info(prc, argv);

        if (n == -1)
            return n;

        return extract_records(prc, &argv[n]);
    }
}

static int
delete_records(prc_t* prc, char** argv)
{
    int i;
    prc_uint16_t index;
    prc_record_t* record;
    unsigned      nRecords = prcgetnrecords(prc);
    prc_byte_t*   record_deletes;
    int           rv = 0;

    record_deletes = (prc_byte_t*)calloc(nRecords, sizeof(prc_byte_t));

    for (i = 0; argv[i] != NULL; i++) {
        char* a = argv[i];
        
        index = atoi(a);

        record_deletes[index] = 1;
    }

    index = nRecords;
    do {
        index--;

        if (!record_deletes[index])
            continue;
        
        record = prcgetrecord(prc, index);

        if (!record) {
            fprintf(stderr, "index %d not found\n", index);
            rv = -1;
            break;
        }

        /* remove the record from the prc, the destroy */
        record = prcremoverecord(prc, record);
        if (!record) {
            fprintf(stderr, "problem deleting record, inbdex=%d\n", index);
            rv = -1;
            break;
        } else {
            prcdestroyrecord(record);
        }
    } while (index > 0);

    free(record_deletes);

    return rv;
}

static int
delete_resources(prc_t* prc, char** argv)
{
    int i;
    prc_resource_t* resource;

    /* type id */
    for (i = 0; argv[i] != NULL;) {
        prc_uint16_t  id;
        prc_type_t type;
        char* type_s;
        char* id_s;

        type_s = argv[i++];
        id_s = argv[i++];
        
        type = prcstrtotype(type_s);
        id = prcstrtoid(id_s);

        resource = prcgetresource(prc, type, id);
        if (!resource) {
            fprintf(stderr, "resource, type='%s', id=0x%x not found\n",
                    type_s, id);
            return -1;
        }

        /* remove the record from the prc, the destroy */
        resource = prcremoveresource(prc, resource);
        if (!resource) {
            fprintf(stderr, "problem deleting resource, type='%s', id=0x%x\n",
                    type_s, id);
            return -1;
        } else {
            prcdestroyresource(resource);
        }
    }
    
    return 0;
}

static int
prcdelete(prc_t* prc, char** argv)
{
    if (PRC_IS_RESOURCE(prc)) {
        return delete_resources(prc, argv);
    } else {
        unsigned dAppInfo;
        unsigned dSortInfo;
        unsigned n = parse_info_args(argv, 0, &dAppInfo, 0, &dSortInfo);

        if (dAppInfo)
            prcsetappinfo(prc, NULL, 0);

        if (dSortInfo)
            prcsetsortinfo(prc, NULL, 0);

        return delete_records(prc, &argv[n]);
    }
}

const char*
prcbasename(const char* s)
{
    char* p = strrchr(s, '/');
    if (p != NULL) {
        return (const char*)(p + 1);
    } else {
        return s;
    }
}

const char*
prcsuffixname(const char* s)
{
    char* p = strrchr(s, '.');
    if (p != NULL) {
        return (const char*)(p + 1);
    } else {
        return s;
    }
}

const unsigned
prcfileisprc(const char* s)
{
    /* this is only a guess, need to open file */
    const char* suf = prcsuffixname(s);
    if (strcmp(suf, "prc") == 0 || strcmp(suf, "PRC") == 0 ||
        strcmp(suf, "pdb") == 0 || strcmp(suf, "PDB") == 0)
        return 1;
    else
        return 0;
}

static unsigned
parse_record_args(char** argv,
                  unsigned* category, unsigned* flags, prc_uint32_t* uid,
                  unsigned* isPrc_r)
{
    unsigned n;
    unsigned options = 0;
    char* f;

    *isPrc_r = 0;

    for (n = 0; (f = argv[n]) != NULL && f[0] == '-';) {
        if (strcmp(f, "-c") == 0) {
            *category = atoi(argv[n+1]);
            n += 2;
            options++;
        } else if (strcmp(f, "-u") == 0) {
            *uid = atoi(argv[n+1]);
            n += 2;
            options++;
        } else if (strcmp(f, "-a") == 0) {
            *flags = prcstrprecordattr(argv[n+1]);
            n += 2;
            options++;
        } else if (strcmp(f, "-p") == 0) {
            *isPrc_r = 1;
            return n;
        } else {
            break;
        }
    }

    if (options == 0) {
        unsigned flag;
        prc_uint32_t id;
        unsigned index;
        unsigned foo;

        if (prcfileisprc(argv[0])) { /* I think it's a prc */
            *isPrc_r = 1;
            return n;
        }

        foo = sscanf(f, "%d.%x.%ld", &index, &flag, &id);

        if (foo == 3) {
            *category = PRC_REC_FLAGS_GET_CATEGORY(flag);
            *flags = flag & 0xF0;
            *uid = id;
        }
    }
    
    return n;
}

static int
append_info(prc_t* prc, char** argv)
{
    int n = 0;
    char* appInfo = NULL;
    char* sortInfo = NULL;
    prc_byte_t*  data;
	prc_uint32_t datalen;

    n += parse_info_args(argv, &appInfo, 0, &sortInfo, 0);

    if (appInfo != NULL) { /* set app info from file */
        data = file_to_data(appInfo, &datalen);
        prcsetappinfo(prc, data, datalen);
        free(data);
    }

    if (sortInfo != NULL) { /* set sort info from file */
        data = file_to_data(sortInfo, &datalen);
        prcsetsortinfo(prc, data, datalen);
        free(data);
    }

    return n;
}

static int
append_one_record(prc_t* prc,
                  prc_uint32_t id,
                  prc_byte_t   flags,
                  prc_byte_t*  data,
                  prc_uint32_t datalen)
{
    prc_record_t* rec = prcnewrecord();

    prcrecordset(rec, data, datalen);

    rec->flags = flags;
    rec->id = id;
    
    rec = prcappendrecord(prc, rec);
    if (rec == NULL) {
        fprintf(stderr, "could not append record\n");
        return -1;
    }
    return 0;
}

static int
append_record_mappee(prc_record_t* m_record, void* arg)
{
    prc_t* prc = (prc_t*)arg;
    
    return append_one_record(prc,
                             m_record->id,
                             m_record->flags,
                             m_record->data,
                             m_record->datalen);
}

static int
append_records(prc_t* prc, char** argv)
{
    int n;

    for (n = 0; argv[n] != NULL; n++) {
        prc_byte_t*  data;
        prc_uint32_t datalen;
        unsigned     category = 0;
        unsigned     flags = 0;
        prc_uint32_t uid = 0;
        unsigned     isPrc;
        int x;

        n += parse_record_args(&argv[n], &category, &flags, &uid, &isPrc);

        if (isPrc) {
            prc_t* a_prc = prcopen(argv[n], PRC_OPEN_READ);

            if (a_prc == NULL) {
                fprintf(stderr, "could not open: %s\n", argv[n]);
                return -1;
            }

            if (PRC_IS_RESOURCE(a_prc)) {
                fprintf(stderr, "%s is a resource file\n", argv[n]);
                prcclose(a_prc);
                return -1;
            }

            x = prcmaprecords(a_prc, append_record_mappee, prc);

            prcclose(a_prc);

            if (x == -1)
                return -1;
        } else {

            prc_byte_t flags_b;

            data = file_to_data(argv[n], &datalen);

            if (!data)
                return -1;

            flags_b = (prc_byte_t)PRC_REC_FLAGS_MAKE(flags, category);

            x = append_one_record(prc,
                                  uid,
                                  flags_b,
                                  data,
                                  datalen);

            free(data);

            if (x != 0)
                return -1;
        }
    }

    return n;
}

static unsigned
filename_to_type_id(const char* s, prc_uint32_t* type_r, prc_uint16_t* id_r)
{
    if (!s || strlen(s) < 8)
        return 0;
    if (!(isxdigit((unsigned)s[4]) &&
          isxdigit((unsigned)s[5]) &&
          isxdigit((unsigned)s[6]) &&
          isxdigit((unsigned)s[7])))
        return 0;
    *type_r = prcstrtotype((char*)s);
    *id_r = (prc_uint16_t)strtol((char*)&s[4], NULL, 16);
    return 1;
}

static int
parse_resource_args(char** argv,
                    prc_uint32_t* type_r,
                    prc_uint16_t* id_r,
                    char** filename_r,
                    unsigned* isPrc_r)
{
    int n = 1;
    prc_uint32_t type;
    prc_uint16_t id;
    char* filename;
    unsigned isPrc = 0;

    /* [-T type id ] filename */
    if (strcmp("-T", argv[0]) == 0) {
        type = prcstrtotype(argv[n++]);
        id = prcstrtoid(argv[n++]);
        filename = argv[n++];
    } else if (strcmp("-p", argv[0]) == 0) {
        filename = argv[n++];
        isPrc = 1;
    } else { /* try to decode type & id from filename */
        if (prcfileisprc(argv[0])) { /* I think it's a prc */
            isPrc = 1;
        } else {
            /* TTTTiiii[.suffix] */
            const char* base = prcbasename(argv[0]);

            if (!filename_to_type_id(base, &type, &id)) {
                fprintf(stderr,
                        "Unable to determine the resource type and id from "
                        "filename: %s (expected form is TTTTxxxx[.suffix])\n",
                        argv[0]);
                return -1;
            }
        }
        filename = argv[0];
    }

    *type_r = type;
    *id_r = id;
    *filename_r = filename;
    *isPrc_r = isPrc;

    return n;
}

static int
append_one_resource(prc_t* prc,
                           prc_uint32_t type,
                           prc_uint16_t id,
                           prc_byte_t*  data,
                           prc_uint32_t datalen)
{
    prc_resource_t* resource;
    unsigned        append = 0;

    if ((resource = prcgetresource(prc, type, id)) == NULL) {
        resource = prcnewresource();
        append++;
    } else {
        fprintf(stderr,
                "replacing resource %s 0x%04x\n",
                prctypetostr(NULL, type), id);
    }
    
    prcresourceset(resource, type, id, data, datalen);
    
    if (append)
        resource = prcappendresource(prc, resource);
    
    if (resource == NULL) {
        fprintf(stderr,
                "could not append resource %s 0x%04x\n",
                prctypetostr(NULL, type), id);
        return -1;
    }

    return 0;
}
 
static int
append_mappee(prc_resource_t* m_resource, void* arg)
{
    prc_t* prc = (prc_t*)arg;
    
    return append_one_resource(prc,
                               m_resource->type,
                               m_resource->id,
                               m_resource->data,
                               m_resource->datalen);
}

static int
append_resources(prc_t* prc, char** argv)
{
    int n;

    for (n = 0; argv[n] != NULL;) {
        prc_byte_t*  data;
        prc_uint32_t datalen;
        prc_uint32_t type;
        prc_uint16_t id;
        char* filename;
        int x;
        unsigned isPrc;

        x = parse_resource_args(&argv[n], &type, &id, &filename, &isPrc);

        if (x == -1)
            return -1;

        n += x;

        if (isPrc) {
            prc_t* m_prc = prcopen(filename, PRC_OPEN_READ);

            if (m_prc == NULL) {
                fprintf(stderr, "could not open: %s\n", filename);
                return -1;
            }

            if (!PRC_IS_RESOURCE(m_prc)) {
                fprintf(stderr, "%s is not a resource file\n", filename);
                prcclose(m_prc);
                return -1;
            }

            x = prcmapresources(m_prc, append_mappee, prc);

            prcclose(m_prc);

            if (x == -1)
                return -1;
        } else {
            data = file_to_data(filename, &datalen);

            if (!data)
                return -1;

            x = append_one_resource(prc,
                                    type,
                                    id,
                                    data,
                                    datalen);