internal Symbol(string name, IrisType type, StorageClass storage, int location, ImportedMember importInfo)
{
Name = name;
Type = type;
StorageClass = storage;
Location = location;
ImportInfo = importInfo;
}
public Symbol OpenMethod(string name, IrisType type)
{
Symbol methodSymbol = Add(name, type, StorageClass.Global); // Add the method itself to the symbol table
// Create the local scope
_local = new Dictionary<string, Symbol>(StringComparer.InvariantCultureIgnoreCase);
return methodSymbol;
}
public Symbol Add(string name, IrisType type, StorageClass storage, int location, ImportedMember importInfo = null)
{
Symbol symbol = new Symbol(name, type, storage, location, importInfo);
if (storage == StorageClass.Global)
_global.Add(name, symbol);
else
_local.Add(name, symbol);
return symbol;
}
public static Function MakeTestFunction(IrisType returnType, IrisType[] paramTypes)
{
Variable[] parameters = new Variable[paramTypes.Length];
for (int i = 0; i < parameters.Length; i++)
{
string name = string.Format("p{0}", i);
parameters[i] = new Variable(paramTypes[i], name);
}
return Function.Create(returnType, parameters);
}
private Symbol ParseLValue(Lexer lvalLexer)
{
if (lvalLexer.CurrentToken != Token.Identifier)
{
AddLValueError();
return(null);
}
Symbol symbol = _context.SymbolTable.Lookup(lvalLexer.GetLexeme());
if (symbol == null)
{
AddLValueError();
return(null);
}
IrisType lhs = symbol.Type;
lvalLexer.MoveNext();
if (lhs.IsArray)
{
// We should have an open bracket (We don't support changing the array value itself)
if (lvalLexer.CurrentToken != Token.ChrOpenBracket)
{
AddLValueError();
return(null);
}
EmitLoadSymbol(symbol, SymbolLoadMode.Raw);
lvalLexer.MoveNext();
if (lvalLexer.CurrentToken != Token.Number)
{
AddLValueError();
return(null);
}
int index = lvalLexer.ParseInteger();
MethodGenerator.PushIntConst(index);
lvalLexer.MoveNext();
if (lvalLexer.CurrentToken != Token.ChrCloseBracket)
{
AddLValueError();
return(null);
}
}
else if (lhs.IsByRef)
{
EmitLoadSymbol(symbol, SymbolLoadMode.Raw);
}
return(symbol);
}
public void InitializeSymbols()
{
ImportedMethod currentMethod = Scope.TryImportCurrentMethod();
if (currentMethod == null)
{
return; // Nothing to evaluate if we can't get the current method
}
// Add compiler intrinsics
AddIntrinsics();
// Add debugger intrinsics
// (Not implemented yet)
// Add globals
ImportedType type = currentMethod.DeclaringType;
foreach (ImportedField importedfield in type.GetFields())
{
IrisType irisType = importedfield.FieldType;
if (irisType != IrisType.Invalid)
{
SymbolTable.Add(importedfield.Name, irisType, StorageClass.Global, importedfield);
}
}
// Add methods
foreach (ImportedMethod importedMethod in type.GetMethods())
{
Method method = importedMethod.ConvertToIrisMethod();
if (IsValidMethod(method))
{
SymbolTable.Add(importedMethod.Name, method, StorageClass.Global, importedMethod);
}
}
// Create symbol for query method and transition the SymbolTable to method scope
_irisMethod = currentMethod.ConvertToIrisMethod();
SymbolTable.OpenMethod("$.query", _irisMethod);
// Add symbols for parameters
foreach (Variable param in _irisMethod.GetParameters())
{
SymbolTable.Add(param.Name, param.Type, StorageClass.Argument);
}
// Add symbols for local variables
foreach (LocalVariable local in Scope.GetLocals())
{
SymbolTable.Add(local.Name, local.Type, StorageClass.Local, local.Slot);
}
}
private static void Findminmax(int N, IrisType[] T)
{
for (int j = 0; j < T.Length; j++)
{
Console.WriteLine(T[j].Name);
string read = Console.ReadLine();
string[] input = read.Split(' ');
for (int i = 0; i < input.Length; i++)
{
T[j].minmax[N - 1].Add(double.Parse(input[i]));
}
}
}
protected IrisType ParseTerm(SymbolLoadMode mode)
{
IrisType lhs = ParseFactor(mode);
FilePosition fp = _lexer.TokenStartPosition;
Operator opr = AcceptOperator(OperatorMaps.Instance.Term);
if (opr != Operator.None)
{
IrisType rhs = ParseTerm(mode);
return(ProcessArithemticOperator(fp, lhs, rhs, opr));
}
return(lhs);
}
public void StoreElement(IrisType elementType)
{
if (elementType == IrisType.Integer)
{
WriteInstruction("stelem.i4", null);
}
else if (elementType == IrisType.Boolean)
{
WriteInstruction("stelem.i1", null);
}
else
{
WriteInstruction("stelem.ref", null);
}
}
public void LoadElement(IrisType elementType)
{
if (elementType == IrisType.Integer)
{
WriteInstruction("ldelem.i4", null);
}
else if (elementType == IrisType.Boolean)
{
WriteInstruction("ldelem.i1", null);
}
else
{
WriteInstruction("ldelem", IrisTypeToCilTypeName(elementType));
}
}
public void Store(IrisType type)
{
if (type == IrisType.Boolean)
{
WriteInstruction("stind.i1", null);
}
else if (type == IrisType.Integer)
{
WriteInstruction("stind.i4", null);
}
else
{
WriteInstruction("stind.ref", null);
}
}
protected IrisType ParseExpression(SymbolLoadMode mode = SymbolLoadMode.Dereference)
{
IrisType lhs = ParseCompareExpression(mode);
FilePosition fp = _lexer.TokenStartPosition;
Operator opr = AcceptOperator(OperatorMaps.Instance.Logic);
if (opr != Operator.None)
{
VerifyExpressionType(fp, lhs, IrisType.Boolean);
IrisType rhs = ParseExpression(mode);
VerifyExpressionType(fp, rhs, IrisType.Boolean);
MethodGenerator.Operator(opr);
}
return(lhs);
}
private void InitArrayHelper(Symbol arraySymbol, int lowerBound, int dimension)
{
IrisType elementType = arraySymbol.Type.GetElementType();
string cilType = IrisTypeToCilTypeName(elementType);
PushIntConst(dimension);
WriteInstruction("newarr", cilType);
if (arraySymbol.StorageClass == StorageClass.Local)
{
StoreLocal(arraySymbol.Location);
}
else
{
StoreGlobal(arraySymbol);
}
}
/// <summary>
/// Convert a type from the debugger's type system into Iris's type system
/// </summary>
/// <param name="lmrType">LMR Type</param>
/// <returns>Iris type</returns>
public static IrisType GetIrisTypeForLmrType(Type lmrType)
{
if (lmrType.IsPrimitive)
{
switch (lmrType.FullName)
{
case "System.Int32":
return(IrisType.Integer);
case "System.Boolean":
return(IrisType.Boolean);
}
}
else if (lmrType.IsArray)
{
if (lmrType.GetArrayRank() != 1)
{
return(IrisType.Invalid);
}
IrisType elementType = GetIrisTypeForLmrType(lmrType.GetElementType());
if (elementType == IrisType.Invalid)
{
return(IrisType.Invalid);
}
return(elementType.MakeArrayType());
}
else if (lmrType.IsByRef)
{
IrisType elementType = GetIrisTypeForLmrType(lmrType.GetElementType());
if (elementType == IrisType.Invalid)
{
return(IrisType.Invalid);
}
return(elementType.MakeByRefType());
}
else if (lmrType.FullName.Equals("System.String"))
{
return(IrisType.String);
}
// Unknown
return(IrisType.Invalid);
}
public ImportedMethod TryFindMethod(string name, bool instance, IrisType returnType, IrisType[] paramTypes)
{
EnsureMethods();
foreach (ImportedMethod method in _methods)
{
if (method.IsStatic == instance)
{
continue;
}
if (method.ReturnType != returnType)
{
continue;
}
if (!string.Equals(method.Name, name))
{
continue;
}
Variable[] methodParams = method.GetParameters();
if (methodParams.Length != paramTypes.Length)
{
continue;
}
bool match = true;
for (int i = 0; i < paramTypes.Length; i++)
{
if (paramTypes[i] != methodParams[i].Type)
{
match = false;
break;
}
}
if (match)
{
return(method); // Found
}
}
return(null); // Not found
}
private IrisType ProcessArrayAccess(FilePosition fp, Symbol symbol, SymbolLoadMode mode)
{
IrisType symbolType = symbol.Type;
IrisType resultType = IrisType.Invalid;
if (symbolType != IrisType.Invalid)
{
if (!symbolType.IsArray)
{
AddError(fp, string.Format("Symbol '{0}' is not an array, but is being used as an array.", _lexeme));
}
else
{
EmitLoadSymbol(symbol, SymbolLoadMode.Dereference);
resultType = symbol.Type.GetElementType();
}
}
FilePosition indexerPosition = _lexer.TokenStartPosition;
IrisType indexerType = ParseExpression();
if (indexerType != IrisType.Integer)
{
AddError(indexerPosition, "Expecting integer value as array index.");
}
Expect(Token.ChrCloseBracket);
if (resultType != IrisType.Invalid)
{
if (mode == SymbolLoadMode.ElementAddress)
{
MethodGenerator.LoadElementAddress(resultType);
resultType = resultType.MakeByRefType();
}
else if (mode == SymbolLoadMode.Element)
{
MethodGenerator.LoadElement(resultType);
}
}
return(resultType);
}
protected void ParseIf()
{
FilePosition fp = _lexer.TokenStartPosition;
IrisType type = ParseExpression();
VerifyExpressionType(fp, type, IrisType.Boolean);
Expect(Token.KwThen);
int label = GetNextLabel();
MethodGenerator.BranchFalse(label);
MethodGenerator.EndSourceLine(_lastParsedPosition);
ParseStatement();
FilePosition endOfIfStatement = _lastParsedPosition;
FilePosition elseStart = _lexer.TokenStartPosition;
if (Accept(Token.KwElse))
{
int label2 = GetNextLabel();
MethodGenerator.Goto(label2);
MethodGenerator.Label(label);
MethodGenerator.EndSourceLine(endOfIfStatement);
MethodGenerator.BeginSourceLine(elseStart);
if (Accept(Token.KwIf))
{
ParseIf();
}
else
{
MethodGenerator.EmitNonCodeLineInfo(elseStart.Expand(4 /* Length of "else" */));
ParseStatement();
}
MethodGenerator.Label(label2);
}
else
{
MethodGenerator.Label(label);
}
}
private Dictionary <IrisType, List <MathVector> > GetData(List <string> data, bool has_headers = false)
{
var result = new Dictionary <IrisType, List <MathVector> >(3);
for (int i = has_headers ? 1 : 0; i < data.Count; i++)
{
var temp = data[i].Split(',').ToList();
var last = temp.Count - 1;
IrisType currentIrisType = ToIrisTypeConverter.Convert(temp[last]);
if (!result.ContainsKey(currentIrisType))
{
result.Add(currentIrisType, new List <MathVector>()); //Adding new iris type to collection
}
AddListOfValues(result[currentIrisType], temp); //Adding new vector to concrete iris type
}
return(result);
}
/// <summary>
/// This method is called by the debug engine to populate the text representing the type of
/// a result.
/// </summary>
/// <param name="inspectionContext">Context of the evaluation. This contains options/flags
/// to be used during compilation. It also contains the InspectionSession. The inspection
/// session is the object that provides lifetime management for our objects. When the user
/// steps or continues the process, the debug engine will dispose of the inspection session</param>
/// <param name="clrType">This is the raw type we want to format</param>
/// <param name="customTypeInfo">If Expression Compiler passed any additional information
/// about the type that doesn't exist in metadata, this parameter contais that information.</param>
/// <param name="formatSpecifiers">A list of custom format specifiers that the debugger did
/// not understand. If you want special format specifiers for your language, handle them
/// here. The formatter should ignore any format specifiers it does not understand.</param>
/// <returns>The text of the type name to display</returns>
string IDkmClrFormatter.GetTypeName(
DkmInspectionContext inspectionContext,
DkmClrType clrType,
DkmClrCustomTypeInfo customTypeInfo,
ReadOnlyCollection <string> formatSpecifiers)
{
// Get the LMR type for the DkmClrType. LMR Types (Microsoft.VisualStudio.Debugger.Metadata.Type)
// are similar to System.Type, but represent types that live in the process being debugged.
Type lmrType = clrType.GetLmrType();
IrisType irisType = Utility.GetIrisTypeForLmrType(lmrType);
if (irisType == IrisType.Invalid)
{
// We don't know about this type. Delegate to the C# Formatter to format the
// type name.
return(inspectionContext.GetTypeName(clrType, customTypeInfo, formatSpecifiers));
}
return(irisType.ToString());
}
public void BeginMethod(
string name,
IrisType returnType,
Variable[] parameters,
Variable[] locals,
bool entryPoint,
string methodFileName)
{
if (!_outputEnabled)
{
return;
}
_emitter.BeginMethod(name, returnType, parameters, locals.ToArray(), entryPoint);
if (_emitDebugInfo)
{
_emitter.EmitMethodLanguageInfo();
}
_methodFileName = methodFileName;
}
protected IrisType ParseCompareExpression(SymbolLoadMode mode)
{
IrisType lhs = ParseArithmeticExpression(mode);
FilePosition fp = _lexer.TokenStartPosition;
Operator opr = AcceptOperator(OperatorMaps.Instance.Compare);
if (opr != Operator.None)
{
IrisType rhs = ParseCompareExpression(mode);
if (lhs == IrisType.String && rhs == IrisType.String)
{
Symbol strcmp = LookupSymbol(fp, "strcmp");
MethodGenerator.Call(strcmp);
MethodGenerator.PushIntConst(0);
}
MethodGenerator.Operator(opr);
return(ApplyTypeRules(fp, lhs, rhs, boolResult: true));
}
return(lhs);
}
public void BeginMethod(string name, IrisType returnType, Variable[] parameters, Variable[] locals, bool entryPoint)
{
string cilName = string.Format(
"{0} {1}({2})",
IrisTypeToCilTypeName(returnType),
name,
string.Join(", ", parameters.Select(v => IrisVarToCilVar(v))));
WriteIndentedText(string.Format(".method public hidebysig static {0} cil managed", cilName));
WriteIndentedText("{");
_indentLevel++;
if (entryPoint)
{
WriteIndentedText(".entrypoint");
}
if (locals.Length > 0)
{
StringBuilder localsBuilder = new StringBuilder();
localsBuilder.Append(".locals init (");
int localIndex = 0;
foreach (Variable var in locals)
{
if (localIndex != 0)
{
localsBuilder.Append(", ");
}
localsBuilder.AppendFormat("[{0}] {1}", localIndex, IrisVarToCilVar(var));
localIndex++;
}
localsBuilder.Append(")");
WriteIndentedText(localsBuilder.ToString());
}
}
private IrisType ParseExpressionAndReadFormatSpecifiers()
{
// Call the base class to parse the expression.
// Then do our own parsing to handle format specifiers.
IrisType resultType = ParseExpression();
// If no compile errors, look for format specifiers
if (_context.CompileErrors.Count > 0)
{
return(resultType);
}
if (_lexer.CurrentToken == Token.Eof)
{
return(resultType);
}
while (_lexer.CurrentToken == Token.ChrComma)
{
_lexer.MoveNext();
if (_lexer.CurrentToken == Token.Identifier)
{
_context.FormatSpecifiers.Add(_lexer.GetLexeme());
_lexer.MoveNext();
}
else
{
AddErrorAtTokenStart("Invalid format specifier.");
}
}
if (_lexer.CurrentToken != Token.Eof)
{
AddErrorAtTokenStart("Unexpected text after expression.");
}
return(resultType);
}
private IrisType ApplyTypeRules(FilePosition fp, IrisType lhs, IrisType rhs, bool boolResult = false)
{
// If there was a previous semantic error, don't apply any further rules.
if (lhs == IrisType.Invalid || rhs == IrisType.Invalid)
{
return(IrisType.Invalid);
}
string semanticError = null;
if (lhs == IrisType.Void || rhs == IrisType.Void)
{
semanticError = "Cannot apply operator to procedure call.";
}
else if (lhs.IsByRef || rhs.IsByRef)
{
semanticError = "Cannot take address of expression.";
}
else if (lhs != rhs)
{
semanticError = "Type mismatch error.";
}
else if (!lhs.IsPrimitive)
{
semanticError = "Operator requires a primitive type (boolean, integer, or string).";
}
if (semanticError != null)
{
AddError(fp, semanticError);
return(IrisType.Invalid);
}
else
{
return(boolResult ? IrisType.Boolean : lhs);
}
}
public static string ConvertBack(IrisType irisType)
{
string result = "";
switch (irisType)
{
case IrisType.Setosa:
result = "setosa";
break;
case IrisType.Versicolor:
result = "versicolor";
break;
case IrisType.Virginica:
result = "virginica";
break;
case IrisType.None:
result = "None";
break;
}
return(result);
}
public Variable(IrisType type, string name, SubRange subRange)
{
Type = type;
Name = name;
SubRange = subRange;
}
private Method CreateMethodHelper(IrisType returnType, Variable[] parameters)
{
if (returnType == IrisType.Void)
return Procedure.Create(parameters);
else
return Function.Create(returnType, parameters);
}
public void Load(IrisType type)
{
_textEmitter.Load(type);
}
public void LoadElementAddress(IrisType elementType)
{
WriteInstruction("ldelema", IrisTypeToCilTypeName(elementType));
}
public void LoadElementAddress(IrisType elementType)
{
_deferredInstructions.Add(new MethodInstruction(MethodOpCode.LoadElemA, elementType));
}
public void Store(IrisType type)
{
_deferredInstructions.Add(new MethodInstruction(MethodOpCode.Assign, type));
}
public void StoreElement(IrisType elementType)
{
_textEmitter.StoreElement(elementType);
}
public void BeginMethod(string name, IrisType returnType, Variable[] parameters, Variable[] locals, bool entryPoint)
{
_textEmitter.BeginMethod(name, returnType, parameters, locals, entryPoint);
}
private static void Findminmax(int M, int k, int ii, IrisType[] I)
{
int[] l = { 0, 0, 0 };
double min = dataList[M][ii].props[M];
for (int i = ii; i < dataList[M].Count; i++)
{
for (int j = 0; j < I.Length; j++)
{
if (dataList[M][i].Name == I[j].Name)
{
l[j]++;
}
if (l[j] == 3) { k = j; ii = i; break; }
}
if (l[k] == 3)
{
break;
}
}
ii = dr(M, ii, k, I);
if (ii != min)
{
I[k].minmax[M - 1].Add(min);
I[k].minmax[M - 1].Add(dataList[M][ii].props[M]);
}
if (ii + 1 < dataList[M].Count)
{
Findminmax(M, k, ii, I);
}
}
public void Store(IrisType type)
{
_deferredInstructions.Add(new MethodInstruction(MethodOpCode.Assign, type));
}
private static string IrisTypeToCilTypeName(IrisType type)
{
if (type.IsPrimitive)
{
if (type == IrisType.Integer)
return "int32";
else if (type == IrisType.String)
return "string";
else if (type == IrisType.Boolean)
return "bool";
}
else if (type.IsArray)
{
return IrisTypeToCilTypeName(type.GetElementType()) + "[]";
}
else if (type.IsByRef)
{
return IrisTypeToCilTypeName(type.GetElementType()) + "&";
}
else if (type == IrisType.Void)
{
return "void";
}
return "_Unknown";
}
public void StoreElement(IrisType elementType)
{
if (elementType == IrisType.Integer)
WriteInstruction("stelem.i4", null);
else if (elementType == IrisType.Boolean)
WriteInstruction("stelem.i1", null);
else
WriteInstruction("stelem.ref", null);
}
public void LoadElement(IrisType elementType)
{
if (elementType == IrisType.Integer)
WriteInstruction("ldelem.i4", null);
else if (elementType == IrisType.Boolean)
WriteInstruction("ldelem.i1", null);
else
WriteInstruction("ldelem", IrisTypeToCilTypeName(elementType));
}
public void LoadElementAddress(IrisType elementType)
{
_textEmitter.LoadElementAddress(elementType);
}
public void StoreElement(IrisType elementType)
{
_deferredInstructions.Add(new MethodInstruction(MethodOpCode.StoreElem, elementType));
}
public void Load(IrisType type)
{
_deferredInstructions.Add(new MethodInstruction(MethodOpCode.Load, type));
}
public void LoadElementAddress(IrisType elementType)
{
_deferredInstructions.Add(new MethodInstruction(MethodOpCode.LoadElemA, elementType));
}
public void StoreElement(IrisType elementType)
{
_deferredInstructions.Add(new MethodInstruction(MethodOpCode.StoreElem, elementType));
}
public void Load(IrisType type)
{
_deferredInstructions.Add(new MethodInstruction(MethodOpCode.Load, type));
}
public void LoadElement(IrisType elementType)
{
_textEmitter.LoadElement(elementType);
}
public void BeginMethod(
string name,
IrisType returnType,
Variable[] parameters,
Variable[] locals,
bool entryPoint,
string methodFileName)
{
if (!_outputEnabled)
return;
_emitter.BeginMethod(name, returnType, parameters, locals.ToArray(), entryPoint);
if (_emitDebugInfo)
_emitter.EmitMethodLanguageInfo();
_methodFileName = methodFileName;
}
public void BeginMethod(string name, IrisType returnType, Variable[] parameters, Variable[] locals, bool entryPoint)
{
_textEmitter.BeginMethod(name, returnType, parameters, locals, entryPoint);
}
public void StoreElement(IrisType elementType)
{
_textEmitter.StoreElement(elementType);
}
public void Store(IrisType type)
{
_textEmitter.Store(type);
}
public ImportedMethod TryFindMethod(string name, bool instance, IrisType returnType, IrisType[] paramTypes)
{
EnsureMethods();
foreach (ImportedMethod method in _methods)
{
if (method.IsStatic == instance)
continue;
if (method.ReturnType != returnType)
continue;
if (!string.Equals(method.Name, name))
continue;
Variable[] methodParams = method.GetParameters();
if (methodParams.Length != paramTypes.Length)
continue;
bool match = true;
for (int i = 0; i < paramTypes.Length; i++)
{
if (paramTypes[i] != methodParams[i].Type)
{
match = false;
break;
}
}
if (match)
return method; // Found
}
return null; // Not found
}
public void BeginMethod(string name, IrisType returnType, Variable[] parameters, Variable[] locals, bool entryPoint)
{
string cilName = string.Format(
"{0} {1}({2})",
IrisTypeToCilTypeName(returnType),
name,
string.Join(", ", parameters.Select(v => IrisVarToCilVar(v))));
WriteIndentedText(string.Format(".method public hidebysig static {0} cil managed", cilName));
WriteIndentedText("{");
_indentLevel++;
if (entryPoint)
{
WriteIndentedText(".entrypoint");
}
if (locals.Length > 0)
{
StringBuilder localsBuilder = new StringBuilder();
localsBuilder.Append(".locals init (");
int localIndex = 0;
foreach (Variable var in locals)
{
if (localIndex != 0)
localsBuilder.Append(", ");
localsBuilder.AppendFormat("[{0}] {1}", localIndex, IrisVarToCilVar(var));
localIndex++;
}
localsBuilder.Append(")");
WriteIndentedText(localsBuilder.ToString());
}
}
public void Add(string name, IrisType type)
{
_symbols.Add(new Tuple<string, IrisType>(name, type));
}
public void LoadElementAddress(IrisType elementType)
{
WriteInstruction("ldelema", IrisTypeToCilTypeName(elementType));
}
protected void ImportMethod(
FilePosition fp,
string symbolName,
ImportedModule module,
string declaringTypeName,
string methodName,
bool instance,
IrisType returnType,
IrisType[] paramTypes)
{
ImportedType declaringType = module.TryGetTypeByName(declaringTypeName);
if (declaringType == null)
{
CompileErrors.Add(fp, String.Format("Cannot find imported type '{0}'.", declaringTypeName));
return;
}
ImportedMethod importedMethod = declaringType.TryFindMethod(methodName, instance, returnType, paramTypes);
if (importedMethod == null)
{
CompileErrors.Add(fp, String.Format("Cannot find imported function or procedure '{0}.{1}'.", declaringTypeName, methodName));
return;
}
Method method = importedMethod.ConvertToIrisMethod();
bool containsInvalidType = method.ReturnType == IrisType.Invalid;
foreach (Variable param in method.GetParameters())
{
if (containsInvalidType)
break;
if (param.Type == IrisType.Invalid)
containsInvalidType = true;
}
if (containsInvalidType)
CompileErrors.Add(fp, String.Format("The function or procedure '{0}.{1}' contains types that are not supported by the language.", declaringTypeName, methodName));
else
SymbolTable.Add(symbolName, method, StorageClass.Global, importedMethod);
}
public void Store(IrisType type)
{
if (type == IrisType.Boolean)
WriteInstruction("stind.i1", null);
else if (type == IrisType.Integer)
WriteInstruction("stind.i4", null);
else
WriteInstruction("stind.ref", null);
}
/// <summary>
/// Add intrinsic methods and globals to the symbol table
/// </summary>
public void AddIntrinsics()
{
ImportedModule mscorlib = ReferenceMscorlib();
ImportedModule runtime = ReferenceExternal("IrisRuntime.dll");
IrisType tVoid = IrisType.Void;
IrisType tString = IrisType.String;
IrisType tInt = IrisType.Integer;
IrisType[] noParams = new IrisType[0];
FilePosition fp = FilePosition.Begin;
if (mscorlib != null)
{
ImportGlobalField(fp, "$.emptystr", mscorlib, "System.String", "Empty");
ImportMethod(fp, "concat", mscorlib, "System.String", "Concat", false, tString, new IrisType[] { tString, tString });
ImportMethod(fp, "readln", mscorlib, "System.Console", "ReadLine", false, tString, noParams);
ImportMethod(fp, "str", mscorlib, "System.Int32", "ToString", true, tString, noParams);
ImportMethod(fp, "strcmp", mscorlib, "System.String", "Compare", false, tInt, new IrisType[] { tString, tString });
ImportMethod(fp, "writeln", mscorlib, "System.Console", "WriteLine", false, tVoid, new IrisType[] { tString });
}
if (runtime != null)
{
ImportMethod(fp, "$.initstrarray", runtime, "IrisRuntime.CompilerServices", "InitStrArray", false, tVoid, new IrisType[] { IrisType.String.MakeArrayType() });
ImportMethod(fp, "rand", runtime, "IrisRuntime.CompilerServices", "Rand", false, tInt, noParams);
}
}
private static string TryGetFrameNameHelper(DkmInspectionContext inspectionContext, DkmStackWalkFrame frame, DkmVariableInfoFlags argumentFlags)
{
ImportedMethod currentMethod = TryGetCurrentMethod(inspectionContext, frame);
if (currentMethod == null)
{
return(null);
}
string name = currentMethod.Name;
if (string.Equals(name, "$.main", StringComparison.Ordinal))
{
return("<Main Block>");
}
if (argumentFlags == DkmVariableInfoFlags.None)
{
return(name);
}
Variable[] args = currentMethod.GetParameters();
if (args.Length == 0)
{
return(name);
}
StringBuilder nameBuilder = new StringBuilder();
nameBuilder.Append(name);
nameBuilder.Append('(');
bool first = true;
bool showTypes = argumentFlags.HasFlag(DkmVariableInfoFlags.Types);
bool showNames = argumentFlags.HasFlag(DkmVariableInfoFlags.Names);
foreach (Variable arg in args)
{
if (first)
{
first = false;
}
else
{
nameBuilder.Append("; ");
}
IrisType argType = arg.Type;
if (argType.IsByRef)
{
nameBuilder.Append("var ");
argType = argType.GetElementType();
}
if (showNames)
{
nameBuilder.Append(arg.Name);
}
if (showNames && showTypes)
{
nameBuilder.Append(" : ");
}
if (showTypes)
{
nameBuilder.Append(argType);
}
}
nameBuilder.Append(')');
return(nameBuilder.ToString());
}
public void LoadElementAddress(IrisType elementType)
{
_textEmitter.LoadElementAddress(elementType);
}
private static int dr(int M, int ii, int k, IrisType[] I)
{
if ((ii + 1 < dataList[M].Count) && (dataList[M][ii + 1].Name == I[k].Name))
{
ii++;
ii = dr(M, ii, k, I);
}
return ii;
}
public void Store(IrisType type)
{
_textEmitter.Store(type);
}
