summaryrefslogtreecommitdiffstatshomepage
path: root/src/emu/validity.h
blob: a845bac46102d993ae51919b7d0fcacc8e134ec1 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
// license:BSD-3-Clause
// copyright-holders:Aaron Giles
/***************************************************************************

    validity.h

    Validity checks

***************************************************************************/

#ifndef MAME_EMU_VALIDITY_H
#define MAME_EMU_VALIDITY_H

#pragma once

#include "drivenum.h"
#include "emuopts.h"


//**************************************************************************
//  TYPE DEFINITIONS
//**************************************************************************

// forward declarations
class machine_config;


// core validity checker class
class validity_checker : public osd_output
{
public:
	validity_checker(emu_options &options);
	~validity_checker();

	// getters
	int errors() const { return m_errors; }
	int warnings() const { return m_warnings; }
	bool validate_all() const { return m_validate_all; }

	// setter
	void set_verbose(bool verbose) { m_print_verbose = verbose; }
	void set_validate_all(bool all) { m_validate_all = all; }

	// operations
	void check_driver(const game_driver &driver);
	void check_shared_source(const game_driver &driver);
	bool check_all_matching(const char *string = "*");

	// helpers for devices
	void validate_tag(const char *tag);
	int region_length(const char *tag) { return m_region_map.find(tag)->second; }

	// generic registry of already-checked stuff
	bool already_checked(const char *string) { return !m_already_checked.insert(string).second; }

	// osd_output interface

protected:
	virtual void output_callback(osd_output_channel channel, const char *msg, va_list args) override;

private:
	// internal map types
	typedef std::unordered_map<std::string,const game_driver *> game_driver_map;
	typedef std::unordered_map<std::string,uintptr_t> int_map;

	// internal helpers
	const char *ioport_string_from_index(u32 index);
	int get_defstr_index(const char *string, bool suppress_error = false);

	// core helpers
	void validate_begin();
	void validate_end();
	void validate_one(const game_driver &driver);

	// internal sub-checks
	void validate_core();
	void validate_inlines();
	void validate_rgb();
	void validate_driver();
	void validate_roms();
	void validate_analog_input_field(ioport_field &field);
	void validate_dip_settings(ioport_field &field);
	void validate_condition(ioport_condition &condition, device_t &device, std::unordered_set<std::string> &port_map);
	void validate_inputs();
	void validate_devices();
	void validate_device_types();

	// output helpers
	void build_output_prefix(std::string &str);
	void output_via_delegate(osd_output_channel channel, const char *format, ...) ATTR_PRINTF(3,4);
	void output_indented_errors(std::string &text, const char *header);

	// random number generation
	s32 random_i32();
	u32 random_u32();
	s64 random_i64();
	u64 random_u64();

	// internal driver list
	driver_enumerator       m_drivlist;

	// blank options for use during validation
	emu_options				m_blank_options;

	// error tracking
	int                     m_errors;
	int                     m_warnings;
	bool                    m_print_verbose;
	std::string             m_error_text;
	std::string             m_warning_text;
	std::string             m_verbose_text;

	// maps for finding duplicates
	game_driver_map         m_names_map;
	game_driver_map         m_descriptions_map;
	game_driver_map         m_roms_map;
	int_map                 m_defstr_map;

	// current state
	const game_driver *     m_current_driver;
	const machine_config *  m_current_config;
	const device_t *        m_current_device;
	const char *            m_current_ioport;
	int_map                 m_region_map;
	std::unordered_set<std::string>   m_already_checked;
	bool                    m_validate_all;
};

#endif // MAME_EMU_VALIDITY_H