Ejemplo n.º 1
0
        public void EmitApply(CodeMemberMethod apply,
                              CodeVariableReferenceExpression pb,
                              CodeVariableReferenceExpression tb,
                              CodeArgumentReferenceExpression log)
        {
            apply.Statements.Add(new CodeCommentStatement("Create target " + name));

            // Set the TargetBuilder var and rule or template.

            CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression();

            cmie.Method = new CodeMethodReferenceExpression(pb, "DefineTarget");
            cmie.Parameters.Add(new CodePrimitiveExpression(name));
            cmie.Parameters.Add(log);

            apply.Statements.Add(new CodeAssignStatement(tb, cmie));
            apply.Statements.Add(CDH.IfNullReturnTrue(tb));

            Converter = delegate(string targ) {
                return(prov.NS.MakeTargetNameExpr(targ, CDH.This,
                                                  new CodeFieldReferenceExpression(pb, "Basis")));
            };

            EmitInfo(apply, tb);
        }
Ejemplo n.º 2
0
        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);
        }