dan/Cosmos
1
0
Fork 0
mirror of https://github.com/danbulant/Cosmos synced 2026-06-11 10:41:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Made extra files for classes

Browse source
This commit is contained in:
gero_cp 2009-08-24 17:42:45 +00:00
parent 3c81f68c66
commit fba8c7c827
4 changed files with 248 additions and 225 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

248
source/Cosmos/Cosmos.Kernel/AddressSpace.cs
View file

@ -2,13 +2,17 @@
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace Cosmos.Kernel {
public abstract class AddressSpace {
namespace Cosmos.Kernel
{
public abstract class AddressSpace
{
public UInt32 Offset;
public UInt32 Size;
public AddressSpace(UInt32 offset, UInt32 size) {
public AddressSpace( UInt32 offset, UInt32 size )
{
Offset = offset;
Size = size;
}
@ -18,21 +22,21 @@ namespace Cosmos.Kernel {
/// </summary>
/// <param name="offset">The offset to read from</param>
/// <returns>8 bits of data read</returns>
public abstract byte Read8(UInt32 offset);
public abstract byte Read8( UInt32 offset );
/// <summary>
/// Reads 16 bits from a given offset if it within the valid range
/// </summary>
/// <param name="offset">The offset to read from</param>
/// <returns>16 bits of data read</returns>
public abstract UInt16 Read16(UInt32 offset);
public abstract UInt16 Read16( UInt32 offset );
/// <summary>
/// Reads 32 bits from a given offset if it within the valid range
/// </summary>
/// <param name="offset">The offset to read from</param>
/// <returns>32 bits of data read</returns>
public abstract UInt32 Read32(UInt32 offset);
public abstract UInt32 Read32( UInt32 offset );
/// <summary>
/// Reads 64 bits from a given offset if it within the valid range
@ -46,21 +50,21 @@ namespace Cosmos.Kernel {
/// </summary>
/// <param name="offset">The offset to read from</param>
/// <returns>8 bits of data read</returns>
public abstract byte Read8Unchecked(UInt32 offset);
public abstract byte Read8Unchecked( UInt32 offset );
/// <summary>
/// Reads 16 bits from a given offset. The offset is not checked. Use with caution
/// </summary>
/// <param name="offset">The offset to read from</param>
/// <returns>16 bits of data read</returns>
public abstract UInt16 Read16Unchecked(UInt32 offset);
public abstract UInt16 Read16Unchecked( UInt32 offset );
/// <summary>
/// Reads 32 bits from a given offset. The offset is not checked. Use with caution
/// </summary>
/// <param name="offset">The offset to read from</param>
/// <returns>32 bits of data read</returns>
public abstract UInt32 Read32Unchecked(UInt32 offset);
public abstract UInt32 Read32Unchecked( UInt32 offset );
/// <summary>
/// Reads 64 bits from a given offset. The offset is not checked. Use with caution
@ -74,21 +78,21 @@ namespace Cosmos.Kernel {
/// </summary>
/// <param name="offset">The offset to write to</param>
/// <param name="value">The data to write</param>
public abstract void Write8(UInt32 offset, byte value);
public abstract void Write8( UInt32 offset, byte value );
/// <summary>
/// Writes 16 bits from a given offset if it is within the valid range.
/// </summary>
/// <param name="offset">The offset to write to</param>
/// <param name="value">The data to write</param>
public abstract void Write16(UInt32 offset, UInt16 value);
public abstract void Write16( UInt32 offset, UInt16 value );
/// <summary>
/// Writes 32 bits from a given offset if it is within the valid range.
/// </summary>
/// <param name="offset">The offset to write to</param>
/// <param name="value">The data to write</param>
public abstract void Write32(UInt32 offset, UInt32 value);
public abstract void Write32( UInt32 offset, UInt32 value );
/// <summary>
/// Writes 64 bits from a given offset if it is within the valid range.
@ -102,231 +106,27 @@ namespace Cosmos.Kernel {
/// </summary>
/// <param name="offset">The offset to write to</param>
/// <param name="value">The data to write</param>
public abstract void Write8Unchecked(UInt32 offset, byte value);
public abstract void Write8Unchecked( UInt32 offset, byte value );
/// <summary>
/// Writes 16 bits from a given offset. The offset is not checked. Use with caution.
/// </summary>
/// <param name="offset">The offset to write to</param>
/// <param name="value">The data to write</param>
public abstract void Write16Unchecked(UInt32 offset, UInt16 value);
public abstract void Write16Unchecked( UInt32 offset, UInt16 value );
/// <summary>
/// Writes 32 bits from a given offset. The offset is not checked. Use with caution.
/// </summary>
/// <param name="offset">The offset to write to</param>
/// <param name="value">The data to write</param>
public abstract void Write32Unchecked(UInt32 offset, UInt32 value);
public abstract void Write32Unchecked( UInt32 offset, UInt32 value );
/// <summary>
/// Writes 64 bits from a given offset. The offset is not checked. Use with caution.
/// </summary>
/// <param name="offset">The offset to write to</param>
/// <param name="value">The data to write</param>
public abstract void Write64Unchecked( UInt32 offset, UInt64 value );
}
public unsafe class MemoryAddressSpace : AddressSpace
{
public MemoryAddressSpace(UInt32 offset, UInt32 size) : base(offset, size)
{ }
public override byte Read8(UInt32 offset)
{
if (offset > Size)
throw new ArgumentOutOfRangeException("offset");
return *(byte*)(this.Offset + offset);
}
public override UInt16 Read16(UInt32 offset)
{
if (offset < 0 || offset > Size)
throw new ArgumentOutOfRangeException("offset");
return *(UInt16*)(this.Offset + offset);
}
public override UInt32 Read32(UInt32 offset)
{
if (offset < 0 || offset > Size)
throw new ArgumentOutOfRangeException("offset");
return *(UInt32*)(this.Offset + offset);
}
public override UInt64 Read64( UInt32 offset )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
return *( UInt64* )( this.Offset + offset );
}
public override byte Read8Unchecked(UInt32 offset)
{
return *(byte*)(this.Offset + offset);
}
public override UInt16 Read16Unchecked(UInt32 offset)
{
return *(UInt16*)(this.Offset + offset);
}
public override UInt32 Read32Unchecked(UInt32 offset)
{
return *(UInt32*)(this.Offset + offset);
}
public override UInt64 Read64Unchecked( UInt32 offset )
{
return *( UInt64* )( this.Offset + offset );
}
public override void Write8(UInt32 offset, byte value)
{
if (offset < 0 || offset > Size)
throw new ArgumentOutOfRangeException("offset");
(*(byte*)(this.Offset + offset)) = value;
}
public override void Write16(UInt32 offset, UInt16 value)
{
if (offset < 0 || offset > Size)
throw new ArgumentOutOfRangeException("offset");
(*(UInt16*)(this.Offset + offset)) = value;
}
public override void Write32(UInt32 offset, UInt32 value)
{
if (offset < 0 || offset > Size)
throw new ArgumentOutOfRangeException("offset");
(*(UInt32*)(this.Offset + offset)) = value;
}
public override void Write64( UInt32 offset, UInt64 value )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
( *( UInt64* )( this.Offset + offset ) ) = value;
}
public override void Write8Unchecked(UInt32 offset, byte value)
{
(*(byte*)(this.Offset + offset)) = value;
}
public override void Write16Unchecked(UInt32 offset, UInt16 value)
{
(*(UInt16*)(this.Offset + offset)) = value;
}
public override void Write32Unchecked(UInt32 offset, UInt32 value)
{
(*(UInt32*)(this.Offset + offset)) = value;
}
public override void Write64Unchecked(UInt32 offset, UInt64 value)
{
(*(UInt64*)(this.Offset + offset)) = value;
}
public void CopyFrom(MemoryAddressSpace src)
{
for (uint x = 0; x < src.Size; x++)
{
(*(byte*)(this.Offset + x)) = *(byte*)(src.Offset + x);
}
}
public void CopyFrom(MemoryAddressSpace src, uint srcOffset, uint dstOffset, uint bytes)
{
for (uint x = 0; x < bytes; x++)
{
(*(byte*)(this.Offset + dstOffset + x)) = *(byte*)(src.Offset + srcOffset + x);
}
}
public void SetMem(byte data)
{
for (uint x = 0; x < this.Size; x++)
{
(*(byte*)(this.Offset + x)) = data;
}
}
}
public class IOAddressSpace : AddressSpace
{
public IOAddressSpace(UInt32 offset, UInt32 size)
: base(offset, size)
{
if (offset > 0xffff || offset + size > 0xffff)
throw new ArgumentOutOfRangeException("offset or size");
}
public override byte Read8(UInt32 offset)
{
if (offset < 0 || offset > Size)
throw new ArgumentOutOfRangeException("offset");
return Kernel.CPUBus.Read8((UInt16)(this.Offset + offset));
}
public override UInt16 Read16(UInt32 offset)
{
if (offset < 0 || offset > Size)
throw new ArgumentOutOfRangeException("offset");
return Kernel.CPUBus.Read16((UInt16)(this.Offset + offset));
}
public override UInt32 Read32(UInt32 offset)
{
if (offset < 0 || offset > Size)
throw new ArgumentOutOfRangeException("offset");
return Kernel.CPUBus.Read32((UInt16)(this.Offset + offset));
}
public override UInt64 Read64( UInt32 offset )
{
throw new NotImplementedException();
}
public override byte Read8Unchecked(UInt32 offset)
{
return Kernel.CPUBus.Read8((UInt16)(this.Offset + offset));
}
public override UInt16 Read16Unchecked(UInt32 offset)
{
return Kernel.CPUBus.Read16((UInt16)(this.Offset + offset));
}
public override UInt32 Read32Unchecked(UInt32 offset)
{
return Kernel.CPUBus.Read32((UInt16)(this.Offset + offset));
}
public override UInt64 Read64Unchecked( UInt32 offset )
{
throw new NotImplementedException();
}
public override void Write8(UInt32 offset, byte value)
{
if (offset < 0 || offset > Size)
throw new ArgumentOutOfRangeException("offset");
Kernel.CPUBus.Write8((UInt16)(this.Offset + offset), value);
}
public override void Write16(UInt32 offset, UInt16 value)
{
if (offset < 0 || offset > Size)
throw new ArgumentOutOfRangeException("offset");
Kernel.CPUBus.Write16((UInt16)(this.Offset + offset), value);
}
public override void Write32(UInt32 offset, UInt32 value)
{
if (offset < 0 || offset > Size)
throw new ArgumentOutOfRangeException("offset");
Kernel.CPUBus.Write32((UInt16)(this.Offset + offset), value);
}
public override void Write64( UInt32 offset, UInt64 value )
{
throw new NotImplementedException();
}
public override void Write8Unchecked(UInt32 offset, byte value)
{
Kernel.CPUBus.Write8((UInt16)(this.Offset + offset), value);
}
public override void Write16Unchecked(UInt32 offset, UInt16 value)
{
Kernel.CPUBus.Write16((UInt16)(this.Offset + offset), value);
}
public override void Write32Unchecked(UInt32 offset, UInt32 value)
{
Kernel.CPUBus.Write32((UInt16)(this.Offset + offset), value);
}
public override void Write64Unchecked( UInt32 offset, UInt64 value )
{
throw new NotImplementedException();
}
public abstract void Write64Unchecked( UInt32 offset, UInt64 value );
}
}

4
source/Cosmos/Cosmos.Kernel/Cosmos.Kernel.csproj
View file

@ -3,7 +3,7 @@
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.21022</ProductVersion>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{A1F83D9F-2D44-4264-A08B-416797123018}</ProjectGuid>
<OutputType>Library</OutputType>
@ -51,6 +51,8 @@
</ItemGroup>
<ItemGroup>
<Compile Include="AddressSpace.cs" />
<Compile Include="IOAddressSpace.cs" />
<Compile Include="MemoryAddressSpace.cs" />
<Compile Include="CPU.cs" />
<Compile Include="CPUBus.cs" />
<Compile Include="Extension\Binary.cs" />

97
source/Cosmos/Cosmos.Kernel/IOAddressSpace.cs Normal file
View file

@ -0,0 +1,97 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace Cosmos.Kernel
{
public class IOAddressSpace : AddressSpace
{
public IOAddressSpace( UInt32 offset, UInt32 size )
: base( offset, size )
{
if( offset > 0xffff || offset + size > 0xffff )
throw new ArgumentOutOfRangeException( "offset or size" );
}
public override byte Read8( UInt32 offset )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
return Kernel.CPUBus.Read8( ( UInt16 )( this.Offset + offset ) );
}
public override UInt16 Read16( UInt32 offset )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
return Kernel.CPUBus.Read16( ( UInt16 )( this.Offset + offset ) );
}
public override UInt32 Read32( UInt32 offset )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
return Kernel.CPUBus.Read32( ( UInt16 )( this.Offset + offset ) );
}
public override UInt64 Read64( UInt32 offset )
{
throw new NotImplementedException();
}
public override byte Read8Unchecked( UInt32 offset )
{
return Kernel.CPUBus.Read8( ( UInt16 )( this.Offset + offset ) );
}
public override UInt16 Read16Unchecked( UInt32 offset )
{
return Kernel.CPUBus.Read16( ( UInt16 )( this.Offset + offset ) );
}
public override UInt32 Read32Unchecked( UInt32 offset )
{
return Kernel.CPUBus.Read32( ( UInt16 )( this.Offset + offset ) );
}
public override UInt64 Read64Unchecked( UInt32 offset )
{
throw new NotImplementedException();
}
public override void Write8( UInt32 offset, byte value )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
Kernel.CPUBus.Write8( ( UInt16 )( this.Offset + offset ), value );
}
public override void Write16( UInt32 offset, UInt16 value )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
Kernel.CPUBus.Write16( ( UInt16 )( this.Offset + offset ), value );
}
public override void Write32( UInt32 offset, UInt32 value )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
Kernel.CPUBus.Write32( ( UInt16 )( this.Offset + offset ), value );
}
public override void Write64( UInt32 offset, UInt64 value )
{
throw new NotImplementedException();
}
public override void Write8Unchecked( UInt32 offset, byte value )
{
Kernel.CPUBus.Write8( ( UInt16 )( this.Offset + offset ), value );
}
public override void Write16Unchecked( UInt32 offset, UInt16 value )
{
Kernel.CPUBus.Write16( ( UInt16 )( this.Offset + offset ), value );
}
public override void Write32Unchecked( UInt32 offset, UInt32 value )
{
Kernel.CPUBus.Write32( ( UInt16 )( this.Offset + offset ), value );
}
public override void Write64Unchecked( UInt32 offset, UInt64 value )
{
throw new NotImplementedException();
}
}
}

124
source/Cosmos/Cosmos.Kernel/MemoryAddressSpace.cs Normal file
View file

@ -0,0 +1,124 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace Cosmos.Kernel
{
public unsafe class MemoryAddressSpace : AddressSpace
{
public MemoryAddressSpace( UInt32 offset, UInt32 size )
: base( offset, size )
{ }
public override byte Read8( UInt32 offset )
{
if( offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
return *( byte* )( this.Offset + offset );
}
public override UInt16 Read16( UInt32 offset )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
return *( UInt16* )( this.Offset + offset );
}
public override UInt32 Read32( UInt32 offset )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
return *( UInt32* )( this.Offset + offset );
}
public override UInt64 Read64( UInt32 offset )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
return *( UInt64* )( this.Offset + offset );
}
public override byte Read8Unchecked( UInt32 offset )
{
return *( byte* )( this.Offset + offset );
}
public override UInt16 Read16Unchecked( UInt32 offset )
{
return *( UInt16* )( this.Offset + offset );
}
public override UInt32 Read32Unchecked( UInt32 offset )
{
return *( UInt32* )( this.Offset + offset );
}
public override UInt64 Read64Unchecked( UInt32 offset )
{
return *( UInt64* )( this.Offset + offset );
}
public override void Write8( UInt32 offset, byte value )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
( *( byte* )( this.Offset + offset ) ) = value;
}
public override void Write16( UInt32 offset, UInt16 value )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
( *( UInt16* )( this.Offset + offset ) ) = value;
}
public override void Write32( UInt32 offset, UInt32 value )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
( *( UInt32* )( this.Offset + offset ) ) = value;
}
public override void Write64( UInt32 offset, UInt64 value )
{
if( offset < 0 || offset > Size )
throw new ArgumentOutOfRangeException( "offset" );
( *( UInt64* )( this.Offset + offset ) ) = value;
}
public override void Write8Unchecked( UInt32 offset, byte value )
{
( *( byte* )( this.Offset + offset ) ) = value;
}
public override void Write16Unchecked( UInt32 offset, UInt16 value )
{
( *( UInt16* )( this.Offset + offset ) ) = value;
}
public override void Write32Unchecked( UInt32 offset, UInt32 value )
{
( *( UInt32* )( this.Offset + offset ) ) = value;
}
public override void Write64Unchecked( UInt32 offset, UInt64 value )
{
( *( UInt64* )( this.Offset + offset ) ) = value;
}
public void CopyFrom( MemoryAddressSpace src )
{
for( uint x = 0; x < src.Size; x++ )
{
( *( byte* )( this.Offset + x ) ) = *( byte* )( src.Offset + x );
}
}
public void CopyFrom( MemoryAddressSpace src, uint srcOffset, uint dstOffset, uint bytes )
{
for( uint x = 0; x < bytes; x++ )
{
( *( byte* )( this.Offset + dstOffset + x ) ) = *( byte* )( src.Offset + srcOffset + x );
}
}
public void SetMem( byte data )
{
for( uint x = 0; x < this.Size; x++ )
{
( *( byte* )( this.Offset + x ) ) = data;
}
}
}
}