Ejemplo n.º 1
0
		public void Constructor0 ()
		{
			CodeGotoStatement cgs = new CodeGotoStatement ();
			Assert.IsNull (cgs.Label, "#1");

			Assert.IsNotNull (cgs.StartDirectives, "#2");
			Assert.AreEqual (0, cgs.StartDirectives.Count, "#3");

			Assert.IsNotNull (cgs.EndDirectives, "#4");
			Assert.AreEqual (0, cgs.EndDirectives.Count, "#5");

			Assert.IsNotNull (cgs.UserData, "#6");
			Assert.AreEqual (typeof(ListDictionary), cgs.UserData.GetType (), "#7");
			Assert.AreEqual (0, cgs.UserData.Count, "#8");

			Assert.IsNull (cgs.LinePragma, "#9");

			CodeLinePragma clp = new CodeLinePragma ("mono", 10);
			cgs.LinePragma = clp;
			Assert.IsNotNull (cgs.LinePragma, "#10");
			Assert.AreSame (clp, cgs.LinePragma, "#11");

			cgs.LinePragma = null;
			Assert.IsNull (cgs.LinePragma, "#12");

			string label = "mono";
			cgs.Label = label;
			Assert.AreSame (label, cgs.Label, "#13");
		}
        internal static void BuildEvalExpression(string field, string formatString, string propertyName,
            Type propertyType, ControlBuilder controlBuilder, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, bool isEncoded, ref bool hasTempObject) {

            // Altogether, this function will create a statement that looks like this:
            // if (this.Page.GetDataItem() != null) {
            //     target.{{propName}} = ({{propType}}) this.Eval(fieldName, formatString);
            // }

            //     this.Eval(fieldName, formatString)
            CodeMethodInvokeExpression evalExpr = new CodeMethodInvokeExpression();
            evalExpr.Method.TargetObject = new CodeThisReferenceExpression();
            evalExpr.Method.MethodName = EvalMethodName;
            evalExpr.Parameters.Add(new CodePrimitiveExpression(field));
            if (!String.IsNullOrEmpty(formatString)) {
                evalExpr.Parameters.Add(new CodePrimitiveExpression(formatString));
            }

            CodeStatementCollection evalStatements = new CodeStatementCollection();
            BuildPropertySetExpression(evalExpr, propertyName, propertyType, controlBuilder, methodStatements, evalStatements, linePragma, isEncoded, ref hasTempObject);

            // if (this.Page.GetDataItem() != null)
            CodeMethodInvokeExpression getDataItemExpr = new CodeMethodInvokeExpression();
            getDataItemExpr.Method.TargetObject = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Page");
            getDataItemExpr.Method.MethodName = GetDataItemMethodName;

            CodeConditionStatement ifStmt = new CodeConditionStatement();
            ifStmt.Condition = new CodeBinaryOperatorExpression(getDataItemExpr, 
                                                                CodeBinaryOperatorType.IdentityInequality, 
                                                                new CodePrimitiveExpression(null));
            ifStmt.TrueStatements.AddRange(evalStatements);
            statements.Add(ifStmt);
        }
Ejemplo n.º 3
0
		public void Constructor0 ()
		{
			CodeSnippetStatement css = new CodeSnippetStatement ();
			Assert.IsNull (css.LinePragma, "#1");

			Assert.IsNotNull (css.Value, "#2");
			Assert.AreEqual (string.Empty, css.Value, "#3");

			Assert.IsNotNull (css.StartDirectives, "#4");
			Assert.AreEqual (0, css.StartDirectives.Count, "#5");

			Assert.IsNotNull (css.EndDirectives, "#6");
			Assert.AreEqual (0, css.EndDirectives.Count, "#7");

			Assert.IsNotNull (css.UserData, "#8");
			Assert.AreEqual (typeof(ListDictionary), css.UserData.GetType (), "#9");
			Assert.AreEqual (0, css.UserData.Count, "#10");
			
			css.Value = null;
			Assert.IsNotNull (css.Value, "#11");
			Assert.AreEqual (string.Empty, css.Value, "#12");

			CodeLinePragma clp = new CodeLinePragma ("mono", 10);
			css.LinePragma = clp;
			Assert.IsNotNull (css.LinePragma, "#13");
			Assert.AreSame (clp, css.LinePragma, "#14");

			css.LinePragma = null;
			Assert.IsNull (css.LinePragma, "#15");
		}
Ejemplo n.º 4
0
	public StructureBuilder (NamespaceBuilder ns, CodeLinePragma loc, TypeAttributes attr) 
	    : base (BundleManagerBase.DefaultStructureClass, ns, loc, attr)
	{
	    BaseClass = new UserType (typeof (StructureTemplate));

	    ns.SetUserParams (this);
	}
        internal static void BuildExpressionSetup(ControlBuilder controlBuilder, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, bool isTwoWayBound, bool designerMode) {
            // {{controlType}} target;
            CodeVariableDeclarationStatement targetDecl = new CodeVariableDeclarationStatement(controlBuilder.ControlType, "dataBindingExpressionBuilderTarget");
            methodStatements.Add(targetDecl);

            CodeVariableReferenceExpression targetExp = new CodeVariableReferenceExpression(targetDecl.Name);

            // target = ({{controlType}}) sender;
            CodeAssignStatement setTarget = new CodeAssignStatement(targetExp,
                                                                    new CodeCastExpression(controlBuilder.ControlType,
                                                                                           new CodeArgumentReferenceExpression("sender")));
            setTarget.LinePragma = linePragma;
            statements.Add(setTarget);

            Type bindingContainerType = controlBuilder.BindingContainerType;
            CodeVariableDeclarationStatement containerDecl = new CodeVariableDeclarationStatement(bindingContainerType, "Container");
            methodStatements.Add(containerDecl);

            // {{containerType}} Container = ({{containerType}}) target.BindingContainer;
            CodeAssignStatement setContainer = new CodeAssignStatement(new CodeVariableReferenceExpression(containerDecl.Name),
                                                                       new CodeCastExpression(bindingContainerType,
                                                                                              new CodePropertyReferenceExpression(targetExp,
                                                                                                                                  "BindingContainer")));
            setContainer.LinePragma = linePragma;
            statements.Add(setContainer);
            string variableName = isTwoWayBound ? "BindItem" : "Item";
            GenerateItemTypeExpressions(controlBuilder, methodStatements, statements, linePragma, variableName);
            //Generate code for other variable as well at design time in addition to runtime variable for intellisense to work.
            if (designerMode) {
                GenerateItemTypeExpressions(controlBuilder, methodStatements, statements, linePragma, isTwoWayBound ?  "Item" : "BindItem");
            }
        }
Ejemplo n.º 6
0
	    public FieldInfo (int idx, UserType type, string name, CodeLinePragma line)
	    {
		Idx = idx;
		Type = type;
		Name = name;
		Line = line;
	    }
Ejemplo n.º 7
0
	public MetaRuleBuilder (string name, NamespaceBuilder ns, CodeLinePragma loc, TypeAttributes attr)
	{
	    rb = new RuleBuilder (name, ns, loc, attr);
	    tmpl = new RuleTemplateBuilder (name + "RTemplate", rb, ns, loc, attr);

	    ns.AddMetaRule (this);
	    BaseClass = RuleType;
	}
Ejemplo n.º 8
0
	    public TheResult (string name, NamespaceBuilder ns, string ename, CodeLinePragma loc, TypeAttributes attr)
		: base (name, ns, loc, attr)
	    {
		etype = new UserType (ename);

		BaseClass = new UserType (typeof (EnumResult<>));
		BaseClass.AddTypeArgument (etype);
	    }
Ejemplo n.º 9
0
	public EnumResultBuilder (string name, NamespaceBuilder ns, CodeLinePragma loc, TypeAttributes attr)
	{
	    if (name == null)
		throw new ArgumentNullException ();
	    
	    enumer = new TheEnum (name, ns, loc, attr);
	    result = new TheResult (name + "Result", ns, name, loc, attr);
	}
Ejemplo n.º 10
0
		public void Constructor0_Deny_Unrestricted ()
		{
			CodeLinePragma clp = new CodeLinePragma ();
			Assert.AreEqual (String.Empty, clp.FileName, "FileName");
			clp.FileName = "filename";
			Assert.AreEqual (0, clp.LineNumber, "LineNumber");
			clp.LineNumber = Int32.MinValue;
		}
Ejemplo n.º 11
0
		public void Constructor1_Deny_Unrestricted ()
		{
			CodeLinePragma clp = new CodeLinePragma ("filename", Int32.MaxValue);
			Assert.AreEqual ("filename", clp.FileName, "FileName");
			clp.FileName = String.Empty;
			Assert.AreEqual (Int32.MaxValue, clp.LineNumber, "LineNumber");
			clp.LineNumber = 0;
		}
 private void AddOutputWriteStatement(CodeStatementCollection methodStatements, CodeExpression expr, CodeLinePragma linePragma)
 {
     CodeStatement outputWriteStatement = this.GetOutputWriteStatement(expr, false);
     if (linePragma != null)
     {
         outputWriteStatement.LinePragma = linePragma;
     }
     methodStatements.Add(outputWriteStatement);
 }
Ejemplo n.º 13
0
 public virtual void WriteLinePragma(CodeLinePragma pragma)
 {
     if (pragma == null)
     {
         WriteLinePragma(null, null);
     }
     else
     {
         WriteLinePragma(pragma.LineNumber, pragma.FileName);
     }
 }
        internal virtual void BuildExpression(BoundPropertyEntry bpe, ControlBuilder controlBuilder,
            CodeExpression controlReference, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, ref bool hasTempObject) {

            CodeExpression codeExpression = GetCodeExpression(bpe,
                bpe.ParsedExpressionData, new ExpressionBuilderContext(controlBuilder.VirtualPath));

            CodeDomUtility.CreatePropertySetStatements(methodStatements, statements,
                controlReference, bpe.Name, bpe.Type,
                codeExpression,
                linePragma);
        }
Ejemplo n.º 15
0
	protected TypeExpressedItem (string namebase, NamespaceBuilder ns, CodeLinePragma loc, TypeAttributes attrs)
	{
	    if (namebase == null)
		throw new ArgumentNullException ();

	    this.namebase = namebase;
	    location = loc;
	    this.attrs = attrs;

	    this.ns = ns;
	    ns.AddItem (this);
	}
Ejemplo n.º 16
0
		public void Constructor1 ()
		{
			string fileName = "mono";

			CodeLinePragma clp = new CodeLinePragma (fileName, 5);
			Assert.IsNotNull (clp.FileName, "#1");
			Assert.AreSame (fileName, clp.FileName, "#2");
			Assert.AreEqual (5, clp.LineNumber, "#3");

			clp = new CodeLinePragma ((string) null, 10);
			Assert.IsNotNull (clp.FileName, "#4");
			Assert.AreEqual (string.Empty, clp.FileName, "#5");
		}
        private static void BuildPropertySetExpression(CodeExpression expression, string propertyName,
            Type propertyType, ControlBuilder controlBuilder, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, bool isEncoded, ref bool hasTempObject) {

            if (isEncoded) {
                expression = new CodeMethodInvokeExpression(
                    new CodeMethodReferenceExpression(
                        new CodeTypeReferenceExpression(typeof(HttpUtility)),
                       "HtmlEncode"),
                    expression);
            }

            CodeDomUtility.CreatePropertySetStatements(methodStatements, statements,
                new CodeVariableReferenceExpression("dataBindingExpressionBuilderTarget"), propertyName, propertyType,
                expression,
                linePragma);
        }
		public void Constructor0 ()
		{
			CodeVariableDeclarationStatement cvds = new CodeVariableDeclarationStatement ();
			Assert.IsNull (cvds.InitExpression, "#1");
			Assert.IsNotNull (cvds.Name, "#2");
			Assert.AreEqual (string.Empty, cvds.Name, "#3");
			Assert.IsNotNull (cvds.Type, "#4");
			Assert.AreEqual (typeof (void).FullName, cvds.Type.BaseType, "#5");

			string name = "mono";
			cvds.Name = name;
			Assert.AreSame (name, cvds.Name, "#6");

			cvds.Name = null;
			Assert.IsNotNull (cvds.Name, "#7");
			Assert.AreEqual (string.Empty, cvds.Name, "#8");

			CodeExpression expression = new CodeExpression ();
			cvds.InitExpression = expression;
			Assert.AreSame (expression, cvds.InitExpression, "#9");

			CodeTypeReference type = new CodeTypeReference ("mono");
			cvds.Type = type;
			Assert.AreSame (type, cvds.Type, "#10");

			cvds.Type = null;
			Assert.IsNotNull (cvds.Type, "#11");
			Assert.AreEqual (typeof (void).FullName, cvds.Type.BaseType, "#12");

#if NET_2_0
			Assert.IsNotNull (cvds.StartDirectives, "#13");
			Assert.AreEqual (0, cvds.StartDirectives.Count, "#14");

			Assert.IsNotNull (cvds.EndDirectives, "#15");
			Assert.AreEqual (0, cvds.EndDirectives.Count, "#16");
#endif

			Assert.IsNull (cvds.LinePragma, "#17");

			CodeLinePragma clp = new CodeLinePragma ("mono", 10);
			cvds.LinePragma = clp;
			Assert.IsNotNull (cvds.LinePragma, "#18");
			Assert.AreSame (clp, cvds.LinePragma, "#19");

			cvds.LinePragma = null;
			Assert.IsNull (cvds.LinePragma, "#20");
		}
Ejemplo n.º 19
0
		public void Constructor0 ()
		{
			CodeLabeledStatement cls = new CodeLabeledStatement ();
			Assert.IsNull (cls.LinePragma, "#1");

			Assert.IsNotNull (cls.Label, "#2");
			Assert.AreEqual (string.Empty, cls.Label, "#3");

#if NET_2_0
			Assert.IsNotNull (cls.StartDirectives, "#4");
			Assert.AreEqual (0, cls.StartDirectives.Count, "#5");

			Assert.IsNotNull (cls.EndDirectives, "#6");
			Assert.AreEqual (0, cls.EndDirectives.Count, "#7");
#endif

			Assert.IsNotNull (cls.UserData, "#8");
			Assert.AreEqual (typeof(ListDictionary), cls.UserData.GetType (), "#9");
			Assert.AreEqual (0, cls.UserData.Count, "#10");
			
			string label = "mono";
			cls.Label = label;
			Assert.IsNotNull (cls.Label, "#11");
			Assert.AreSame (label, cls.Label, "#12");

			cls.Label = null;
			Assert.IsNotNull (cls.Label, "#13");
			Assert.AreEqual (string.Empty, cls.Label, "#14");

			CodeLinePragma clp = new CodeLinePragma ("mono", 10);
			cls.LinePragma = clp;
			Assert.IsNotNull (cls.LinePragma, "#15");
			Assert.AreSame (clp, cls.LinePragma, "#16");

			cls.LinePragma = null;
			Assert.IsNull (cls.LinePragma, "#17");

			Assert.IsNull (cls.Statement, "#18");

			CodeStatement stmt = new CodeStatement ();
			cls.Statement = stmt;
			Assert.IsNotNull (cls.Statement, "#19");
			Assert.AreSame (stmt, cls.Statement);
		}
 internal static void CreatePropertySetStatements(CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeExpression target, string targetPropertyName, Type destinationType, CodeExpression value, CodeLinePragma linePragma)
 {
     bool flag = false;
     if (destinationType == null)
     {
         flag = true;
     }
     if (flag)
     {
         CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression();
         CodeExpressionStatement statement = new CodeExpressionStatement(expression) {
             LinePragma = linePragma
         };
         expression.Method.TargetObject = new CodeCastExpression(typeof(IAttributeAccessor), target);
         expression.Method.MethodName = "SetAttribute";
         expression.Parameters.Add(new CodePrimitiveExpression(targetPropertyName));
         expression.Parameters.Add(GenerateConvertToString(value));
         statements.Add(statement);
     }
     else if (destinationType.IsValueType)
     {
         CodeAssignStatement statement2 = new CodeAssignStatement(BuildPropertyReferenceExpression(target, targetPropertyName), new CodeCastExpression(destinationType, value)) {
             LinePragma = linePragma
         };
         statements.Add(statement2);
     }
     else
     {
         CodeExpression expression2;
         if (destinationType == typeof(string))
         {
             expression2 = GenerateConvertToString(value);
         }
         else
         {
             expression2 = new CodeCastExpression(destinationType, value);
         }
         CodeAssignStatement statement3 = new CodeAssignStatement(BuildPropertyReferenceExpression(target, targetPropertyName), expression2) {
             LinePragma = linePragma
         };
         statements.Add(statement3);
     }
 }
Ejemplo n.º 21
0
		public void Constructor0 ()
		{
			CodeLinePragma clp = new CodeLinePragma ();
			Assert.IsNotNull (clp.FileName, "#1");
			Assert.AreEqual (string.Empty, clp.FileName, "#2");
			Assert.AreEqual (0, clp.LineNumber, "#3");

			clp.FileName = null;
			Assert.IsNotNull (clp.FileName, "#4");
			Assert.AreEqual (string.Empty, clp.FileName, "#5");

			string fileName = "mono";
			clp.FileName = fileName;
			Assert.IsNotNull (clp.FileName, "#6");
			Assert.AreSame (fileName, clp.FileName, "#7");

			clp.LineNumber = 5;
			Assert.AreEqual (5, clp.LineNumber, "#8");
		}
Ejemplo n.º 22
0
		public void Constructor0 ()
		{
			CodeSnippetTypeMember cstm = new CodeSnippetTypeMember ();

			Assert.AreEqual (MemberAttributes.Private | MemberAttributes.Final,
				cstm.Attributes, "#1");

			Assert.IsNotNull (cstm.Comments, "#2");
			Assert.AreEqual (0, cstm.Comments.Count, "#3");

			Assert.IsNotNull (cstm.CustomAttributes, "#4");
			Assert.AreEqual (0, cstm.CustomAttributes.Count, "#5");

#if NET_2_0
			Assert.IsNotNull (cstm.StartDirectives, "#6");
			Assert.AreEqual (0, cstm.StartDirectives.Count, "#7");

			Assert.IsNotNull (cstm.EndDirectives, "#8");
			Assert.AreEqual (0, cstm.EndDirectives.Count, "#9");
#endif

			Assert.IsNotNull (cstm.Text, "#10");
			Assert.AreEqual (string.Empty, cstm.Text, "#11");

			Assert.IsNull (cstm.LinePragma, "#12");

			Assert.IsNotNull (cstm.Name, "#13");
			Assert.AreEqual (string.Empty, cstm.Name, "#14");

			Assert.IsNotNull (cstm.UserData, "#15");
			Assert.AreEqual (typeof(ListDictionary), cstm.UserData.GetType (), "#16");
			Assert.AreEqual (0, cstm.UserData.Count, "#17");

			cstm.Name = null;
			Assert.IsNotNull (cstm.Name, "#18");
			Assert.AreEqual (string.Empty, cstm.Name, "#19");

			CodeLinePragma clp = new CodeLinePragma ("mono", 10);
			cstm.LinePragma = clp;
			Assert.IsNotNull (cstm.LinePragma, "#20");
			Assert.AreSame (clp, cstm.LinePragma, "#21");
		}
 internal static void BuildEvalExpression(string field, string formatString, string propertyName, Type propertyType, ControlBuilder controlBuilder, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, ref bool hasTempObject)
 {
     CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression {
         Method = { TargetObject = new CodeThisReferenceExpression(), MethodName = "Eval" }
     };
     expression.Parameters.Add(new CodePrimitiveExpression(field));
     if (!string.IsNullOrEmpty(formatString))
     {
         expression.Parameters.Add(new CodePrimitiveExpression(formatString));
     }
     CodeStatementCollection statements2 = new CodeStatementCollection();
     BuildPropertySetExpression(expression, propertyName, propertyType, controlBuilder, methodStatements, statements2, linePragma, ref hasTempObject);
     CodeMethodInvokeExpression left = new CodeMethodInvokeExpression {
         Method = { TargetObject = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Page"), MethodName = "GetDataItem" }
     };
     CodeConditionStatement statement = new CodeConditionStatement {
         Condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null))
     };
     statement.TrueStatements.AddRange(statements2);
     statements.Add(statement);
 }
Ejemplo n.º 24
0
		public void Constructor0 ()
		{
			CodeNamespaceImport cni = new CodeNamespaceImport ();
			Assert.IsNull (cni.LinePragma, "#1");
			Assert.IsNotNull (cni.Namespace, "#2");
			Assert.AreEqual (string.Empty, cni.Namespace, "#3");

			CodeLinePragma linePragma = new CodeLinePragma ("a", 5);
			cni.LinePragma = linePragma;
			Assert.IsNotNull (cni.LinePragma, "#4");
			Assert.AreSame (linePragma, cni.LinePragma, "#5");

			cni.LinePragma = null;
			Assert.IsNull (cni.LinePragma, "#6");

			string ns = "mono";
			cni.Namespace = ns;
			Assert.AreSame (ns, cni.Namespace, "#7");

			cni.Namespace = null;
			Assert.IsNotNull (cni.Namespace, "#8");
			Assert.AreEqual (string.Empty, cni.Namespace, "#9");
		}
Ejemplo n.º 25
0
		public void Constructor0 ()
		{
			CodeSnippetCompileUnit cscu = new CodeSnippetCompileUnit ();
			Assert.IsNull (cscu.LinePragma, "#1");

			Assert.IsNotNull (cscu.Value, "#2");
			Assert.AreEqual (string.Empty, cscu.Value, "#3");

			Assert.IsNotNull (cscu.AssemblyCustomAttributes, "#4");
			Assert.AreEqual (0, cscu.AssemblyCustomAttributes.Count, "#5");

			Assert.IsNotNull (cscu.EndDirectives, "#6");
			Assert.AreEqual (0, cscu.EndDirectives.Count, "#7");

			Assert.IsNotNull (cscu.Namespaces, "#8");
			Assert.AreEqual (0, cscu.Namespaces.Count, "#9");

			Assert.IsNotNull (cscu.ReferencedAssemblies, "#10");
			Assert.AreEqual (0, cscu.ReferencedAssemblies.Count, "#11");

			Assert.IsNotNull (cscu.StartDirectives, "#12");
			Assert.AreEqual (0, cscu.StartDirectives.Count, "#13");

			Assert.IsNotNull (cscu.UserData, "#14");
			Assert.AreEqual (typeof(ListDictionary), cscu.UserData.GetType (), "#15");
			Assert.AreEqual (0, cscu.UserData.Count, "#16");
			
			cscu.Value = null;
			Assert.IsNotNull (cscu.Value, "#17");
			Assert.AreEqual (string.Empty, cscu.Value, "#18");

			CodeLinePragma clp = new CodeLinePragma ("mono", 10);
			cscu.LinePragma = clp;
			Assert.IsNotNull (cscu.LinePragma, "#19");
			Assert.AreSame (clp, cscu.LinePragma, "#20");
		}
Ejemplo n.º 26
0
 protected override void GenerateLinePragmaStart(System.CodeDom.CodeLinePragma e)
 {
     throw new Exception("The method or operation is not implemented.");
 }
		protected override void GenerateLinePragmaEnd(CodeLinePragma e)
		{
			Output.WriteLine("[CodeLinePragma: {0}]", e.ToString());
		}
Ejemplo n.º 28
0
 private void AddLinePragma(CodeStatement cs, int lineNumber)
 {
     CodeLinePragma clp = new CodeLinePragma(ParentFolderPrefix + SourceFileInfo.RelativeSourceFilePath + XAML, lineNumber);
     cs.LinePragma = clp;
 }
Ejemplo n.º 29
0
 private void AddLinePragma(CodeTypeMember ctm, int lineNumber)
 {
     CodeLinePragma clp = new CodeLinePragma(ParentFolderPrefix + SourceFileInfo.RelativeSourceFilePath + XAML, lineNumber);
     ctm.LinePragma = clp;
 }
Ejemplo n.º 30
0
 protected override void GenerateLinePragmaStart(CodeLinePragma e)
 {
     base.Output.WriteLine("");
     base.Output.Write("#ExternalSource(\"");
     base.Output.Write(e.FileName);
     base.Output.Write("\",");
     base.Output.Write(e.LineNumber);
     base.Output.WriteLine(")");
 }
Ejemplo n.º 31
0
 protected override void GenerateLinePragmaEnd(CodeLinePragma e)
 {
     base.Output.WriteLine("");
     base.Output.WriteLine("#End ExternalSource");
 }