Example #1
0
//-----------------------------------------------------------------------------
// Memory_Alloc (int size)
// Allocate memory using malloc(), abort if unavailable
//-----------------------------------------------------------------------------
void    *Memory_Alloc (int size)
{
 byte   *p;

 if ((p = malloc (size)) == NULL)
    {
    meka_errno = MEKA_ERR_MEMORY;
    Quit_Msg (meka_strerror());
    }
 return (p);
}
Example #2
0
void	Blitters_Init()
{
    ConsolePrint(Msg_Get(MSG_Blitters_Loading));

    Blitters.list = NULL;
    Blitters.current = NULL;

    // Open and read file
    t_tfile * tf;
    if ((tf = tfile_read (Blitters.filename)) == NULL)
        Quit_Msg("%s", meka_strerror());
    ConsolePrint("\n");

    // Parse each line
    int line_cnt = 0;
    for (t_list* lines = tf->data_lines; lines; lines = lines->next)
    {
        const char* line = (char*)lines->elem;
        line_cnt += 1;

		int i, j;
        char s1 [256], s2 [256];
        for (i = 0, j = 0; line [i] != 0 && line [i] != ';'; i ++)
            if ((line [0] == '[') || (line [i] != ' ' && line [i] != '\t'))
                s2 [j ++] = line [i];
        s2 [j] = 0;
        if (StrIsNull (s2))
            continue;

        strcpy(s1, s2);
        StrLower(s1);

        switch (Blitters_Parse_Line (s1, s2))
        {
        case MEKA_ERR_UNKNOWN:          tfile_free(tf); Quit_Msg(Msg_Get(MSG_Blitters_Error_Unrecognized), line_cnt);
        case MEKA_ERR_MISSING:          tfile_free(tf); Quit_Msg(Msg_Get(MSG_Blitters_Error_Missing), line_cnt);
        case MEKA_ERR_VALUE_INCORRECT:  tfile_free(tf); Quit_Msg(Msg_Get(MSG_Blitters_Error_Incorrect_Value), line_cnt);
        }
    }

    // Free file data
    tfile_free(tf);

    // Requires at least 1 blitter
    if (Blitters.count == 0)
        Quit_Msg("%s", Msg_Get(MSG_Blitters_Error_Not_Enough));

    // Current blitter
    if (Blitters.blitter_configuration_name != NULL)
        Blitters.current = Blitters_FindBlitterByName(Blitters.blitter_configuration_name);
    if (Blitters.current == NULL)
        Blitters.current = (t_blitter*)Blitters.list->elem; // first
}
Example #3
0
//-----------------------------------------------------------------------------
// DB_Load (const char *filename)
// Initialize and load given Meka DB file
//-----------------------------------------------------------------------------
void            DB_Load (const char *filename)
{
    t_tfile *   tf;
    t_list *    lines;
    char *      line;
    int         line_cnt;

    ConsolePrint (Msg_Get (MSG_DB_Loading));

    // Open and read file
    tf = tfile_read (filename);
    if (tf == NULL)
    {
        ConsolePrintf ("%s\n", meka_strerror());
        return;
    }

    // Ok
    ConsolePrint ("\n");

    // Parse each line
    line_cnt = 0;
    for (lines = tf->data_lines; lines; lines = lines->next)
    {
        line_cnt += 1;
        line = lines->elem;

        // Strip comments
        // FIXME
        // Trim spaces?
        // FIXME
        // Skip empty lines
        //if (line[0] == EOSTR)
        //    continue;

        if (DB_Load_Line (line) == 0)
        {
            tfile_free (tf); 
            Quit_Msg (Msg_Get (MSG_DB_SyntaxError), line_cnt);
        }
    }

    // Free file data
    tfile_free(tf);

    // FIXME - Uncomment for counting progress of DB transition
    //ConsolePrintf ("ENTRIES NEW = %d, OLD = %d\n", DB.entries_counter_format_new, DB.entries_counter_format_old);
    //Quit();
}
Example #4
0
//-----------------------------------------------------------------------------
// VLFN_DataBase_Load (void)
// Load VLFN database from MEKA.FDB file.
//-----------------------------------------------------------------------------
void            VLFN_DataBase_Load (void)
{
    t_tfile *   tf;
    t_list *    lines;
    char *      line;
    int         line_cnt;

    ConsolePrint (Msg_Get (MSG_FDB_Loading));

    // Open and read file
    tf = tfile_read (VLFN_DataBase.filename);
    if (tf == NULL)
    {
        ConsolePrintf ("%s\n", meka_strerror());
        return;
    }

    // Ok
    ConsolePrint ("\n");

    // Parse each line
    line_cnt = 0;
    for (lines = tf->data_lines; lines; lines = lines->next)
    {
        char *  w;

        line_cnt += 1;
        line = lines->elem;

        w = parse_getword(NULL, 0, &line, "/", ';', 0);
        if (w == NULL)
            continue;
        else
        {
            char            buf[1024];
            char *          file_name;
            u32             crc_crc32;
            t_meka_crc      crc_mekacrc;

            // Save allocated filename
            file_name = w;

            // Get CRCs
            crc_crc32 = 0;
            crc_mekacrc.v[0] = crc_mekacrc.v[1] = 0;
            while ((w = parse_getword(buf, 1024, &line, "/", ';', 0)) != NULL)
            {
                if (!strncmp(w, "MEKACRC:", 8))
                {
                    if (sscanf(w + 8, "%08X%08X", &crc_mekacrc.v[0], &crc_mekacrc.v[1]) != 2)
                        continue; // Syntax error
                }
                else if (!strncmp(w, "CRC32:", 6))
                {
                    if (sscanf(w + 6, "%08x", &crc_crc32) != 1)
                        continue; // Syntax error
                }
            }

            // Requires at least MekaCRC
            // (to be changed by CRC32 when MekaCRC is dropped)
            if (crc_mekacrc.v[0] == 0 && crc_mekacrc.v[1] == 0)
                continue;

            {
                // Find DB entry
                t_db_entry *db_entry = DB_Entry_Find (crc_crc32, &crc_mekacrc);
                if (db_entry)
                {
                    // Create VLFN entry
                    t_vlfn_entry *  entry;
                    entry = VLFN_Entry_New (file_name, db_entry);
                    list_add (&VLFN_DataBase.entries, entry);
                }
            }
        }
    }

    // Free file data
    tfile_free (tf);
}
Example #5
0
void            Load_Inputs_Src_List (void)
{
    int             i;
    char            w[256];
    t_input_src *   input_src = NULL;

    t_tfile *       tf;
    t_list *        lines;
    int             line_cnt;

    // Open and read file
    ConsolePrint (Msg_Get (MSG_Inputs_Src_Loading));
    tf = tfile_read (Inputs.FileName);
    if (tf == NULL)
        Quit_Msg (meka_strerror());
    ConsolePrint ("\n");

    // Parse each line
    line_cnt = 0;
    for (lines = tf->data_lines; lines; lines = lines->next)
    {
        char *line;

        line_cnt += 1;
        line = lines->elem;

        if (StrNull(line))
            continue;

        if (line[0] == '[' && line[strlen(line) - 1] == ']')
        {
            input_src = Inputs_Sources_Add (StrNDup (line + 1, strlen(line) - 2));
            // ConsolePrintf ("new source --> %s <--\n", CurSrc->Name);
            continue;
        }

        strlwr(line);
        if (!parse_getword(w, sizeof(w), &line, "=", ';', PARSE_FLAGS_NONE))
            continue;

        for (i = 0; Inputs_Src_List_KeyWords[i]; i++)
            if (strcmp(w, Inputs_Src_List_KeyWords[i]) == 0)
            {
                // FIXME: this is ugly
                if (input_src == NULL && strcmp (w, "joy_driver") != 0
                    && strcmp (w, "mouse_speed_x") != 0
                    && strcmp (w, "mouse_speed_y") != 0
                    && strcmp (w, "cabinet_mode")  != 0)
                {
                    tfile_free(tf);
                    Quit_Msg (Msg_Get (MSG_Inputs_Src_Missing), line_cnt);
                }

                parse_skip_spaces(&line);
                if (!parse_getword(w, sizeof(w), &line, "", ';', PARSE_FLAGS_NONE))
                {
                    tfile_free(tf);
                    Quit_Msg (Msg_Get (MSG_Inputs_Src_Equal), line_cnt);
                }

                switch (Load_Inputs_Src_Parse_Var(i, w, input_src))
                {
                case MEKA_ERR_SYNTAX:
                    tfile_free(tf);
                    Quit_Msg (Msg_Get (MSG_Inputs_Src_Syntax_Param), line_cnt);
                case MEKA_ERR_INCOHERENT :
                    tfile_free(tf);
                    Quit_Msg (Msg_Get (MSG_Inputs_Src_Inconsistency), line_cnt);
                    break;
                    // FIXME: EMPTY is not handled there
                }
                break;
            }
            if (!Inputs_Src_List_KeyWords [i])
            {
                tfile_free(tf);
                Quit_Msg (Msg_Get (MSG_Inputs_Src_Unrecognized), line_cnt, w);
            }
    }

    // Free file data
    tfile_free(tf);

    // Verify that we have enough inputs sources
    if (Inputs.Sources_Max == 0)
        Quit_Msg (Msg_Get (MSG_Inputs_Src_Not_Enough));
}
Example #6
0
// Load media/ROM from given filename.
// If user_verbose if false, avoid printing stuff to the message box
// Note: path to ROM filename must be set in 'g_env.Paths.MediaImageFile' before calling this
bool    Load_ROM(t_load_mode load_mode, bool user_verbose)
{
    // Set file global flag
    Loading_UserVerbose = user_verbose;

    switch (load_mode)
    {
    case LOAD_MODE_COMMANDLINE:
        if (user_verbose)
            ConsolePrint(Msg_Get(MSG_LoadROM_Loading));
        break;
    case LOAD_MODE_GUI:
        // FIXME: do not save Backed Memory in non-verbose mode
        // This mode is only used by the file browser. This way we avoid loading
        // and saving all battery backed memory when doing a "Load All".
        // Of course, this is a little hack but it's better this way.
        if (user_verbose)
            BMemory_Save();
        break;
    }

    if (Load_ROM_Main() != MEKA_ERR_OK)
    {
        switch (load_mode)
        {
        case LOAD_MODE_COMMANDLINE:
            Quit_Msg("%s\n\"%s\"\n", meka_strerror(), g_env.Paths.MediaImageFile);
            return false;
        case LOAD_MODE_GUI:
            Msg(MSGT_USER, Msg_Get(MSG_Error_Base), meka_strerror());
            return false;
        }
    }

    // If we are already in SF-7000 mode, do not reset (allows hot switching disks)
    const bool reset = (g_driver->id != DRV_SF7000);

    // Miscellaneous stuff (including reset)
    Load_ROM_Misc(reset);

    if (load_mode == LOAD_MODE_COMMANDLINE)
    {
        if (user_verbose)
            ConsolePrint("\n");
        if (opt.State_Load != -1)
        {
            opt.State_Current = opt.State_Load; // Note: we're not calling the function to avoid displaying the 'slot change' message
            opt.State_Load = -1;
            SaveState_Load();
        }
    }

    // Verbose
    if (user_verbose)
    {
        // Display success message
        char filename[FILENAME_LEN];
        StrPath_RemoveDirectory(filename, g_env.Paths.MediaImageFile);
        if (g_driver->id != DRV_SF7000)
            Msg(MSGT_USER, Msg_Get(MSG_LoadROM_Success), filename);
        else
            Msg(MSGT_USER, Msg_Get(MSG_LoadDisk_Success), filename);

        // Display data from DB
        if (DB.current_entry)
        {
            // Name
            Msg(MSGT_USER, "\"%s\"", DB_Entry_GetCurrentName (DB.current_entry));

            // Comment
            if (DB.current_entry->comments)
                Msg(MSGT_USER_LOG, Msg_Get(MSG_LoadROM_Comment), DB.current_entry->comments);

            // Show SMS-GG mode info
            if (DB.current_entry->flags & DB_FLAG_SMSGG_MODE)
            {
                if (DB.current_entry->comments)
                    // Append to comment message
                    Msg(MSGT_USER_LOG, "%s", Msg_Get(MSG_LoadROM_SMSGG_Mode_Comment));
                else // Print the comment marker before
                    Msg(MSGT_USER_LOG, Msg_Get(MSG_LoadROM_Comment), Msg_Get(MSG_LoadROM_SMSGG_Mode_Comment));
            }

            // Show BAD ROM warning
            if (DB.current_entry->flags & DB_FLAG_BAD)
            {
                Msg(MSGT_USER_LOG, "%s", Msg_Get(MSG_LoadROM_Warning));
                Msg(MSGT_USER_LOG, "%s", Msg_Get(MSG_LoadROM_Bad_Dump_Long));
                Msg(MSGT_STATUS_BAR, "%s", Msg_Get(MSG_LoadROM_Bad_Dump_Short));
            }

            // Show Product Number
            if (DB.current_entry->product_no && g_config.show_product_number)
                Msg(MSGT_USER_LOG, Msg_Get(MSG_LoadROM_Product_Num), DB.current_entry->product_no);
        }

        // Show SDSC Header
        if (user_verbose)
            SDSC_Read_and_Display();
    }

    // Automatically change input peripheral depending on MEKA.NAM entry
    // FIXME: we don't do it at all if !user_verbose, to save us from passing
    // the verbose flag all down to inputs peripherals changing functions.
    // Since the verbose flag is only cleared by the file browser "Load All"
    // functionality, it is ok to avoid changing inputs.
    if (user_verbose)
        Input_ROM_Change();

    return true;
}