public void ExtendedConstructor_FileNotFoundException()
{
const string msg = "Test MSG";
const string path = "Test PATH";
try
{
Raise <FileNotFoundException> .If(false, msg, path);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
try
{
Raise <FileNotFoundException> .If(true, msg, path);
}
catch (FileNotFoundException fex)
{
Assert.That(fex.Message, Is.EqualTo(msg));
Assert.That(fex.FileName, Is.EqualTo(path));
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
StructType GetStructType(string name)
{
name = name.ToLower();
Raise <TypeCheckException> .If(!_structTypes.ContainsKey(name), "Type does not exist.");
return(_structTypes[name]);
}
public void ExtendedConstructor_BigCtorException()
{
var x = 3;
var y = decimal.MinValue;
var z = "ZZZ";
var t = new KeyValuePair <string, string>(z, z + z);
try
{
Raise <BigCtorException> .If(false, x, y, z, t);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
try
{
Raise <BigCtorException> .If(true, x, y, z, t);
}
catch (BigCtorException fex)
{
Assert.That(fex.Message, Is.EqualTo(x.ToString()));
Assert.That(fex.X, Is.EqualTo(x));
Assert.That(fex.Y, Is.EqualTo(y));
Assert.That(fex.Z, Is.EqualTo(z));
Assert.That(fex.T, Is.EqualTo(t));
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
StructType AddStructType(StructDecl decl)
{
var name = decl.Name.ToLower();
Raise <TypeCheckException> .If(_types.ContainsKey(name));
const string nmsp = "DanglingLang.Runner";
const TypeAttributes typeAttr =
TypeAttributes.Sealed | TypeAttributes.Public | TypeAttributes.AnsiClass |
TypeAttributes.BeforeFieldInit | TypeAttributes.SequentialLayout;
var typeDef = new TypeDefinition(nmsp, name, typeAttr, Module.Import(typeof(object)));
var type = new StructType(name, typeDef);
foreach (var f in decl.Fields)
{
var fieldType = GetType(f.Item2);
Raise <TypeCheckException> .IfAreEqual("void", fieldType.Name, "Field cannot be void");
type.AddField(f.Item1, fieldType);
}
_types.Add(name, type);
_structTypes.Add(name, type);
return(type);
}
/// <summary>
/// Deposits given amount into the bank.
/// </summary>
/// <param name="amount">A positive amount of money.</param>
/// <exception cref="ArgumentOutOfRangeException">Amount is zero or negative.</exception>
/// <exception cref="InvalidOperationException">Bank is closed.</exception>
/// <exception cref="OverNineThousandException">Amount is over nine thousand!</exception>
public void Deposit(decimal amount)
{
// Preconditions
Raise.InvalidOperationException.IfNot(_isOpen, "Bank is still closed");
Raise.ArgumentOutOfRangeException.IfIsLessOrEqual(amount, 0, nameof(amount), "Zero or negative amount");
Raise <OverNineThousandException> .If(amount > 9000M, "You are too rich!");
Amount += amount;
}
public FieldInfo AddField(string name, Type type)
{
Raise <TypeCheckException> .If(_fields.Any(f => f.Name == name), "Field with existing name");
var fieldInfo = new FieldInfo(name, type);
_fields.Add(fieldInfo);
return(fieldInfo);
}
public void Visit(Block block)
{
foreach (var s in block.Statements)
{
Raise <ReturnCheckException> .If(_foundReturn, "There must be no stmts after return");
s.Accept(this);
}
}
public VarInfo AddVariable(string name, Type type)
{
Raise <ArgumentException> .If(_variables.Any(v => v.Name == name));
var varInfo = new VarInfo(name, type);
_variables.Add(varInfo);
return(varInfo);
}
public ParamInfo AddParam(string name, string typeName)
{
Raise <ArgumentException> .If(_params.Any(p => p.Name == name));
var paramInfo = new ParamInfo(name, typeName);
_params.Add(paramInfo);
return(paramInfo);
}
Type AddType(string name, TypeReference reference)
{
name = name.ToLower();
Raise <TypeCheckException> .If(_types.ContainsKey(name), "Type already existing.");
var type = new Type(name, reference);
_types.Add(name, type);
return(type);
}
// Math methods
public static int Fact(int n)
{
Raise <ArgumentOutOfRangeException> .If(n < 0);
var result = n;
for (; n > 2; result *= --n)
{
}
return(result > 1 ? result : 1);
}
void LoadType(TypeDefinition typeDef)
{
Raise <TypeCheckException> .If(_structTypes.ContainsKey(typeDef.Name), "There is a type with the same name!");
var typeRef = Module.Import(typeDef);
var structType = new StructType(typeRef.Name, typeRef);
structType.Ctor = Module.Import(typeDef.Methods.First(m => m.Name == ".ctor"));
structType.TypeEquals = Module.Import(typeDef.Methods.First(m => m.Name == "MyEquals"));
_types.Add(typeRef.Name, structType);
_structTypes.Add(typeRef.Name, structType);
}
public void ExceptionPrivateConstructor3()
{
try
{
Raise <PrivateCtorException> .If(true, "msg");
Assert.Fail();
}
catch (ThrowerException)
{
Should.Throw <ThrowerException>(() => Raise <PrivateCtorException> .If(true, "msg"));
}
}
public Exception RaiseGeneric()
{
try
{
var b = Identity(Rnd.Next() % 2 == 0);
Raise <NotSupportedException> .If(b, nameof(RaiseVsThrow_NotSupportedException));
}
catch (Exception ex)
{
return(ex);
}
return(default(Exception));
}
public Exception RaiseGeneric()
{
try
{
var nullString = Identity <string>(null);
Raise <ArgumentNullException> .If(nullString == null, nameof(nullString));
}
catch (Exception ex)
{
return(ex);
}
return(default(Exception));
}
public Exception RaiseGeneric()
{
try
{
var x = Identity(21);
var y = Identity(3);
Raise <ArgumentOutOfRangeException> .If(x >= y, nameof(x));
}
catch (Exception ex)
{
return(ex);
}
return(default(Exception));
}
public void Visit(FunctionDecl funcDecl)
{
var oldRet = _foundReturn;
_foundReturn = false;
funcDecl.Body.Accept(this);
Raise <ReturnCheckException> .If(!_foundReturn && funcDecl.ReturnTypeName != "void");
if (!_foundReturn && funcDecl.ReturnTypeName == "void")
{
funcDecl.RequiresExplicitReturn = true;
}
_foundReturn = oldRet;
}
public void ExceptionInternalConstructor3()
{
try
{
Raise <ThrowerException> .If(true, "A RANDOM MSG");
Assert.Fail();
}
catch (ThrowerException ex)
{
Assert.AreNotEqual("A RANDOM MSG", ex.Message);
Assert.Pass();
}
}
public void InvalidOperationException_WithMsg()
{
try
{
Raise <InvalidOperationException> .If(true, "Pino");
Assert.Fail();
}
catch (InvalidOperationException ex)
{
Assert.AreEqual("Pino", ex.Message);
Assert.Pass();
}
}
public void ArgumentNullException_WithMsg()
{
try
{
Raise <ArgumentNullException> .If(true, "Pino");
Assert.Fail();
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("Pino", ex.Message);
Assert.Pass();
}
}
public void ExtendedConstructor_TooManyArgs()
{
try
{
Raise <ArgumentException> .If(true, 1, "snau", 3.14M);
}
catch (ArgumentException aex)
{
Assert.Pass(aex.Message);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
private static void WrongThreadTest()
{
for (var i = 0; i < 10000; ++i)
{
var msg = i.ToString(CultureInfo.InvariantCulture);
try
{
Raise <NoCtorException> .If(true, msg);
}
catch (ThrowerException ex)
{
Assert.AreNotEqual(msg, ex.Message);
}
}
}
public static CallResult InvokeUnmanagedFunction(CallData callData)
{
Type dllHandle = CreateTypeBuilder(callData);
MethodInfo methodInfo = dllHandle.GetMethod(callData.ProcedureName);
Raise <LegacyWrapperException> .If(methodInfo == null, $"Requested method {callData.ProcedureName} was not found in unmanaged DLL.");
object result = methodInfo.Invoke(null, callData.Parameters);
return(new CallResult()
{
Result = result,
Parameters = callData.Parameters
});
}
public void Visit(FunctionCall fc)
{
Raise <TypeCheckException> .If(!_funcDecls.ContainsKey(fc.FunctionName), "Function not existing");
var fd = _funcDecls[fc.FunctionName];
Raise <TypeCheckException> .IfAreNotEqual(fc.Arguments.Count, fd.Params.Count, "Wrong argument count!");
for (var i = 0; i < fd.Params.Count; ++i)
{
fc.Arguments[i].Accept(this);
Raise <TypeCheckException> .IfAreNotSame(fc.Arguments[i].Type, fd.Params[i].Type, "Wrong parameter type");
}
fc.Function = fd;
fc.Type = _result = fd.ReturnType;
}
void LoadFunc(MethodReference funcDef)
{
Raise <TypeCheckException> .If(_funcDecls.ContainsKey(funcDef.Name));
var funcRef = Module.Import(funcDef);
var funcDecl = new FunctionDecl();
funcDecl.Name = funcRef.Name;
funcDecl.ReturnType = GetType(funcRef.ReturnType.Name);
funcDecl.ReturnTypeName = funcDecl.ReturnType.Name;
funcDecl.Reference = funcRef;
foreach (var p in funcDef.Parameters)
{
var paramType = GetType(p.ParameterType.Name);
var paramInfo = funcDecl.AddParam(p.Name, paramType.Name);
paramInfo.Type = paramType;
paramInfo.Reference = p;
}
_funcDecls.Add(funcDef.Name, funcDecl);
}
static int Main(string[] args)
{
try {
Raise <Exception> .If(args.Length == 0 || args.Length > 2, "Wrong argument count!");
Raise <Exception> .If(args.Length == 2 && args[0] != "-e", "Wrong flag!");
if (args.Length == 2)
{
var output = Compile(args[1]);
Execute(output);
}
else
{
Compile(args[0]);
}
} catch (Exception ex) {
Console.WriteLine();
Console.WriteLine("ERROR: {0}", ex.Message);
return(1);
}
return(0);
}
public void Visit(FunctionDecl funcDecl)
{
Raise <TypeCheckException> .If(_funcDecls.ContainsKey(funcDecl.Name), "Function with existing name!");
funcDecl.ReturnType = GetType(funcDecl.ReturnTypeName);
var previousStaticEnv = _staticEnv;
_staticEnv = new StaticEnv(new OutmostStaticEnv());
foreach (var p in funcDecl.Params)
{
p.Type = GetType(p.TypeName);
Raise <TypeCheckException> .IfAreSame(p.Type, _voidType, "Struct fields cannot be void");
var vInfo = new StaticEnvBase.VarInfo(p.Name, p.Type, StaticEnvBase.Kind.Param, p);
_staticEnv.SetVariable(p.Name, vInfo);
}
_funcDecls.Add(funcDecl.Name, funcDecl); // Must be put here to allow recursion...
var prevFunc = _currFunc;
_currFunc = funcDecl;
funcDecl.Body.Accept(this);
_currFunc = prevFunc;
_staticEnv = previousStaticEnv;
}
public static int Pow(int b, int e)
{
Raise <ArgumentOutOfRangeException> .If(e < 0);
return((int)Math.Pow(b, e));
}
public void Visit(Return ret)
{
Raise <ReturnCheckException> .If(_foundReturn, "Two or more returns in same block");
_foundReturn = true;
}
public void Visit(Print print)
{
print.Exp.Accept(this);
Raise <TypeCheckException> .If(print.Exp.Type != _intType && print.Exp.Type != _boolType);
}