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();
}
