protected override void Emit(CodeTypeDeclaration ctd)
{
EmitEmptyCtor (ctd);
// Parameter fields
foreach (string name in sparams.Keys)
EmitParameter (ctd, name);
// ApplyDefaults
EmitApplyDefaults (ctd);
// Apply prologue
CodeParameterDeclarationExpression p1 =
new CodeParameterDeclarationExpression (ProjBuilder, "proj");
CodeParameterDeclarationExpression p2 =
new CodeParameterDeclarationExpression (CDH.String, "declloc");
CodeParameterDeclarationExpression p3 =
new CodeParameterDeclarationExpression (CDH.ILog, "log");
CodeMemberMethod apply = new CodeMemberMethod ();
apply.Name = "Apply";
apply.Attributes = MemberAttributes.Public | MemberAttributes.Override;
apply.ReturnType = CDH.Bool;
apply.Parameters.Add (p1);
apply.Parameters.Add (p2);
apply.Parameters.Add (p3);
CDH.EmitBaseChainBool (apply);
// Elements
if (elts.Count > 0) {
apply.Statements.Add (CDH.Variable (ProvBuilder, "pb"));
apply.Statements.Add (CDH.Variable (TargBuilder, "tb"));
CodeArgumentReferenceExpression proj = CDH.ARef ("proj");
CodeArgumentReferenceExpression declloc = CDH.ARef ("declloc");
CodeArgumentReferenceExpression log = CDH.ARef ("log");
CodeVariableReferenceExpression pb = CDH.VRef ("pb");
CodeVariableReferenceExpression tb = CDH.VRef ("tb");
foreach (StructureElement se in elts)
se.EmitApply (apply, proj, declloc, log, pb, tb);
}
// Apply epilogue
apply.Statements.Add (new CodeMethodReturnStatement (CDH.False));
ctd.Members.Add (apply);
}
void EmitApplyDefaults(CodeTypeDeclaration ctd)
{
CodeMemberMethod meth = new CodeMemberMethod ();
meth.Name = "ApplyDefaults";
meth.Attributes = MemberAttributes.Public | MemberAttributes.Override;
meth.ReturnType = CDH.Bool;
meth.Parameters.Add (CDH.Param (BMBase, "bmb"));
meth.Parameters.Add (CDH.Param (CDH.ILog, "log"));
CodeArgumentReferenceExpression bmb = CDH.ARef ("bmb");
CodeArgumentReferenceExpression log = CDH.ARef ("log");
// Set the parameters
foreach (string param in sparams.Keys) {
StructureParameterKind kind = sparams[param];
string val = defaults[param];
CodeAssignStatement assg = new CodeAssignStatement ();
assg.Left = CDH.ThisDot (param);
switch (kind) {
case StructureParameterKind.Basis:
if (val[val.Length - 1] != '/')
// Canonicalize basis names.
val += '/';
goto case StructureParameterKind.Target;
case StructureParameterKind.Target:
assg.Right = new CodePrimitiveExpression (val);
break;
case StructureParameterKind.Structure:
CodeMethodInvokeExpression mie = new CodeMethodInvokeExpression ();
mie.Method = new CodeMethodReferenceExpression (bmb, "GetNamespaceTemplate");
mie.Parameters.Add (new CodePrimitiveExpression (val));
mie.Parameters.Add (log);
UserType stype = structtypes[param];
assg.Right = new CodeCastExpression (stype.AsCodeDom, mie);
break;
}
meth.Statements.Add (assg);
if (kind == StructureParameterKind.Structure)
meth.Statements.Add (CDH.IfNullReturnTrue (assg.Left));
}
// All done.
meth.Statements.Add (new CodeMethodReturnStatement (CDH.False));
ctd.Members.Add (meth);
}
protected override void Emit(CodeTypeDeclaration ctd)
{
EmitAttribute(ctd);
// Constructor
CodeConstructor ctor = EmitEmptyCtor(ctd);
ctor.Parameters.Add(CDH.Param(NS.ParamsType, "stmpl"));
ctor.BaseConstructorArgs.Add(CDH.ARef("stmpl"));
// Matcher attr
CodeAttributeDeclaration kattr =
new CodeAttributeDeclaration("Mono.Build.Bundling.MatcherAttribute");
kattr.Arguments.Add(new CodeAttributeArgument(KindExpression));
ctd.CustomAttributes.Add(kattr);
// GetRegex override
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "GetRegex";
//method.Attributes = MemberAttributes.Family | MemberAttributes.Override;
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.ReturnType = CDH.String;
method.LinePragma = Location;
CodeExpression val = new CodePrimitiveExpression(Regex);
CodeStatement ret = new CodeMethodReturnStatement(val);
ret.LinePragma = Location;
method.Statements.Add(ret);
ctd.Members.Add(method);
// GetMatchType override
method = new CodeMemberMethod();
method.Name = "GetMatchType";
//method.Attributes = MemberAttributes.Family | MemberAttributes.Override;
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.ReturnType = CDH.Type;
method.LinePragma = Location;
val = new CodeTypeOfExpression(MatchType.AsCodeDom);
ret = new CodeMethodReturnStatement(val);
ret.LinePragma = Location;
method.Statements.Add(ret);
ctd.Members.Add(method);
}
CodeConstructor EmitConstructor(CodeTypeDeclaration ctd)
{
// The ctor that inits the field and chains to the parent if necc.
CodeConstructor ctor = EmitEmptyCtor(ctd);
CodeArgumentReferenceExpression stmpl = CDH.ARef("stmpl");
ctor.Parameters.Add(CDH.Param(NS.ParamsType, "stmpl"));
if (UsesStructure)
{
CodeAssignStatement assg = new CodeAssignStatement();
assg.Left = CDH.ThisDot("stmpl");
assg.Right = stmpl;
ctor.Statements.Add(assg);
}
ctor.BaseConstructorArgs.Add(ContextualStructRef(basestruct, stmpl));
return(ctor);
}
void EmitAsComposite(CodeTypeDeclaration ctd)
{
if (fields.Count == 0)
{
return;
}
if (comp_default_idx >= 0)
{
EmitDefault(ctd);
}
// Prologues - TotalItems field
CodeMemberProperty ti = new CodeMemberProperty();
ti.Name = "TotalItems";
ti.HasGet = true;
ti.HasSet = false;
ti.Type = new CodeTypeReference(typeof(int));
ti.Attributes = MemberAttributes.Family | MemberAttributes.Override;
CodeBinaryOperatorExpression add = new CodeBinaryOperatorExpression();
add.Left = new CodePropertyReferenceExpression(CDH.Base, "TotalItems");
add.Operator = CodeBinaryOperatorType.Add;
add.Right = new CodePrimitiveExpression(fields.Count);
CodeStatement ret = new CodeMethodReturnStatement(add);
ti.GetStatements.Add(ret);
ctd.Members.Add(ti);
// Prologues - CopyItems
CodeParameterDeclarationExpression p = CDH.Param(new CodeTypeReference(CDH.Result, 1), "r");
CodeMemberMethod copy = new CodeMemberMethod();
copy.Name = "CopyItems";
copy.ReturnType = null;
copy.Parameters.Add(p);
copy.Attributes = MemberAttributes.Family | MemberAttributes.Override;
CDH.EmitBaseChainVoid(copy);
CodeExpression copyarray = new CodeArgumentReferenceExpression(p.Name);
copy.Statements.Add(BaseTotalItems);
// Prologues - CloneTo method
p = CDH.Param(CDH.Result, "r");
CodeMemberMethod clone = new CodeMemberMethod();
clone.Name = "CloneTo";
clone.ReturnType = null;
clone.Parameters.Add(p);
clone.Attributes = MemberAttributes.Family | MemberAttributes.Override;
CDH.EmitBaseChainVoid(clone);
CodeExpression cp = CDH.ARef(p.Name);
CodeVariableDeclarationStatement vds = new CodeVariableDeclarationStatement();
vds.Name = "other";
vds.Type = new CodeTypeReference(ctd.Name);
vds.InitExpression = new CodeCastExpression(vds.Type, cp);
clone.Statements.Add(vds);
CodeExpression other = CDH.VRef(vds.Name);
// Now per-field statements
foreach (FieldInfo fi in fields)
{
fi.Emit(ctd, copy, copyarray, clone, other);
}
// no epilogues.
ctd.Members.Add(copy);
ctd.Members.Add(clone);
}