/// <summary> /// Read COM port /// </summary> /// <returns></returns> public string ReadCOM() { int count = Port.BytesToRead; byte[] msg = new byte[count]; string MSG = ""; try { if (!Port.IsOpen) { OpenCOM(Port.PortName); } if (Port.IsOpen) { Port.Read(msg, 0, count); Port.DiscardInBuffer(); MSG = Port.Encoding.GetString(msg); } } catch (Exception e) { SLConstant.ShowException(e); } return(MSG); }
/// <summary> /// Write COM port /// </summary> /// <param name="text"></param> /// <returns></returns> public bool WriteCOM(string text) { bool success = false; try { if (!Port.IsOpen) { OpenCOM(Port.PortName); } if (Port.IsOpen) { Port.WriteLine(text); Port.DiscardOutBuffer(); success = true; } } catch (Exception e) { SLConstant.ShowException(e); } return(success); }
public void SimpleLet() { SLLine line = SLDeclaration.LetLine("foo", SLSimpleType.Int, SLConstant.Val(5), Visibility.Public); string code = CodeWriter.WriteToString(line); Compiler.CompileStringUsing(null, XCodeCompiler.SwiftcCustom, code, null); }
void FuncReturningFoo(SLType type, SLConstant val) { SLLine line = SLReturn.ReturnLine(val); SLCodeBlock block = new SLCodeBlock(new ICodeElement [] { line }); SLFunc func = new SLFunc(Visibility.Public, type, new SLIdentifier("simpleFunc"), null, block); string code = CodeWriter.WriteToString(func); Compiler.CompileStringUsing(null, XCodeCompiler.SwiftcCustom, code, null); }
public void TestLetInt() { BindToValue(true, SLSimpleType.Int, SLConstant.Val(42), Visibility.Public); BindToValue(false, SLSimpleType.Int, SLConstant.Val(42), Visibility.Public); BindToValue(true, SLSimpleType.Int, SLConstant.Val(42), Visibility.Private); BindToValue(false, SLSimpleType.Int, SLConstant.Val(42), Visibility.Private); BindToValue(true, SLSimpleType.Int, SLConstant.Val(42), Visibility.Internal); BindToValue(false, SLSimpleType.Int, SLConstant.Val(42), Visibility.Internal); BindToValue(true, SLSimpleType.Int, SLConstant.Val(42), Visibility.None); BindToValue(false, SLSimpleType.Int, SLConstant.Val(42), Visibility.None); }
/// <summary> /// Creates a new object that is a copy of the current instance /// </summary> /// <returns></returns> public override object Clone() { if (gdRef != null) { return(new Primitive(distance2Display, displayRatio, displaySize, globalCamera, unit, gdRef, Para)); } else { SLConstant.ShowMessage("No Internal GraphicsDevice Reference, Please InitVS(GraphicsDevice gd) First !"); return("No gdRef"); } }
/// <summary> /// Creates a new object that is a copy of the current instance /// </summary> /// <returns></returns> public override object Clone() { if (gdRef != null) { return(new Text(distance2Display, displayRatio, displaySize, globalCamera, unit, gdRef, contentManager.ServiceProvider, contentManager.RootDirectory, Para)); } else { SLConstant.ShowMessage("No Internal GraphicsDevice Reference, Please InitVS(GraphicsDevice gd) First !"); return("No gdRef"); } }
/// <summary> /// SerialDataReceived EventHandler Delegate /// </summary> /// <param name="sender"></param> /// <param name="e"></param> protected virtual void DataReceived(object sender, SerialDataReceivedEventArgs e) { newReceivedData = ""; try { newReceivedData = Port.ReadExisting(); receivedDataLength += newReceivedData.Length; } catch (Exception ex) { SLConstant.ShowException(ex); } }
/// <summary> /// Open a COM port with custom parameters /// </summary> /// <param name="portName"></param> /// <param name="readTimeout">0: InfiniteTimeout(ms)</param> /// <param name="writeTimeout">0: InfiniteTimeout(ms)</param> /// <param name="baudRate"></param> /// <param name="parity"></param> /// <param name="dataBits"></param> /// <param name="stopBits"></param> /// <param name="handShake"></param> /// <returns></returns> public bool OpenCOM(string portName, int readTimeout, int writeTimeout, int baudRate, Parity parity, int dataBits, StopBits stopBits, Handshake handShake) { bool hr = false; try { if (isCOMExist) { if (!Port.IsOpen) { if (readTimeout > 0) { Port.ReadTimeout = readTimeout; } else { Port.ReadTimeout = SerialPort.InfiniteTimeout; } if (writeTimeout > 0) { Port.WriteTimeout = writeTimeout; } else { Port.WriteTimeout = SerialPort.InfiniteTimeout; } Port.PortName = portName; Port.BaudRate = baudRate; Port.Parity = parity; Port.DataBits = dataBits; Port.StopBits = stopBits; Port.Handshake = handShake; Port.DataReceived += DataReceivedEventHandler; Port.ErrorReceived += ErrorReceivedEventHandler; Port.PinChanged += PinChangedEventHandler; Port.Open(); hr = true; } } } catch (Exception e) { SLConstant.ShowException(e); } return(hr); }
/// <summary> /// Close current port /// </summary> public void CloseCOM() { try { if (Port.IsOpen) { Port.Close(); } } catch (Exception e) { SLConstant.ShowException(e); } }
/// <summary> /// Init Each Element of Collection According to StiLib Configuration, Custom Vision Stimulus Type and Parameters Object /// </summary> /// <param name="count"></param> /// <param name="vstype"></param> /// <param name="gd"></param> /// <param name="slconfig"></param> /// <param name="service"></param> /// <param name="path"></param> /// <param name="vspara"></param> public virtual void Init(int count, VSType vstype, GraphicsDevice gd, AssemblySettings slconfig, IServiceProvider service, string path, object vspara) { vsType temp = null; try { switch (vstype) { case VSType.Bar: temp = new Bar(gd, slconfig, (BarPara)vspara) as vsType; break; case VSType.Grating: temp = new Grating(gd, slconfig, service, path, (GratingPara)vspara) as vsType; break; case VSType.Image: temp = new Image(gd, slconfig, service, path, (ImagePara)vspara) as vsType; break; case VSType.Primitive: temp = new Primitive(gd, slconfig, (PrimitivePara)vspara) as vsType; break; case VSType.SLModel: temp = new SLModel(gd, slconfig, service, path, (ModelPara)vspara) as vsType; break; case VSType.SLQuad: temp = new SLQuad(gd, slconfig, service, path, (Quad)vspara) as vsType; break; case VSType.SLVideo: temp = new SLVideo(gd, slconfig, service, path, (VideoPara)vspara) as vsType; break; case VSType.Text: temp = new Text(gd, slconfig, service, path, (TextPara)vspara) as vsType; break; } Init(count, gd, temp); } catch (Exception e) { SLConstant.ShowException(e); } }
/// <summary> /// Log message string /// </summary> /// <param name="info"></param> public void Log(string info) { try { message.Append(DateTime.Now.ToString()).Append(" --- ").Append(info); writer.WriteLine(message.ToString()); writer.Flush(); } catch (Exception e) { SLConstant.ShowException(e); } finally { message.Remove(0, message.Length); } }
/// <summary> /// Linearize Gamma According to Current Gamma Value Using GraphicsDevice GammaRamp /// </summary> /// <param name="gamma">current R, G, B gamma value</param> public void SetGamma(Vector3 gamma) { bool isfullscreengamma; GraphicsDeviceCapabilities gdcap = gd.GraphicsDeviceCapabilities; if (gdcap.DriverCapabilities.SupportsFullScreenGamma) { isfullscreengamma = true; } else { isfullscreengamma = false; SLConstant.ShowMessage("This GraphicsDevice Does Not Support Full Screen Gamma Correction !"); } if (isfullscreengamma && gd.PresentationParameters.IsFullScreen && (gamma.X != 1.0f || gamma.Y != 1.0f || gamma.Z != 1.0f)) { gd.SetGammaRamp(false, SLAlgorithm.GetGamma(gamma)); } }
/// <summary> /// Linearize Gamma According to Current Gamma Value Using GraphicsDevice GammaRamp /// </summary> /// <param name="gamma">current R, G, B gamma value</param> public void SetGamma(Vector3 gamma) { bool isfullscreengamma; GraphicsDeviceCapabilities gdcap = GraphicsAdapter.DefaultAdapter.GetCapabilities(DeviceType.Hardware); if (gdcap.DriverCapabilities.SupportsFullScreenGamma) { isfullscreengamma = true; } else { isfullscreengamma = false; SLConstant.ShowMessage("This Adapter Does Not Support Full Screen Gamma Correction !"); } if (isfullscreengamma && gdm.IsFullScreen && (gamma.X != 1.0f || gamma.Y != 1.0f || gamma.Z != 1.0f)) { gdm.GraphicsDevice.SetGammaRamp(false, SLAlgorithm.GetGamma(gamma)); this.gamma = gamma; } }
public static SLBaseExpr operator >>(SLBaseExpr lhs, int bits) { return(new SLBinaryExpr(BinaryOp.RightShift, lhs, SLConstant.Val(bits))); }
public void FuncReturningInt() { FuncReturningFoo(SLSimpleType.Int, SLConstant.Val(4)); }
SLBaseExpr MarshalTupleTypeSpec(BaseDeclaration declContext, string name, TupleTypeSpec tuple) { var bindingName = new SLIdentifier(MarshalEngine.Uniqueify(name, identifiersUsed)); var argType = typeMapper.TypeSpecMapper.MapType(declContext, imports, tuple, false); var ptrType = new SLBoundGenericType("UnsafeMutablePointer", argType); identifiersUsed.Add(bindingName.Name); var decl = new SLDeclaration(true, bindingName, ptrType, new SLFunctionCall(ptrType + ".allocate", false, new SLArgument(new SLIdentifier("capacity"), SLConstant.Val(1), true)), Visibility.None, false); var varBinding = new SLLine(decl); preMarshalCode.Add(varBinding); var initCall = SLFunctionCall.FunctionCallLine(bindingName.Name + ".initialize", new SLArgument(new SLIdentifier("to"), new SLIdentifier(name), true)); preMarshalCode.Add(initCall); imports.AddIfNotPresent("XamGlue"); if (tuple.IsInOut) { postMarshalCode.Add(new SLLine(new SLBinding(name, bindingName.Dot(new SLIdentifier("pointee"))))); } return(new SLFunctionCall("toIntPtr", false, new SLArgument(new SLIdentifier("value"), bindingName, true))); }
public IEnumerable <ICodeElement> MarshalFunctionCall(FunctionDeclaration func, string vtableName, string vtableElementName) { preMarshalCode.Clear(); postMarshalCode.Clear(); ICodeElement returnLine = null; var instanceEntity = typeMapper.GetEntityForTypeSpec(func.ParameterLists [0] [0].TypeSpec); bool instanceIsProtocol = instanceEntity.EntityType == EntityType.Protocol; // bool returnIsGeneric = func.ReturnTypeSpec != null && func.IsGenericType(func.ReturnTypeSpec); SLIdentifier returnIdent = null; if (func.ParameterLists.Count != 2) { throw new ArgumentException(String.Format("Method {0} is has {1} parameter lists - it should really have two (normal for an instance method).", func.ToFullyQualifiedName(true), func.ParameterLists.Count)); } var closureArgs = new List <SLBaseExpr> (); // marshal the regular arguments for (int i = 0; i < func.ParameterLists [1].Count; i++) { var parm = func.ParameterLists [1] [i]; var privateName = !String.IsNullOrEmpty(parm.PrivateName) ? parm.PrivateName : TypeSpecToSLType.ConjureIdentifier(null, i).Name; if (func.IsTypeSpecGeneric(parm)) { Tuple <int, int> depthIndex = func.GetGenericDepthAndIndex(parm.TypeSpec); closureArgs.Add(MarshalGenericTypeSpec(func, privateName, parm.TypeSpec as NamedTypeSpec, depthIndex.Item1, depthIndex.Item2)); } else { closureArgs.Add(MarshalTypeSpec(func, privateName, parm.TypeSpec)); } } string callName = String.Format("{0}.{1}", vtableName, vtableElementName); var callInvocation = new SLPostBang(new SLIdentifier(callName), false); if (instanceIsProtocol) { string protoName = MarshalEngine.Uniqueify("selfProto", identifiersUsed); identifiersUsed.Add(protoName); var selfProtoDecl = new SLDeclaration(false, new SLBinding(protoName, new SLIdentifier("self"), new SLSimpleType(func.ParameterLists [0] [0].TypeName.NameWithoutModule())), Visibility.None); preMarshalCode.Add(new SLLine(selfProtoDecl)); closureArgs.Insert(0, new SLAddressOf(new SLIdentifier(protoName), false)); } else { // add self as a parameter imports.AddIfNotPresent("XamGlue"); closureArgs.Insert(0, new SLFunctionCall("toIntPtr", false, new SLArgument(new SLIdentifier("value"), new SLIdentifier("self"), true))); } string throwReturnName = null; SLIdentifier throwReturn = null; SLType throwReturnType = null; throwReturnType = new SLTupleType( new SLNameTypePair(SLParameterKind.None, "_", func.ReturnTypeSpec == null || func.ReturnTypeSpec.IsEmptyTuple ? SLSimpleType.Void : typeMapper.TypeSpecMapper.MapType(func, imports, func.ReturnTypeSpec, true)), new SLNameTypePair(SLParameterKind.None, "_", new SLSimpleType("Swift.Error")), new SLNameTypePair(SLParameterKind.None, "_", new SLSimpleType("Bool"))); if (func.HasThrows) { throwReturnName = MarshalEngine.Uniqueify("retval", identifiersUsed); identifiersUsed.Add(throwReturnName); throwReturn = new SLIdentifier(throwReturnName); imports.AddIfNotPresent("XamGlue"); // FIXME for generics var throwReturnDecl = new SLDeclaration(true, new SLBinding(throwReturn, new SLFunctionCall(String.Format("UnsafeMutablePointer<{0}>.allocate", throwReturnType.ToString()), false, new SLArgument(new SLIdentifier("capacity"), SLConstant.Val(1), true))), Visibility.None); closureArgs.Insert(0, new SLFunctionCall("toIntPtr", false, new SLArgument(new SLIdentifier("value"), throwReturn, true))); preMarshalCode.Add(new SLLine(throwReturnDecl)); } if (func.HasThrows) { returnLine = new SLLine(new SLNamedClosureCall(callInvocation, new CommaListElementCollection <SLBaseExpr> (closureArgs))); string errName = MarshalEngine.Uniqueify("err", identifiersUsed); identifiersUsed.Add(errName); var errIdent = new SLIdentifier(errName); var errDecl = new SLDeclaration(true, new SLBinding(errIdent, new SLFunctionCall("getExceptionThrown", false, new SLArgument(new SLIdentifier("retval"), throwReturn, true))), Visibility.None); postMarshalCode.Add(new SLLine(errDecl)); var ifblock = new SLCodeBlock(null); SLCodeBlock elseblock = null; ifblock.Add(SLFunctionCall.FunctionCallLine($"{throwReturnName}.deinitialize", new SLArgument(new SLIdentifier("count"), SLConstant.Val(1), true))); ifblock.Add(SLFunctionCall.FunctionCallLine($"{throwReturnName}.deallocate")); ifblock.Add(new SLLine(new SLThrow(new SLPostBang(errIdent, false)))); if (func.ReturnTypeSpec != null && !func.ReturnTypeSpec.IsEmptyTuple) { elseblock = new SLCodeBlock(null); string retvalvalName = MarshalEngine.Uniqueify("retvalval", identifiersUsed); identifiersUsed.Add(retvalvalName); SLIdentifier retvalval = new SLIdentifier(retvalvalName); string tuplecracker = "getExceptionNotThrown"; var retvalvaldecl = new SLDeclaration(true, new SLBinding(retvalval, new SLFunctionCall(tuplecracker, false, new SLArgument(new SLIdentifier("retval"), throwReturn, true))), Visibility.None); elseblock.Add(new SLLine(retvalvaldecl)); elseblock.Add(SLFunctionCall.FunctionCallLine($"{throwReturnName}.deallocate")); ISLExpr returnExpr = new SLPostBang(retvalval, false); elseblock.Add(SLReturn.ReturnLine(returnExpr)); } postMarshalCode.Add(new SLIfElse(new SLBinaryExpr(BinaryOp.NotEqual, errIdent, SLConstant.Nil), ifblock, elseblock)); } else { if (func.ReturnTypeSpec == null || func.ReturnTypeSpec.IsEmptyTuple) { // On no return value // _vtable.entry!(args) // returnLine = new SLLine(new SLNamedClosureCall(callInvocation, new CommaListElementCollection <SLBaseExpr> (closureArgs))); } else { if (TypeSpec.IsBuiltInValueType(func.ReturnTypeSpec)) { // on simple return types (Int, UInt, Bool, etc) // return _vtable.entry!(args) // var closureCall = new SLNamedClosureCall(callInvocation, new CommaListElementCollection <SLBaseExpr> (closureArgs)); if (postMarshalCode.Count == 0) { returnLine = SLReturn.ReturnLine(closureCall); } else { returnIdent = new SLIdentifier(MarshalEngine.Uniqueify("retval", identifiersUsed)); identifiersUsed.Add(returnIdent.Name); var retvalDecl = new SLDeclaration(true, returnIdent, null, closureCall, Visibility.None); returnLine = new SLLine(retvalDecl); postMarshalCode.Add(SLReturn.ReturnLine(returnIdent)); } } else { if (func.IsTypeSpecGeneric(func.ReturnTypeSpec)) { imports.AddIfNotPresent("XamGlue"); // dealing with a generic here. // UnsafeMutablePointer<T> retval = UnsafeMutablePointer<T>.alloc(1) // someCall(toIntPtr(retval), ...) // T actualRetval = retval.move() // retval.dealloc(1) // return actualRetval returnIdent = new SLIdentifier(MarshalEngine.Uniqueify("retval", identifiersUsed)); identifiersUsed.Add(returnIdent.Name); Tuple <int, int> depthIndex = func.GetGenericDepthAndIndex(func.ReturnTypeSpec); var retvalDecl = new SLDeclaration(true, returnIdent, null, new SLFunctionCall(String.Format("UnsafeMutablePointer<{0}>.allocate", SLGenericReferenceType.DefaultNamer(depthIndex.Item1, depthIndex.Item2)), false, new SLArgument(new SLIdentifier("capacity"), SLConstant.Val(1), true)), Visibility.None); preMarshalCode.Add(new SLLine(retvalDecl)); closureArgs.Insert(0, new SLFunctionCall("toIntPtr", false, new SLArgument(new SLIdentifier("value"), returnIdent, true))); SLIdentifier actualReturnIdent = new SLIdentifier(MarshalEngine.Uniqueify("actualRetval", identifiersUsed)); identifiersUsed.Add(actualReturnIdent.Name); returnLine = new SLLine(new SLNamedClosureCall(callInvocation, new CommaListElementCollection <SLBaseExpr> (closureArgs))); var actualRetvalDecl = new SLDeclaration(true, actualReturnIdent, null, new SLFunctionCall(String.Format("{0}.move", returnIdent.Name), false), Visibility.None); postMarshalCode.Add(new SLLine(actualRetvalDecl)); postMarshalCode.Add(SLFunctionCall.FunctionCallLine(String.Format("{0}.deallocate", returnIdent.Name))); postMarshalCode.Add(SLReturn.ReturnLine(actualReturnIdent)); } else if (NamedSpecIsClass(func.ReturnTypeSpec as NamedTypeSpec)) { // class (not struct or enum) return type is a pointer // if we have no post marshal code: // return fromIntPtr(_vtable.entry!(args)) // if we have post marshal code: // let retval:returnType = fromIntPtr(_vtable.entry!(args)) // ... post marshal code // return retval; imports.AddIfNotPresent("XamGlue"); SLBaseExpr callExpr = new SLFunctionCall("fromIntPtr", false, new SLArgument(new SLIdentifier("ptr"), new SLNamedClosureCall(callInvocation, new CommaListElementCollection <SLBaseExpr> (closureArgs)), true)); if (postMarshalCode.Count > 0) { string retvalName = MarshalEngine.Uniqueify("retval", identifiersUsed); var retDecl = new SLDeclaration(true, retvalName, typeMapper.TypeSpecMapper.MapType(func, imports, func.ReturnTypeSpec, true), callExpr); returnLine = new SLLine(retDecl); postMarshalCode.Add(SLReturn.ReturnLine(new SLIdentifier(retvalName))); } else { returnLine = SLReturn.ReturnLine(callExpr); } } else { var entity = typeMapper.GetEntityForTypeSpec(func.ReturnTypeSpec); if (func.ReturnTypeSpec is NamedTypeSpec && entity == null) { throw new NotImplementedException($"Function {func.ToFullyQualifiedName (true)} has an unknown return type {func.ReturnTypeSpec.ToString ()}"); } if (entity?.EntityType == EntityType.TrivialEnum) { imports.AddIfNotPresent(entity.Type.Module.Name); var slSelf = new SLIdentifier($"{entity.Type.Name}.self"); SLBaseExpr callExpr = new SLFunctionCall("unsafeBitCast", false, new SLArgument(new SLIdentifier("_"), new SLNamedClosureCall(callInvocation, new CommaListElementCollection <SLBaseExpr> (closureArgs)), false), new SLArgument(new SLIdentifier("to"), slSelf, true)); if (postMarshalCode.Count == 0) { returnLine = SLReturn.ReturnLine(callExpr); } else { returnIdent = new SLIdentifier(MarshalEngine.Uniqueify("retval", identifiersUsed)); identifiersUsed.Add(returnIdent.Name); var retvalDecl = new SLDeclaration(true, returnIdent, null, callExpr, Visibility.None); returnLine = new SLLine(retvalDecl); postMarshalCode.Add(SLReturn.ReturnLine(returnIdent)); } } else { switch (func.ReturnTypeSpec.Kind) { case TypeSpecKind.Closure: // let retval:CT = allocSwiftClosureToFunc_ARGS () // _vtable.entry!(retval, args) // let actualReturn = netFuncToSwiftClosure (retval.move()) // retval.deallocate() // return actualReturn var ct = func.ReturnTypeSpec as ClosureTypeSpec; var slct = new SLBoundGenericType("UnsafeMutablePointer", ToMarshaledClosureType(func, ct)); var ptrName = MarshalEngine.Uniqueify("retval", identifiersUsed); identifiersUsed.Add(ptrName); var ptrAllocCallSite = ct.HasReturn() ? $"allocSwiftClosureToFunc_{ct.ArgumentCount()}" : $"allocSwiftClosureToAction_{ct.ArgumentCount ()}"; var ptrAllocCall = new SLFunctionCall(ptrAllocCallSite, false); var ptrDecl = new SLDeclaration(true, new SLIdentifier(ptrName), slct, ptrAllocCall, Visibility.None); preMarshalCode.Add(new SLLine(ptrDecl)); closureArgs.Insert(0, new SLIdentifier(ptrName)); returnLine = new SLLine(new SLNamedClosureCall(callInvocation, new CommaListElementCollection <SLBaseExpr> (closureArgs))); var actualReturnName = MarshalEngine.Uniqueify("actualReturn", identifiersUsed); identifiersUsed.Add(actualReturnName); var convertCallSite = ct.HasReturn() ? "netFuncToSwiftClosure" : "netActionToSwiftClosure"; var isEmptyClosure = !ct.HasReturn() && !ct.HasArguments(); var pointerMove = new SLFunctionCall($"{ptrName}.move", false); var convertCall = isEmptyClosure ? pointerMove : new SLFunctionCall(convertCallSite, false, new SLArgument(new SLIdentifier("a1"), pointerMove, true)); var actualDecl = new SLDeclaration(true, actualReturnName, value: convertCall, vis: Visibility.None); postMarshalCode.Add(new SLLine(actualDecl)); postMarshalCode.Add(new SLReturn(new SLIdentifier(actualReturnName))); break; case TypeSpecKind.ProtocolList: case TypeSpecKind.Tuple: case TypeSpecKind.Named: var namedReturn = func.ReturnTypeSpec as NamedTypeSpec; // enums and structs can't get returned directly // instead they will be inserted at the head of the argument list // let retval = UnsafeMutablePointer<StructOrEnumType>.allocate(capacity: 1) // _vtable.entry!(retval, args) // T actualRetval = retval.move() // retval.deallocate() // return actualRetval string allocCallSite = String.Format("UnsafeMutablePointer<{0}>.allocate", func.ReturnTypeName); if (namedReturn != null) { imports.AddIfNotPresent(namedReturn.Module); } string retvalName = MarshalEngine.Uniqueify("retval", identifiersUsed); identifiersUsed.Add(retvalName); var retDecl = new SLDeclaration(true, retvalName, null, new SLFunctionCall(allocCallSite, false, new SLArgument(new SLIdentifier("capacity"), SLConstant.Val(1), true)), Visibility.None); preMarshalCode.Add(new SLLine(retDecl)); closureArgs.Insert(0, new SLIdentifier(retvalName)); returnLine = new SLLine(new SLNamedClosureCall(callInvocation, new CommaListElementCollection <SLBaseExpr> (closureArgs))); SLIdentifier actualReturnIdent = new SLIdentifier(MarshalEngine.Uniqueify("actualRetval", identifiersUsed)); identifiersUsed.Add(actualReturnIdent.Name); var actualRetvalDecl = new SLDeclaration(true, actualReturnIdent, null, new SLFunctionCall(String.Format("{0}.move", retvalName), false), Visibility.None); postMarshalCode.Add(new SLLine(actualRetvalDecl)); postMarshalCode.Add(SLFunctionCall.FunctionCallLine( String.Format("{0}.deallocate", retvalName))); postMarshalCode.Add(SLReturn.ReturnLine(actualReturnIdent)); break; } } } } } } foreach (ICodeElement line in preMarshalCode) { yield return(line); } yield return(returnLine); foreach (ICodeElement line in postMarshalCode) { yield return(line); } }
public void FuncReturningBool() { FuncReturningFoo(SLSimpleType.Bool, SLConstant.Val(false)); }
public void FuncReturningDouble() { FuncReturningFoo(SLSimpleType.Float, SLConstant.Val(4.0)); }
SLBaseExpr MarshalGenericTypeSpec(BaseDeclaration declContext, string name, NamedTypeSpec spec, int depth, int index) { // given Foo(T x) // the vtable entry should be something like // foo : ((@convention(c)(UnsafeRawPointer)->()) // // UnsafeMutablePointer<T> xPtr = UnsafeMutablePointer<T>.alloc(1); // pointerToX.initialize(x) // vtable.foo(toIntPtr(pointerToX)) // pointerToX.deinitialize(1) // pointerToX.deallocate() imports.AddIfNotPresent("XamGlue"); var xPtr = new SLIdentifier(MarshalEngine.Uniqueify(name + "Ptr", identifiersUsed)); identifiersUsed.Add(xPtr.Name); var xPtrDecl = new SLDeclaration(true, xPtr, null, new SLFunctionCall(String.Format("UnsafeMutablePointer<{0}>.allocate", SLGenericReferenceType.DefaultNamer(depth, index)), false, new SLArgument(new SLIdentifier("capacity"), SLConstant.Val(1), true)), Visibility.None); var xPtrBinding = new SLLine(xPtrDecl); preMarshalCode.Add(xPtrBinding); var xPtrInit = SLFunctionCall.FunctionCallLine(xPtr.Name + ".initialize", new SLArgument(new SLIdentifier("to"), new SLIdentifier(name), true)); preMarshalCode.Add(xPtrInit); var xPtrDeinit = SLFunctionCall.FunctionCallLine(xPtr.Name + ".deinitialize", new SLArgument(new SLIdentifier("count"), SLConstant.Val(1), true)); var xPtrDalloc = SLFunctionCall.FunctionCallLine(xPtr.Name + ".deallocate"); postMarshalCode.Add(xPtrDeinit); postMarshalCode.Add(xPtrDalloc); return(new SLFunctionCall("toIntPtr", false, new SLArgument(new SLIdentifier("value"), xPtr, true))); }
public void TestLetFloat() { BindToValue(true, SLSimpleType.Float, SLConstant.Val(42f), Visibility.Public); BindToValue(false, SLSimpleType.Float, SLConstant.Val(42f), Visibility.Public); }
SLBaseExpr MarshalProtocolListTypeSpec(BaseDeclaration declContext, string name, ProtocolListTypeSpec protocols) { // let p = UnsafeMutablePointer<protoType>.allocate (argName) // p.initialize(to: argName) // exp is toIntPtr(value: p) // ... // if isInOut: // argName = p.pointee // always: // p.deinitialize () // p.deallocate () var bindingName = new SLIdentifier(MarshalEngine.Uniqueify(name, identifiersUsed)); var argType = typeMapper.TypeSpecMapper.MapType(declContext, imports, protocols, false); var ptrType = new SLBoundGenericType("UnsafeMutablePointer", argType); identifiersUsed.Add(bindingName.Name); var decl = new SLDeclaration(true, bindingName, ptrType, new SLFunctionCall(ptrType + ".allocate", false, new SLArgument(new SLIdentifier("capacity"), SLConstant.Val(1), true)), Visibility.None, false); var varBinding = new SLLine(decl); preMarshalCode.Add(varBinding); var initCall = SLFunctionCall.FunctionCallLine(bindingName.Name + ".initialize", new SLArgument(new SLIdentifier("to"), new SLIdentifier(name), true)); preMarshalCode.Add(initCall); imports.AddIfNotPresent("XamGlue"); if (protocols.IsInOut) { postMarshalCode.Add(new SLLine(new SLBinding(name, bindingName.Dot(new SLIdentifier("pointee"))))); } postMarshalCode.Add(SLFunctionCall.FunctionCallLine($"{bindingName.Name}.deinitialize", new SLArgument(new SLIdentifier("count"), SLConstant.Val(1), true))); postMarshalCode.Add(SLFunctionCall.FunctionCallLine($"{bindingName.Name}.deallocate")); return(new SLFunctionCall("toIntPtr", false, new SLArgument(new SLIdentifier("value"), bindingName, true))); }
public void TestLetFloatInfer() { BindToValue(true, null, SLConstant.Val(42f), Visibility.Public); BindToValue(false, null, SLConstant.Val(42f), Visibility.Public); }