/// <summary>
/// Converts character to an ascii c like string representation.
/// If unicode character is outside the range of an Ascii
/// character then Convert.NonAsciiCharacter is returned.
/// </summary>
/// <param name="value">char to be converted</param>
/// <returns></returns>
public unsafe static CString8 *ToCString8(char value)
{
CString8 *str1 = CString8.Create(1);
str1->SetChar(0, ToAscii(value));
return(str1);
}
/// <summary>
/// Converts string to its ascii representation terminating with
/// null. If unicode character is outside the range of an Ascii
/// character then Convert.NonAsciiCharacter is returned in its
/// place.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public unsafe static CString8 *ToCString8(string value)
{
CString8 *str1 = CString8.Create(value.Length);
for (int x = 0; x < value.Length; x++)
{
str1->SetChar(x, ToAscii(value [x]));
}
return(str1);
}
/// <summary>
/// Performs a new test, optionally printing it and/or recording it in memory.
/// </summary>
public unsafe static void Test(bool result, string source, string name)
{
CString8 *sourceStr = CString8.Copy(source);
CString8 *nameStr = CString8.Copy(name);
if (PrintTestcases)
{
Debug.COM1.Write(sourceStr);
Debug.COM1.Write(": ");
Debug.COM1.Write(nameStr);
Debug.COM1.Write(" ... ");
TextMode.SaveAttributes();
if (result)
{
Debug.COM1.WriteLine("PASS");
}
else
{
Debug.COM1.WriteLine("FAIL");
}
TextMode.RestoreAttributes();
}
if (RecordTestcases)
{
TestRecord *rec = (TestRecord *)MemoryManager.Allocate((uint)sizeof(TestRecord));
rec->Source = sourceStr;
rec->Name = nameStr;
rec->Result = result;
rec->Next = null;
if (Records == null)
{
Records = rec;
}
else
{
GetLastTest()->Next = rec;
}
}
else
{
MemoryManager.Free(sourceStr);
MemoryManager.Free(nameStr);
}
}
private CString8 *Substring_INTERNAL(int index, int count)
{
if (count == 0)
{
return(CString8.CreateEmpty());
}
byte *rslt = (byte *)SharpOS.Kernel.ADC.MemoryManager.Allocate((uint)count + 1);
byte *thisPtr = this.Pointer;
Diagnostics.Assert(rslt != thisPtr, "CString8.Substring_INTERNAL(): Insane memory allocation detected!");
for (int i = index; i < (index + count); i++)
{
rslt [i - index] = thisPtr [i];
}
rslt [count] = (byte)'\0';
return((CString8 *)rslt);
}
public CommandTableEntry* FindCommand (CString8* name)
{
Diagnostics.Assert (name != null, "CommandTableHeader::FindCommand(CString8*): Parameter 'name' is null");
Diagnostics.Assert (firstEntry != null, "CommandTableHeader::FindCommand(CString8*): Cannot search through commands; command list is empty");
CommandTableEntry* currentEntry;
for (currentEntry = firstEntry;
currentEntry != null;
currentEntry = currentEntry->nextEntry) {
//FIXME: This needs to be case insensitive!
if (ByteString.Compare (name->Pointer, currentEntry->name->Pointer) == 0)
return currentEntry;
//else
//{
// ADC.TextMode.Write("CommandTableHeader::FindCommand(CString8*): Entered '");
// ADC.TextMode.Write(name);
// ADC.TextMode.Write("' != '");
// ADC.TextMode.Write(currentEntry->name);
// ADC.TextMode.WriteLine("'");
//}
}
return null;
}
private static void HandleUnrecognizedCommandEntry (CString8* commandName)
{
TextMode.Write ("Unrecognized command: \"");
TextMode.Write (commandName);
TextMode.WriteLine ("\"");
}
/// <summary>
/// Writes <paramref name="len" /> characters of the string
/// <paramref name="message" /> to the screen, starting with
/// the character at index <paramref name="offset" />.
/// </summary>
public unsafe static void WriteSubstring (CString8* message, int offset, int len)
{
for (int i = offset; message->GetChar (i) != 0 && i < offset + len; ++i)
WriteChar (message->GetChar (i));
}
private unsafe static bool __StringComp (CString8* str1, CString8* str2)
{
byte* s1 = (byte*) str1;
byte* s2 = (byte*) str2;
while (*s1 == *s2 && *s1 != 0 && *s2 != 0) {
++s1;
++s2;
}
return (*s1 == 0 & *s2 == 0);
}
/// <summary>
/// Sets the current keymap to a built-in one specified by
/// <paramref name="name" />.
/// </summary>
public static void SetKeyMap (CString8* name)
{
SetKeyMap (name->Pointer);
}
/// <summary>
/// Concatenates <paramref name="str" />.
/// </summary>
public int Concat (CString8* str)
{
return Concat (str, 0, 0);
}
/// <summary>
/// Compares the string against <paramref name="str" />.
/// </summary>
public int Compare (CString8* str)
{
return Compare (str, 0);
}
public static unsafe TypeDefRow GetType (CString8 *ns, CString8 *name)
{
AssemblyMetadata assembly;
uint token;
return GetType (ns, name, out assembly, out token);
}
public static void DISPOSE (CString8* cstr)
{
ADC.MemoryManager.Free ((void*) cstr);
}
public static unsafe ModuleRow GetModule (AssemblyMetadata assembly, CString8 *name)
{
Diagnostics.Assert (assembly == null,
"Runtime.GetModule(): parameter `assembly' is null");
Diagnostics.Assert (name == null,
"Runtime.GetModule(): parameter `name' is null");
for (int x = 0; x < assembly.Module.Length; ++x) {
ModuleRow row = assembly.Module [x];
int len = GetStringLength (assembly, row.Name);
if (name->Compare (0, assembly.StringsHeap, (int) row.Name, len) == 0)
return row;
}
return null;
}
public static unsafe TypeDefRow GetType (CString8 *ns, CString8 *name, out AssemblyMetadata assembly, out uint token)
{
token = 0;
assembly = null;
Diagnostics.Assert (ns != null,
"Runtime.GetType(): parameter `ns' is null");
Diagnostics.Assert (name != null,
"Runtime.GetType(): parameter `name' is null");
for (int x = 0; x < Root.Assemblies.Length; ++x) {
TypeDefRow row = GetType (Root.Assemblies [x], ns, name, out token);
if (row != null) {
assembly = Root.Assemblies [x];
return row;
}
}
return null;
}
public static unsafe ModuleRow GetModule (CString8 *name)
{
for (int x = 0; x < Root.Assemblies.Length; ++x) {
ModuleRow result = GetModule (Root.Assemblies [x], name);
if (result != null)
return result;
}
return null;
}
public static unsafe bool IsBaseClassOf (TypeInfo type, CString8 *baseNS, CString8 *baseType)
{
AssemblyMetadata baseAsm;
uint token;
TypeRefRow row;
TypeDefRow def;
row = GetTypeRef (baseNS, baseType, out baseAsm, out token);
if (row != null) {
return IsBaseClassOf (type.Assembly, type.MetadataToken, baseAsm, token);
} else {
def = GetType (baseNS, baseType, out baseAsm, out token);
Diagnostics.Assert (def != null,
"Runtime.IsBaseClasOf(): couldn't find TypeRef/Def for named type");
return IsBaseClassOf (type.Assembly, type.MetadataToken, baseAsm, token);
}
}
public static void RenderItem(string title, CString8* value)
{
RenderItemTitle(title);
TextMode.WriteLine(value);
}
/// <summary>
/// Compares <paramref name="count" /> characters of the
/// string against <paramref name="str" />.
/// </summary>
public int Compare (int from, CString8* str, int offset, int count)
{
return ByteString.Compare (Pointer, from, str->Pointer, offset, count);
}
public static unsafe TypeDefRow GetType (AssemblyMetadata assembly, CString8 *ns, CString8 *name)
{
uint token;
return GetType (assembly, name, ns, out token);
}
public static CString8* Copy (CString8* original)
{
uint l = (uint) original->Length;
byte* originalPtr = original->Pointer;
byte* result = (byte*) ADC.MemoryManager.Allocate (l + 1);
for (int i = 0; i < l; i++)
result [i] = originalPtr [i];
result [l] = (byte) '\0';
return (CString8*) result;
}
public static unsafe TypeRefRow GetTypeRef (CString8 *ns, CString8 *name, out AssemblyMetadata assembly, out uint token)
{
assembly = null;
token = 0;
for (int x = 0; x < Root.Assemblies.Length; ++x) {
TypeRefRow result = GetTypeRef (Root.Assemblies [x], ns, name, out token);
if (result != null) {
assembly = Root.Assemblies [x];
return result;
}
}
return null;
}
/// <summary>
/// Concatenates from <paramref name="str" /> the
/// characters at indices <paramref name="offset" /> to
/// <paramref name="offset" /> + <paramref name="len" />.
/// </summary>
public int Concat (CString8* str, int offset, int len)
{
return Concat (str->Pointer, str->Length, offset, len);
}
public static unsafe TypeRefRow GetTypeRef (AssemblyMetadata assembly, CString8 *ns, CString8 *name, out uint token)
{
TypeRefRow result = null;
token = 0;
for (int x = 0; x < assembly.TypeRef.Length; ++x) {
int nameLength = 0;
int nsLength = 0;
TypeRefRow inspect = assembly.TypeRef [x];
nameLength = GetStringLength (assembly, inspect.Name);
nsLength = GetStringLength (assembly, inspect.Namespace);
if (name->Compare (0, assembly.StringsHeap, (int) inspect.Name, nameLength) != 0)
continue;
if (ns->Compare (0, assembly.StringsHeap, (int) inspect.Namespace, nsLength) != 0)
continue;
result = inspect;
token = (uint)TokenType.TypeRef | (uint)x+1U;
break;
}
return result;
}
/// <summary>
/// Compares <paramref name="count" /> characters of the
/// string against <paramref name="str" />.
/// </summary>
public int Compare (CString8* str, int count)
{
return ByteString.Compare (Pointer, str->Pointer, count);
}
public int IndexOf (int from, CString8* substr, int offset, int count)
{
return IndexOf (from, substr->Pointer, substr->Length, offset, count);
}
static public string ToString (CString8* cstring)
{
return InternalSystem.String.CreateStringImpl (cstring);
}
public unsafe static void Write (CString8* str)
{
Write (str->Pointer, str->Length);
}
/// <summary>
/// Gets the address of a builtin keymap included in the kernel
/// via the keymap archive resource in SharpOS.Kernel.dll. The
/// archive is generated by the SharpOS keymap compiler.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="nameLen">The name len.</param>
/// <returns></returns>
public static void* GetBuiltinKeyMap (CString8* name)
{
return GetBuiltinKeyMap (name->Pointer, name->Length);
}
public int IndexOf (int from, CString8* substr)
{
return IndexOf (from, substr, 0, 0);
}
internal CommandExecutionAttemptResult HandleLine (CString8* input, bool verboseFailure, bool useHelp)
{
Diagnostics.Assert (input != null, "Prompter::HandleLine(CString8*): Parameter 'input' is null");
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Function started");
#endif
if (input->Length == 0) {
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Raw input is blank");
#endif
if (verboseFailure)
HandleEmptyCommandEntry ();
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): RET");
#endif
return CommandExecutionAttemptResult.BlankEntry;
}
CString8* trimmedInput = input->Trim ();
if (trimmedInput->Length == 0) {
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Trimmed input is blank");
#endif
CString8.DISPOSE (trimmedInput);
if (verboseFailure)
HandleEmptyCommandEntry ();
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): RET");
#endif
return CommandExecutionAttemptResult.BlankEntry;
}
int firstSpace = trimmedInput->IndexOf (" ");
CString8* commandName;
CString8* parameters;
if (firstSpace < 0) {
commandName = trimmedInput;
parameters = CString8.CreateEmpty ();
}
else {
commandName = trimmedInput->Substring (0, firstSpace);
parameters = trimmedInput->Substring (firstSpace + 1);
}
CommandTableEntry* command = this.FindCommand (commandName);
if (command == null) {
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Command not found");
#endif
if (verboseFailure)
HandleUnrecognizedCommandEntry (commandName);
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Freeing contextual stuff");
#endif
//Free up what we used
if (commandName != trimmedInput)
CString8.DISPOSE (commandName);
CString8.DISPOSE (trimmedInput);
CString8.DISPOSE (parameters);
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): RET");
#endif
return CommandExecutionAttemptResult.NotFound;
}
CommandExecutionContext* commandExecutionContext = CommandExecutionContext.CREATE ();
commandExecutionContext->parameters = parameters;
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Getting ready to call command");
#endif
if (!useHelp)
ADC.MemoryUtil.Call (command->func_Execute, (void*)commandExecutionContext);
else
ADC.MemoryUtil.Call (command->func_GetHelp, (void*)commandExecutionContext);
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Done calling command");
#endif
//Free up what we used
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Freeing contextual stuff");
#endif
if (commandName != trimmedInput)
CString8.DISPOSE (commandName);
CString8.DISPOSE (trimmedInput);
CString8.DISPOSE (parameters);
CommandExecutionContext.DISPOSE (commandExecutionContext);
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): RET");
#endif
return CommandExecutionAttemptResult.Success;
}
public int IndexOf (CString8* substr)
{
return IndexOf (0, substr, 0, 0);
}
public int IndexOf (int from, CString8* substr, int count)
{
return IndexOf (from, substr, 0, count);
}
public unsafe static void WriteLine (CString8* message, int value)
{
Write (message);
Write (value);
WriteLine ();
}
