Exemple #1
0
bool code_write(code_t *code, const char *filename, const char *lnofile) {
    prog_header_t  code_header;
    fs_file_t     *fp = NULL;

    code_create_header(code, &code_header, filename, lnofile);

    if (lnofile) {
        uint32_t version = 1;

        fp = fs_file_open(lnofile, "wb");
        if (!fp)
            return false;

        util_endianswap(&version,         1,                          sizeof(version));
        util_endianswap(code->linenums,   vec_size(code->linenums),   sizeof(code->linenums[0]));
        util_endianswap(code->columnnums, vec_size(code->columnnums), sizeof(code->columnnums[0]));

        if (fs_file_write("LNOF",                          4,                                      1,                          fp) != 1 ||
            fs_file_write(&version,                        sizeof(version),                        1,                          fp) != 1 ||
            fs_file_write(&code_header.defs.length,        sizeof(code_header.defs.length),        1,                          fp) != 1 ||
            fs_file_write(&code_header.globals.length,     sizeof(code_header.globals.length),     1,                          fp) != 1 ||
            fs_file_write(&code_header.fields.length,      sizeof(code_header.fields.length),      1,                          fp) != 1 ||
            fs_file_write(&code_header.statements.length,  sizeof(code_header.statements.length),  1,                          fp) != 1 ||
            fs_file_write(code->linenums,                  sizeof(code->linenums[0]),              vec_size(code->linenums),   fp) != vec_size(code->linenums) ||
            fs_file_write(code->columnnums,                sizeof(code->columnnums[0]),            vec_size(code->columnnums), fp) != vec_size(code->columnnums))
        {
            con_err("failed to write lno file\n");
        }

        fs_file_close(fp);
        fp = NULL;
    }

    fp = fs_file_open(filename, "wb");
    if (!fp)
        return false;

    if (1                          != fs_file_write(&code_header,     sizeof(prog_header_t)           , 1                         , fp) ||
        vec_size(code->statements) != fs_file_write(code->statements, sizeof(prog_section_statement_t), vec_size(code->statements), fp) ||
        vec_size(code->defs)       != fs_file_write(code->defs,       sizeof(prog_section_def_t)      , vec_size(code->defs)      , fp) ||
        vec_size(code->fields)     != fs_file_write(code->fields,     sizeof(prog_section_field_t)    , vec_size(code->fields)    , fp) ||
        vec_size(code->functions)  != fs_file_write(code->functions,  sizeof(prog_section_function_t) , vec_size(code->functions) , fp) ||
        vec_size(code->globals)    != fs_file_write(code->globals,    sizeof(int32_t)                 , vec_size(code->globals)   , fp) ||
        vec_size(code->chars)      != fs_file_write(code->chars,      1                               , vec_size(code->chars)     , fp))
    {
        fs_file_close(fp);
        return false;
    }

    fs_file_close(fp);
    code_stats(filename, lnofile, code, &code_header);
    return true;
}
Exemple #2
0
bool code_write(code_t *code, const char *filename, const char *lnofile) {
    prog_header_t code_header;
    FILE *fp = nullptr;

    code_create_header(code, &code_header, filename, lnofile);

    if (lnofile) {
        uint32_t version = 1;

        fp = fopen(lnofile, "wb");
        if (!fp)
            return false;

        util_endianswap(&version,             1,                       sizeof(version));
        util_endianswap(&code->linenums[0],   code->linenums.size(),   sizeof(code->linenums[0]));
        util_endianswap(&code->columnnums[0], code->columnnums.size(), sizeof(code->columnnums[0]));

        if (fwrite("LNOF",                          4,                                      1,                          fp) != 1 ||
            fwrite(&version,                        sizeof(version),                        1,                          fp) != 1 ||
            fwrite(&code_header.defs.length,        sizeof(code_header.defs.length),        1,                          fp) != 1 ||
            fwrite(&code_header.globals.length,     sizeof(code_header.globals.length),     1,                          fp) != 1 ||
            fwrite(&code_header.fields.length,      sizeof(code_header.fields.length),      1,                          fp) != 1 ||
            fwrite(&code_header.statements.length,  sizeof(code_header.statements.length),  1,                          fp) != 1 ||
            fwrite(&code->linenums[0],              sizeof(code->linenums[0]),              code->linenums.size(),      fp) != code->linenums.size() ||
            fwrite(&code->columnnums[0],            sizeof(code->columnnums[0]),            code->columnnums.size(),    fp) != code->columnnums.size())
        {
            con_err("failed to write lno file\n");
        }

        fclose(fp);
        fp = nullptr;
    }

    fp = fopen(filename, "wb");
    if (!fp)
        return false;

    if (1                       != fwrite(&code_header,         sizeof(prog_header_t)           , 1                      , fp) ||
        code->statements.size() != fwrite(&code->statements[0], sizeof(prog_section_statement_t), code->statements.size(), fp) ||
        code->defs.size()       != fwrite(&code->defs[0],       sizeof(prog_section_def_t)      , code->defs.size()      , fp) ||
        code->fields.size()     != fwrite(&code->fields[0],     sizeof(prog_section_field_t)    , code->fields.size()    , fp) ||
        code->functions.size()  != fwrite(&code->functions[0],  sizeof(prog_section_function_t) , code->functions.size() , fp) ||
        code->globals.size()    != fwrite(&code->globals[0],    sizeof(int32_t)                 , code->globals.size()   , fp) ||
        code->chars.size()      != fwrite(&code->chars[0],      1                               , code->chars.size()     , fp))
    {
        fclose(fp);
        return false;
    }

    fclose(fp);
    code_stats(filename, lnofile, code, &code_header);
    return true;
}