public CCodeNewOperatorPointerDeclaration(INamedTypeSymbol type) : base(new NewOperatorMethod(type)) { var parameterSymbols = new List <IParameterSymbol>(); var arguments = new List <Expression>(); var parameterSymbolSize = new ParameterImpl { Name = "_size" }; var parameterSize = new Parameter { ParameterSymbol = parameterSymbolSize }; var parameterSymboPtr = new ParameterImpl { Name = "_ptr" }; var parameterPtr = new Parameter { ParameterSymbol = parameterSymboPtr }; parameterSymbols.Add(parameterSymbolSize); parameterSymbols.Add(parameterSymboPtr); arguments.Add(parameterSize); arguments.Add(parameterPtr); MethodBodyOpt = new MethodBody(Method) { Statements = { new ReturnStatement { ExpressionOpt = parameterPtr } } }; }
private bool AddOrUpdateIndexer(string name, bool isGet, IMethod orig) { var holder = _type as IHasIndexers; if (holder == null) { return(false); } var indx = holder.Indexers.FirstOrDefault(p => p.Name == name); if (indx == null) { holder.Indexers.Add(indx = new IndexerImpl(name)); } indx.Visibility = orig.Visibility; if (isGet) { indx.Type = orig.ReturnType; indx.Getter = ""; } else { indx.Type = orig.Parameters.Last().Type; indx.Setter = ""; } indx.Parameters.Clear(); foreach (var parm in orig.Parameters.Take(orig.Parameters.Count - (isGet ? 0 : 1))) { var myParm = new ParameterImpl(parm.Name, parm.Type); indx.Parameters.Add(myParm); } return(true); }
public CCodeNewOperatorWithSizeDeclaration(INamedTypeSymbol type) : base(new NewOperatorMethod(type)) { var parameterSymbol = new ParameterImpl { Name = "_customSize" }; var parameter = new Parameter { ParameterSymbol = parameterSymbol }; var methodSymbol = new MethodImpl { Name = "__new_set0", MethodKind = MethodKind.BuiltinOperator, Parameters = ImmutableArray.Create <IParameterSymbol>(parameterSymbol) }; MethodBodyOpt = new MethodBody(Method) { Statements = { new ReturnStatement { ExpressionOpt = new Call{ Method = methodSymbol, Arguments ={ parameter } } } } }; }
private bool AddOrUpdateConstructor(bool isInstance, IMethod orig) { var holder = _type as IHasConstructors; if (holder == null) { return(false); } var cstr = holder.Constructors.FirstOrDefault(c => isInstance ? !c.Modifier.HasFlag(Modifier.Static) : c.Modifier == Modifier.Static); if (cstr == null) { holder.Constructors.Add(cstr = new ConstructorImpl(null)); } cstr.Visibility = orig.Visibility; foreach (var parm in orig.Parameters) { var myParm = new ParameterImpl(parm.Name, parm.Type); cstr.Parameters.Add(myParm); } if (!isInstance) { cstr.Modifier = Modifier.Static; } return(true); }
private bool AddOrUpdateOperator(string name, IMethod orig) { var holder = _type as IHasOperators; if (holder == null) { return(false); } var opr = holder.Operators.FirstOrDefault(o => o.Name == name); if (opr == null) { holder.Operators.Add(opr = new OperatorImpl(name)); } opr.Visibility = orig.Visibility; opr.Modifier = orig.Modifier; if (!opr.Modifier.HasFlag(Modifier.Static)) { opr.Modifier |= Modifier.Static; } opr.ReturnType = orig.ReturnType; foreach (var parm in orig.Parameters) { var myParm = new ParameterImpl(parm.Name, parm.Type); opr.Parameters.Add(myParm); } return(true); }
private Parameter createParameter(XNamespace xnamespace, CoreNamespace ownerNamespace, CoreBehavioralFeature owner, XElement xparameter) { Parameter parameter = new ParameterImpl(); var name = xparameter.Attribute("name"); parameter.setName(name != null ? name.Value : ""); parameter.setBehavioralFeature(owner); updateOperationParameters(owner, parameter); parameter.setNamespace(ownerNamespace); updateNamespaceElemOwnedElements(ownerNamespace, parameter); var id = xparameter.Attribute("Id").Value; lookup.Add(id, parameter); var xptype = xparameter.Descendants(xnamespace + "referencedTypeMoniker").FirstOrDefault(); if (xptype != null) { var xtyperefid = xptype.Attribute("Id").Value; idToType.Add(id, xtyperefid); } string skind = xparameter.Attribute("direction").Value.ToLower(); parameter.setKind(getParameterDirectionKind(skind)); return(parameter); }
private Parameter createParameter(XNamespace xnamespace, CoreNamespace ownerNamespace, CoreBehavioralFeature owner, XElement xparameter) { Parameter parameter = new ParameterImpl(); parameter.setName(xparameter.Attribute("name").Value); parameter.setBehavioralFeature(owner); updateOperationParameters(owner, parameter); parameter.setNamespace(ownerNamespace); updateNamespaceElemOwnedElements(ownerNamespace, parameter); var id = xparameter.Attribute("xmi.id").Value; lookup.Add(id, parameter); // mode 1 var xptype = xparameter.Element(xnamespace + "Parameter.type"); if (xptype != null) { var xpclass = xptype.Element(xnamespace + "Class"); if (xpclass != null) { var xtyperefid = xpclass.Attribute("xmi.idref").Value; idToType.Add(id, xtyperefid); } } else // mode 2 { var xtype = xparameter.Attribute("type"); if (xtype != null) { string xtypeidref = xtype.Value; idToType.Add(id, xtypeidref); } } string skind = xparameter.Attribute("kind").Value; CoreModelElement kind; lookup.TryGetValue(skind, out kind); parameter.setKind(getParameterDirectionKind(skind)); return(parameter); }
public CCodeNewOperatorDeclaration(INamedTypeSymbol type, bool withFinalization = false, bool withExtraParams = false, bool debugVersion = false) : base(new NewOperatorMethod(type)) { this.withFinalization = withFinalization; this.withExtraParams = withExtraParams; this.debugVersion = debugVersion; var parameterSymbols = new List <IParameterSymbol>(); var arguments = new List <Expression>(); var parameterSymbolSize = new ParameterImpl { Name = "_size" }; parameterSymbols.Add(parameterSymbolSize); if (!withExtraParams) { var parameterSize = new Parameter { ParameterSymbol = parameterSymbolSize }; arguments.Add(parameterSize); } else { var parameterSymbolCustomSize = new ParameterImpl { Name = "_customSize" }; var parameterCustomSize = new Parameter { ParameterSymbol = parameterSymbolCustomSize }; parameterSymbols.Add(parameterSymbolCustomSize); arguments.Add(parameterCustomSize); } if (type.IsAtomicType()) { var parameterSymbolIsAtomicOrTypeDescr = new ParameterImpl { Name = "_is_atomic_or_type_descr" }; parameterSymbols.Add(parameterSymbolIsAtomicOrTypeDescr); arguments.Add( new FieldAccess { Field = new FieldImpl { ContainingType = new NamedTypeImpl { Name = "GCAtomic" }, Name = "Default", IsStatic = true } }); } else { // get or create type descriptor var parameterSymbolIsAtomicOrTypeDescr = new ParameterImpl { Name = "_is_atomic_or_type_descr" }; parameterSymbols.Add(parameterSymbolIsAtomicOrTypeDescr); var local = new Local { CustomName = "__type_descriptor" }; arguments.Add( new ConditionalOperator { Condition = local, Consequence = local, Alternative = new AssignmentOperator { Left = local, Right = new Call { Method = new CCodeGetTypeDescriptorDeclaration.GetTypeDescriptorMethod(type) } } }); } if (debugVersion) { var parameterSymbolFile = new ParameterImpl { Name = "_file" }; var parameterFile = new Parameter { ParameterSymbol = parameterSymbolFile }; var parameterSymbolLine = new ParameterImpl { Name = "_line" }; var parameterLine = new Parameter { ParameterSymbol = parameterSymbolLine }; parameterSymbols.Add(parameterSymbolFile); parameterSymbols.Add(parameterSymbolLine); arguments.Add(parameterFile); arguments.Add(parameterLine); } var methodSymbol = new MethodImpl { Name = withFinalization ? "__new_set0_with_finalizer" : "__new_set0", MethodKind = MethodKind.BuiltinOperator, Parameters = ImmutableArray.Create(parameterSymbols.ToArray()) }; var methodCallExpr = new Call { Method = methodSymbol }; foreach (var argItem in arguments) { methodCallExpr.Arguments.Add(argItem); } MethodBodyOpt = new MethodBody(Method) { Statements = { new ReturnStatement { ExpressionOpt = methodCallExpr } } }; }
internal override void AddToRuntime(ParameterInfo aParamInfo) { ParameterImpl parameter = new ParameterImpl(aParamInfo); GetOnDemandContext().ReportObjectModel.ParametersImpl.Add(aParamInfo.Name, parameter); }
public override void AddToRuntime(ParameterInfo aParamInfo) { ParameterImpl parameter = new ParameterImpl(aParamInfo.Values, aParamInfo.Labels, aParamInfo.MultiValue); this.GetLegacyContext().ReportObjectModel.ParametersImpl.Add(aParamInfo.Name, parameter); }
internal void SetNewContext() { m_paramValue = null; }
internal ParameterImplWrapper(ParameterImpl odpParameter) { m_odpParameter = odpParameter; }
internal ParameterImplWrapper() { m_odpParameter = new ParameterImpl(); }
public ParameterImplWrapper(ParameterImpl odpParameter) { this.m_odpParameter = odpParameter; }
public ParameterImplWrapper() { this.m_odpParameter = new ParameterImpl(); }