namcos21: shorthand variable types

Author: happppp

src/mame/namco/namcos21.cpp

@@ -335,46 +335,46 @@ class namcos21_state : public driver_device
 	required_device<namco_c148_device> m_master_intc;
 	required_device<namco_c148_device> m_slave_intc;
 	required_device<namco_c148_device> m_gpu_intc;
-	memory_share_creator<uint8_t> m_nvram;
+	memory_share_creator<u8> m_nvram;
 	required_device<c140_device> m_c140;
 	required_device<palette_device> m_palette;
 	required_device<screen_device> m_screen;
 	required_memory_bank m_audiobank;
 	required_region_ptr<u16> m_c140_region;
-	required_shared_ptr<uint8_t> m_dpram;
+	required_shared_ptr<u8> m_dpram;
 	required_device<namcos21_3d_device> m_namcos21_3d;
 	required_device<namcos21_dsp_device> m_namcos21_dsp;
 
-	std::unique_ptr<uint8_t[]> m_gpu_videoram;
+	std::unique_ptr<u8[]> m_gpu_videoram;
 
-	uint8_t m_gpu_videoram_mask = 0;
-	uint16_t m_gpu_color = 0;
-	uint16_t m_gpu_register[0x10/2] = { };
+	u8 m_gpu_videoram_mask = 0;
+	u16 m_gpu_color = 0;
+	u16 m_gpu_register[0x10/2] = { };
 
-	uint16_t dpram_word_r(offs_t offset);
-	void dpram_word_w(offs_t offset, uint16_t data, uint16_t mem_mask = ~0);
-	uint8_t dpram_byte_r(offs_t offset);
-	void dpram_byte_w(offs_t offset, uint8_t data);
+	u16 dpram_word_r(offs_t offset);
+	void dpram_word_w(offs_t offset, u16 data, u16 mem_mask = ~0);
+	u8 dpram_byte_r(offs_t offset);
+	void dpram_byte_w(offs_t offset, u8 data);
 
-	uint16_t gpu_color_r();
-	void gpu_color_w(offs_t offset, uint16_t data, uint16_t mem_mask = ~0);
-	uint16_t gpu_register_r(offs_t offset);
-	void gpu_register_w(offs_t offset, uint16_t data, uint16_t mem_mask = ~0);
-	void gpu_videoram_w(offs_t offset, uint16_t data, uint16_t mem_mask = ~0);
-	uint16_t gpu_videoram_r(offs_t offset);
+	u16 gpu_color_r();
+	void gpu_color_w(offs_t offset, u16 data, u16 mem_mask = ~0);
+	u16 gpu_register_r(offs_t offset);
+	void gpu_register_w(offs_t offset, u16 data, u16 mem_mask = ~0);
+	void gpu_videoram_w(offs_t offset, u16 data, u16 mem_mask = ~0);
+	u16 gpu_videoram_r(offs_t offset);
 
-	void nvram_w(offs_t offset, uint8_t data) { m_nvram[offset] = data; }
-	uint8_t nvram_r(offs_t offset) { return m_nvram[offset]; }
+	void nvram_w(offs_t offset, u8 data) { m_nvram[offset] = data; }
+	u8 nvram_r(offs_t offset) { return m_nvram[offset]; }
 
-	void sound_bankselect_w(uint8_t data);
+	void sound_bankselect_w(u8 data);
 
-	void sound_reset_w(uint8_t data);
-	void system_reset_w(uint8_t data);
+	void sound_reset_w(u8 data);
+	void system_reset_w(u8 data);
 	void reset_all_subcpus(int state);
 
 	TIMER_DEVICE_CALLBACK_MEMBER(screen_scanline);
 
-	uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
+	u32 screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect);
 
 	void bitmap_draw(bitmap_ind16 &bitmap, const rectangle &cliprect);
 
@@ -388,36 +388,36 @@ class namcos21_state : public driver_device
 
 void namcos21_state::video_start()
 {
-	m_gpu_videoram = make_unique_clear<uint8_t[]>(0x80000);
+	m_gpu_videoram = make_unique_clear<u8[]>(0x80000);
 	save_pointer(NAME(m_gpu_videoram), 0x80000);
 }
 
-uint16_t namcos21_state::gpu_color_r()
+u16 namcos21_state::gpu_color_r()
 {
 	return m_gpu_color;
 }
 
-void namcos21_state::gpu_color_w(offs_t offset, uint16_t data, uint16_t mem_mask)
+void namcos21_state::gpu_color_w(offs_t offset, u16 data, u16 mem_mask)
 {
 	COMBINE_DATA(&m_gpu_color);
 }
 
-uint16_t namcos21_state::gpu_register_r(offs_t offset)
+u16 namcos21_state::gpu_register_r(offs_t offset)
 {
 	return m_gpu_register[offset];
 }
 
-void namcos21_state::gpu_register_w(offs_t offset, uint16_t data, uint16_t mem_mask)
+void namcos21_state::gpu_register_w(offs_t offset, u16 data, u16 mem_mask)
 {
 	m_screen->update_partial(m_screen->vpos());
 	COMBINE_DATA(&m_gpu_register[offset]);
 }
 
-void namcos21_state::gpu_videoram_w(offs_t offset, uint16_t data, uint16_t mem_mask)
+void namcos21_state::gpu_videoram_w(offs_t offset, u16 data, u16 mem_mask)
 {
 	// it always does word access
 	m_gpu_videoram_mask = data & 0xff;
-	uint8_t color = data >> 8;
+	u8 color = data >> 8;
 
 	for (int i = 0; i < 8; i++)
 	{
@@ -426,7 +426,7 @@ void namcos21_state::gpu_videoram_w(offs_t offset, uint16_t data, uint16_t mem_m
 	}
 }
 
-uint16_t namcos21_state::gpu_videoram_r(offs_t offset)
+u16 namcos21_state::gpu_videoram_r(offs_t offset)
 {
 	return (m_gpu_videoram[offset] << 8) | m_gpu_videoram_mask;
 }
@@ -441,14 +441,14 @@ void namcos21_state::bitmap_draw(bitmap_ind16 &bitmap, const rectangle &cliprect
 	printf("| %04x\n", m_gpu_color);
 #endif
 
-	int const yscroll = -cliprect.top() + (int16_t)m_gpu_register[1];
+	int const yscroll = -cliprect.top() + (s16)m_gpu_register[1];
 	int const xscroll = m_gpu_register[0] & 0xff;
 	int const base = 0x1000 | (m_gpu_color << 8 & 0xf00);
 
 	for (int sy = cliprect.top(); sy <= cliprect.bottom(); sy++)
 	{
-		uint8_t const *const pSource = &m_gpu_videoram[((yscroll + sy) & 0x3ff) * 0x200];
-		uint16_t *const pDest = &bitmap.pix(sy);
+		u8 const *const pSource = &m_gpu_videoram[((yscroll + sy) & 0x3ff) * 0x200];
+		u16 *const pDest = &bitmap.pix(sy);
 		for (int sx = cliprect.left(); sx <= cliprect.right(); sx++)
 		{
 			int const pen = pSource[(sx + xscroll) & 0x1ff];
@@ -481,7 +481,7 @@ void namcos21_state::bitmap_draw(bitmap_ind16 &bitmap, const rectangle &cliprect
 }
 
 
-uint32_t namcos21_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
+u32 namcos21_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect)
 {
 	bitmap.fill((m_gpu_color << 8 & 0xf00) | 0xff, cliprect);
 
@@ -512,23 +512,23 @@ uint32_t namcos21_state::screen_update(screen_device &screen, bitmap_ind16 &bitm
 
 // dual port ram memory handlers
 
-uint16_t namcos21_state::dpram_word_r(offs_t offset)
+u16 namcos21_state::dpram_word_r(offs_t offset)
 {
 	return m_dpram[offset];
 }
 
-void namcos21_state::dpram_word_w(offs_t offset, uint16_t data, uint16_t mem_mask)
+void namcos21_state::dpram_word_w(offs_t offset, u16 data, u16 mem_mask)
 {
 	if (ACCESSING_BITS_0_7)
 		m_dpram[offset] = data & 0xff;
 }
 
-uint8_t namcos21_state::dpram_byte_r(offs_t offset)
+u8 namcos21_state::dpram_byte_r(offs_t offset)
 {
 	return m_dpram[offset];
 }
 
-void namcos21_state::dpram_byte_w(offs_t offset, uint8_t data)
+void namcos21_state::dpram_byte_w(offs_t offset, u8 data)
 {
 	m_dpram[offset] = data;
 }
@@ -707,12 +707,12 @@ static INPUT_PORTS_START( winrungp )
 	PORT_DIPSETTING(    0x00, "4M" )
 INPUT_PORTS_END
 
-void namcos21_state::sound_bankselect_w(uint8_t data)
+void namcos21_state::sound_bankselect_w(u8 data)
 {
 	m_audiobank->set_entry(data >> 4);
 }
 
-void namcos21_state::sound_reset_w(uint8_t data)
+void namcos21_state::sound_reset_w(u8 data)
 {
 	if (data & 0x01)
 	{
@@ -726,7 +726,7 @@ void namcos21_state::sound_reset_w(uint8_t data)
 	}
 }
 
-void namcos21_state::system_reset_w(uint8_t data)
+void namcos21_state::system_reset_w(u8 data)
 {
 	reset_all_subcpus(data & 1 ? CLEAR_LINE : ASSERT_LINE);
 }
@@ -752,7 +752,7 @@ void namcos21_state::machine_reset()
 
 void namcos21_state::machine_start()
 {
-	uint32_t max = memregion("audiocpu")->bytes() / 0x4000;
+	u32 max = memregion("audiocpu")->bytes() / 0x4000;
 	for (int i = 0; i < 0x10; i++)
 		m_audiobank->configure_entry(i, memregion("audiocpu")->base() + (i % max) * 0x4000);
 

src/mame/namco/namcos21_3d.cpp

@@ -17,7 +17,7 @@ Namco System 21 3D Rasterizer
 
 DEFINE_DEVICE_TYPE(NAMCOS21_3D, namcos21_3d_device, "namcos21_3d", "Namco System 21 3D Rasterizer")
 
-namcos21_3d_device::namcos21_3d_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) :
+namcos21_3d_device::namcos21_3d_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) :
 	device_t(mconfig, NAMCOS21_3D, tag, owner, clock),
 	m_fixed_palbase(-1),
 	m_zz_shift(10),
@@ -39,11 +39,11 @@ void namcos21_3d_device::allocate_poly_framebuffer()
 	if (m_framebuffer_size_in_bytes == 0)
 		fatalerror("m_framebuffer_size_in_bytes == 0\n");
 
-	m_mpPolyFrameBufferZ = make_unique_clear<uint16_t[]>(m_framebuffer_size_in_bytes / 2);
-	m_mpPolyFrameBufferPens = make_unique_clear<uint16_t[]>(m_framebuffer_size_in_bytes / 2);
+	m_mpPolyFrameBufferZ = make_unique_clear<u16[]>(m_framebuffer_size_in_bytes / 2);
+	m_mpPolyFrameBufferPens = make_unique_clear<u16[]>(m_framebuffer_size_in_bytes / 2);
 
-	m_mpPolyFrameBufferZ2 = make_unique_clear<uint16_t[]>(m_framebuffer_size_in_bytes / 2);
-	m_mpPolyFrameBufferPens2 = make_unique_clear<uint16_t[]>(m_framebuffer_size_in_bytes / 2);
+	m_mpPolyFrameBufferZ2 = make_unique_clear<u16[]>(m_framebuffer_size_in_bytes / 2);
+	m_mpPolyFrameBufferPens2 = make_unique_clear<u16[]>(m_framebuffer_size_in_bytes / 2);
 
 	swap_and_clear_poly_framebuffer();
 	swap_and_clear_poly_framebuffer();
@@ -77,9 +77,9 @@ void namcos21_3d_device::copy_visible_poly_framebuffer(bitmap_ind16 &bitmap, con
 	/* blit the visible framebuffer */
 	for (int sy = clip.top(); sy <= clip.bottom(); sy++)
 	{
-		uint16_t *const dest = &bitmap.pix(sy);
-		uint16_t const *const pPen = m_mpPolyFrameBufferPens2.get() + m_poly_frame_width * sy;
-		uint16_t const *const pZ = m_mpPolyFrameBufferZ2.get() + m_poly_frame_width * sy;
+		u16 *const dest = &bitmap.pix(sy);
+		u16 const *const pPen = m_mpPolyFrameBufferPens2.get() + m_poly_frame_width * sy;
+		u16 const *const pZ = m_mpPolyFrameBufferZ2.get() + m_poly_frame_width * sy;
 		for (int sx = clip.left(); sx <= clip.right(); sx++)
 		{
 			int z = pZ[sx];
@@ -99,8 +99,8 @@ void namcos21_3d_device::renderscanline_flat(const edge *e1, const edge *e2, int
 	if (e1->x > e2->x)
 		std::swap(e1, e2);
 
-	uint16_t *pDest = m_mpPolyFrameBufferPens.get() + sy * m_poly_frame_width;
-	uint16_t *pZBuf = m_mpPolyFrameBufferZ.get() + sy * m_poly_frame_width;
+	u16 *pDest = m_mpPolyFrameBufferPens.get() + sy * m_poly_frame_width;
+	u16 *pZBuf = m_mpPolyFrameBufferZ.get() + sy * m_poly_frame_width;
 	int x0 = (int)e1->x;
 	int x1 = (int)e2->x;
 	int w = x1 - x0;
@@ -119,7 +119,7 @@ void namcos21_3d_device::renderscanline_flat(const edge *e1, const edge *e2, int
 
 		for (int x = x0; x < x1; x++)
 		{
-			uint16_t zz = (uint16_t)z;
+			u16 zz = (u16)z;
 			if (zz < pZBuf[x])
 			{
 				int pen = color;
@@ -253,7 +253,7 @@ void namcos21_3d_device::rendertri(const n21_vertex *v0, const n21_vertex *v1, c
 	}
 }
 
-void namcos21_3d_device::blit_single_quad(int sx[4], int sy[4], int zcode[4], uint16_t color)
+void namcos21_3d_device::blit_single_quad(int sx[4], int sy[4], int zcode[4], u16 color)
 {
 	int depthcueenable = 1;
 	// 0x0000..0x1fff  sprite palettes (0x20 sets of 0x100 colors)
@@ -294,42 +294,42 @@ void namcos21_3d_device::blit_single_quad(int sx[4], int sy[4], int zcode[4], ui
 	rendertri(&c, &d, &a, color, depthcueenable);
 }
 
-void namcos21_3d_device::draw_direct_quad(const uint16_t *source, uint16_t color)
+void namcos21_3d_device::draw_direct_quad(const u16 *source, u16 color)
 {
 	int sx[4], sy[4], zcode[4];
 
 	for (int i = 0; i < 4; i++)
 	{
-		sx[i] = m_poly_frame_width/2 + (int16_t)*source++;
-		sy[i] = m_poly_frame_height/2 + (int16_t)*source++;
+		sx[i] = m_poly_frame_width/2 + (s16)*source++;
+		sy[i] = m_poly_frame_height/2 + (s16)*source++;
 		zcode[i] = *source++;
 	}
 
 	blit_single_quad(sx, sy, zcode, color);
 }
 
-void namcos21_3d_device::draw_quads(const uint16_t *source, const uint8_t *pointram, const uint32_t ptram_size, uint32_t quad_idx)
+void namcos21_3d_device::draw_quads(const u16 *source, const u8 *pointram, const u32 ptram_size, u32 quad_idx)
 {
-	const uint32_t ptram_mask = ptram_size - 1;
+	const u32 ptram_mask = ptram_size - 1;
 	quad_idx = (quad_idx * 6) & ptram_mask;
 
 	int sx[4], sy[4], zcode[4];
 
 	for (int count = 0; count < ptram_size / 6; count++)
 	{
-		uint8_t code = pointram[quad_idx];
+		u8 code = pointram[quad_idx];
 		quad_idx = (quad_idx + 1) & ptram_mask;
 
-		uint16_t color = pointram[quad_idx] | (code << 8);
+		u16 color = pointram[quad_idx] | (code << 8);
 		quad_idx = (quad_idx + 1) & ptram_mask;
 
 		for (int i = 0; i < 4; i++)
 		{
-			uint8_t vi = pointram[quad_idx];
+			u8 vi = pointram[quad_idx];
 			quad_idx = (quad_idx + 1) & ptram_mask;
 
-			sx[i] = m_poly_frame_width/2 + (int16_t)source[vi * 3 + 0];
-			sy[i] = m_poly_frame_height/2 + (int16_t)source[vi * 3 + 1];
+			sx[i] = m_poly_frame_width/2 + (s16)source[vi * 3 + 0];
+			sy[i] = m_poly_frame_height/2 + (s16)source[vi * 3 + 1];
 			zcode[i] = source[vi * 3 + 2];
 		}
 

src/mame/namco/namcos21_3d.h

@@ -8,7 +8,7 @@
 class namcos21_3d_device : public device_t
 {
 public:
-	namcos21_3d_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
+	namcos21_3d_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
 
 	// config
 	void set_fixed_palbase(int base) { m_fixed_palbase = base; }
@@ -19,14 +19,14 @@ class namcos21_3d_device : public device_t
 	{
 		m_poly_frame_width = width;
 		m_poly_frame_height = height;
-		m_framebuffer_size_in_bytes = sizeof(uint16_t)*m_poly_frame_width*m_poly_frame_height;
+		m_framebuffer_size_in_bytes = sizeof(u16)*m_poly_frame_width*m_poly_frame_height;
 	}
 
 	void copy_visible_poly_framebuffer(bitmap_ind16 &bitmap, const rectangle &cliprect, int zlo, int zhi);
 	void swap_and_clear_poly_framebuffer();
 
-	void draw_direct_quad(const uint16_t *source, uint16_t color);
-	void draw_quads(const uint16_t *source, const uint8_t *pointram, const uint32_t ptram_size, uint32_t quad_idx);
+	void draw_direct_quad(const u16 *source, u16 color);
+	void draw_quads(const u16 *source, const u8 *pointram, const u32 ptram_size, u32 quad_idx);
 
 protected:
 	// device-level overrides
@@ -47,13 +47,13 @@ class namcos21_3d_device : public device_t
 
 	void renderscanline_flat(const edge *e1, const edge *e2, int sy, unsigned color, int depthcueenable);
 	void rendertri(const n21_vertex *v0, const n21_vertex *v1, const n21_vertex *v2, unsigned color, int depthcueenable);
-	void blit_single_quad(int sx[4], int sy[4], int zcode[4], uint16_t color);
+	void blit_single_quad(int sx[4], int sy[4], int zcode[4], u16 color);
 	void allocate_poly_framebuffer();
 
-	std::unique_ptr<uint16_t[]> m_mpPolyFrameBufferPens;
-	std::unique_ptr<uint16_t[]> m_mpPolyFrameBufferZ;
-	std::unique_ptr<uint16_t[]> m_mpPolyFrameBufferPens2;
-	std::unique_ptr<uint16_t[]> m_mpPolyFrameBufferZ2;
+	std::unique_ptr<u16[]> m_mpPolyFrameBufferPens;
+	std::unique_ptr<u16[]> m_mpPolyFrameBufferZ;
+	std::unique_ptr<u16[]> m_mpPolyFrameBufferPens2;
+	std::unique_ptr<u16[]> m_mpPolyFrameBufferZ2;
 
 	int m_fixed_palbase;
 	int m_zz_shift, m_zzmult;