Beispiel #1
0
static int palette_load_core(FILE *f, const char *file_name,
                             palette_t *tmp_palette,
                             palette_t *palette_return)
{
    char buf[1024];

    unsigned int line_num = 0;
    unsigned int entry_num = 0;

    while (1) {
        int i;
        BYTE values[4];
        const char *p1;

        int line_len = util_get_line(buf, 1024, f);

        if (line_len < 0) {
            break;
        }

        line_num++;

        if (*buf == '#') {
            continue;
        }

        p1 = next_nonspace(buf);

        if (*p1 == '\0') { /* empty line */
            continue;
        }

        for (i = 0; i < 4; i++) {
            long result;
            const char *p2;

            if (util_string_to_long(p1, &p2, 16, &result) < 0) {
                log_error(palette_log, "%s, %d: number expected.",
                          file_name, line_num);
                return -1;
            }
            if (result < 0
                || (i == 3 && result > 0xf)
                || result > 0xff
                || result < 0) {
                log_error(palette_log, "%s, %d: invalid value %lx.",
                          file_name, line_num, result);
                return -1;
            }
            values[i] = (BYTE)result;
            p1 = p2;
        }

        p1 = next_nonspace(p1);
        if (*p1 != '\0') {
            log_error(palette_log,
                      "%s, %d: garbage at end of line.",
                      file_name, line_num);
            return -1;
        }
        if (entry_num >= palette_return->num_entries) {
            log_error(palette_log,
                      "%s: too many entries, %d expected.", file_name,
                      palette_return->num_entries);
            return -1;
        }
        if (palette_set_entry(tmp_palette, entry_num,
                              values[0], values[1], values[2], values[3]) < 0) {
            log_error(palette_log, "Failed to set palette entry.");
            return -1;
        }
        entry_num++;
    }

    if (line_num == 0) {
        log_error(palette_log, "Could not read from palette file.");
        return -1;
    }

    if (entry_num < palette_return->num_entries) {
        log_error(palette_log, "%s: too few entries, %d found, %d expected.",
                  file_name, entry_num, palette_return->num_entries);
        return -1;
    }

    if (palette_copy(palette_return, tmp_palette) < 0) {
        log_error(palette_log, "Failed to copy palette.");
        return -1;
    }

    return 0;
}
Beispiel #2
0
int load_keymap_file(const char *fname)
{
    FILE *fp;
    int num = 0;
    char *complete_path;

    if (fname == NULL)
        return -1;

    fp = sysfile_open(fname, &complete_path, "r");

    if (fp == NULL) {
        char *tmp = util_concat(fname, ".vkm", NULL);

        fp = sysfile_open(tmp, &complete_path, "r");
        lib_free(tmp);
    }

    if (fp == NULL)
        return -1;
    else
        log_message(LOG_DEFAULT, "Loading keymap `%s'.", complete_path);

    lib_free(complete_path);

    while (!feof(fp))
    {
        char buffer[81];
        if (util_get_line(buffer, 80, fp))
            switch (buffer[0])
            {
            case 0:
            case '/':
                break;
            case '#':
            case 'S':
            case 'U':
                // table entry handling
                {
                    // FIXME: ERROR LOGGING MISSING
                    char *p;
                    char *dummy;
                    unsigned long code1, code2;
                    int row, col, shift;

                    if (keyconvmap.symbolic == 1)
                    {
                        p = strtok(buffer+1, " \t,");
                        if (!p)
                            break;
                        code1 = strtoul(p, &dummy, 10);
                        if (code1>0xff)
                            break;
                        p = strtok(NULL, " \t:");
                        if (!p)
                            break;
                        code2 = strtoul(p, &dummy, 10);
                        if (code2>0xff)
                            break;
                    }
                    else
                    {
                        p = strtok(buffer+1, " \t:");
                        if (!p)
                            break;
                        code1 = strtoul(p, &dummy, 10);
                        if (code1>0xff)
                            break;
                        code2 = 0;
                    }
                    p = strtok(NULL, " \t,");
                    if (!p)
                        break;
                    row = atoi(p);
                    p = strtok(NULL, " \t,");
                    if (!p)
                        break;
                    col = atoi(p);

                    p = strtok(NULL, " \t");
                    if (!(p || row < 0))
                        break;
                    if (p)
                        shift = atoi(p);

                    {
                        switch (buffer[0])
                        {
                        case '#':
                            keyconvmap.map[0][num].code   = code1 | code2<<8;
                            keyconvmap.map[0][num].row    = row;
                            keyconvmap.map[0][num].column = col;
                            keyconvmap.map[0][num].vshift = shift;
                            keyconvmap.map[1][num].code   = code1 | code2<<8;
                            keyconvmap.map[1][num].row    = row;
                            keyconvmap.map[1][num].column = col;
                            keyconvmap.map[1][num].vshift = shift;
                            num++;
                            break;
                        case 'S':
                            keyconvmap.map[1][num].code   = code1 | code2<<8;
                            keyconvmap.map[1][num].row    = row;
                            keyconvmap.map[1][num].column = col;
                            keyconvmap.map[1][num].vshift = shift;
                            num++;
                            break;
                        case 'U':
                            keyconvmap.map[0][num].code   = code1 | code2<<8;
                            keyconvmap.map[0][num].row    = row;
                            keyconvmap.map[0][num].column = col;
                            keyconvmap.map[0][num].vshift = shift;
                            num++;
                            break;
                        }
                        // log_debug("setting %i (%i) to r%i c%i = %i s%i", num, s, row, col, code1|code2<<8, shift);
                    }
                }
            case '!': // keyword handling
                {
                    char *p;
                    int row, col;

                    p = strtok(buffer+1, " \t:");
                    if (!p)
                        break;

                    if (!strcmp(p, "LSHIFT"))
                    {
                        p = strtok(NULL, " \t,");
                        if (!p)
                            break;
                        row = atoi(p);
                        p = strtok(NULL, " \t,");
                        if (!p)
                            break;
                        col = atoi(p);

                        keyconvmap.lshift_row = row;
                        keyconvmap.lshift_col = col;
                    }
                    if (!strcmp(p, "RSHIFT"))
                    {
                        p = strtok(NULL, " \t,");
                        if (!p)
                            break;
                        row = atoi(p);
                        p = strtok(NULL, " \t,");
                        if (!p)
                            break;
                        col = atoi(p);

                        keyconvmap.rshift_row = row;
                        keyconvmap.rshift_col = col;
                    }
                    if (!strcmp(p, "KSCODE"))
                        keyconvmap.symbolic = 0;  // FALSE
                    if (!strcmp(p, "KSYM"))
                        keyconvmap.symbolic = 1;  // TRUE
                }

                break;
            default:
                break;
            }
        if (num==0x100)
        {
            log_message(LOG_DEFAULT, "parse.c: Warning: keyboard file contains more than 255 entries.");
            break;
        }
    }
    keyconvmap.entries = num;

    fclose(fp);

    return 0;
}