// Requires:
        //  statement.Expression is MethodCall
        //  statement.Expression.Callee is MemberBinding
        //  statement.Expression.Callee.BoundMember is Method
        //  statement.Expression.Callee.BoundMember == "Requires" or "Ensures"
        //
        //  inline  <==> replacementMethod == null
        //  replacementMethod != null
        //           ==> replacementMethod.ReturnType == methodToReplace.ReturnType
        //               && replacementMethod.Parameters.Count == 1
        //               && methodToReplace.Parameters.Count == 1
        //               && replacementMethod.Parameters[0].Type == methodToReplace.Parameters[0].Type
        //
        private static Statement RewriteContractCall(
            ExpressionStatement statement,
            Method /*!*/ methodToReplace,
            Method /*?*/ replacementMethod,
            Literal /*?*/ sourceTextToUseAsSecondArg)
        {
            Contract.Requires(statement != null);

            MethodCall call = statement.Expression as MethodCall;

            if (call == null || call.Callee == null)
            {
                return statement;
            }

            MemberBinding mb = call.Callee as MemberBinding;
            if (mb == null)
            {
                return statement;
            }

            Method m = mb.BoundMember as Method;
            if (m == null)
            {
                return statement;
            }

            if (m != methodToReplace)
            {
                return statement;
            }

            mb.BoundMember = replacementMethod;

            if (call.Operands.Count == 3)
            {
                // then the invariant was found in a reference assembly
                // it already has all of its arguments
                return statement;
            }

            if (call.Operands.Count == 1)
            {
                call.Operands.Add(Literal.Null);
            }

            Literal extraArg = sourceTextToUseAsSecondArg;
            if (extraArg == null)
            {
                extraArg = Literal.Null;
                //extraArg = new Literal("No other information available", SystemTypes.String);
            }

            call.Operands.Add(extraArg);

            return statement;
        }
Exemplo n.º 2
0
 public override Expression ExplicitLiteralCoercion(Literal lit, TypeNode sourceType, TypeNode targetType, TypeViewer typeViewer) {
   if (sourceType == targetType && (sourceType == SystemTypes.Double || sourceType == SystemTypes.Single)) return lit;
   TypeNode originalTargetType = targetType;
   EnumNode sourceEnum = sourceType as EnumNode;
   if (sourceEnum != null) sourceType = sourceEnum.UnderlyingType;
   bool needsRuntimeCoercion = this.suppressOverflowCheck;
   if (!sourceType.IsPrimitiveInteger || sourceType == SystemTypes.IntPtr || sourceType == SystemTypes.UIntPtr)
     needsRuntimeCoercion = true;
   else if (!targetType.IsPrimitiveInteger || targetType == SystemTypes.IntPtr || targetType == SystemTypes.UIntPtr)
     needsRuntimeCoercion = true;
   if (needsRuntimeCoercion){
     if (lit != null && lit.Value != null)
       targetType = TypeNode.StripModifier(targetType, SystemTypes.NonNullType);
     return this.ExplicitCoercion(lit, targetType, typeViewer);
   }else
     return this.LiteralCoercion(lit, sourceType, targetType, true, originalTargetType, null, false);
 }
Exemplo n.º 3
0
 public override bool ImplicitLiteralCoercionFromTo(Literal lit, TypeNode sourceType, TypeNode targetType){
   if (lit == null) return false;
   if (sourceType == targetType) return true;
   object val = lit.Value;
   if (targetType is EnumNode){
     if (val is int && ((int)val) == 0)
       return true;
     return false;
   }
   if (targetType.TypeCode == TypeCode.Boolean) return false;
   if (val == null && lit.Type == SystemTypes.Object){
     //null literal
     if (targetType != null && !this.IsCompatibleWithNull(targetType))
       return false;
     return true;
   }
   if (targetType.TypeCode == TypeCode.String) return false;
   if (targetType.TypeCode == TypeCode.Object) return false;
   if (targetType.TypeCode == TypeCode.Char || sourceType.TypeCode == TypeCode.Boolean || sourceType.TypeCode == TypeCode.Decimal) return false;
   switch (sourceType.TypeCode){
     case TypeCode.Char:
     case TypeCode.Double:
       return false;
     case TypeCode.Single:
       switch (targetType.TypeCode){
         case TypeCode.Double: return true;
         default: return false;
       }
     case TypeCode.Int64:
       switch (targetType.TypeCode) {
         case TypeCode.Int64:
         case TypeCode.UInt32:
         case TypeCode.UInt64:
         case TypeCode.Decimal:
         case TypeCode.Single:
         case TypeCode.Double:
           break;
         default:
           return false;
       }
       break;
     case TypeCode.UInt64:
       switch (targetType.TypeCode){
         case TypeCode.Int64: 
         case TypeCode.UInt64:
         case TypeCode.Decimal:
         case TypeCode.Single:
         case TypeCode.Double:
           break;
         default: 
           return false;
       }
       break;
   }
   try{
     if (val == null){
       if (targetType.IsValueType) return false;
     }else
       val = System.Convert.ChangeType(val, targetType.TypeCode);
     return true;
   }catch(InvalidCastException){
   }catch(OverflowException){
   }catch(FormatException){}
   return false;
 }
Exemplo n.º 4
0
 public override Expression VisitLiteral(Literal literal)
 {
     if (literal == null) return null;
     TypeNode t = literal.Value as TypeNode;
     if (t != null)
         return new Literal(this.VisitTypeReference(t), literal.Type, literal.SourceContext);
     ArrayType at = literal.Type as ArrayType;
     if (at != null && at.ElementType is TypeNode)
     {
         TypeNode cloneType = this.VisitTypeReference(literal.Type);
         TypeNode[] val = literal.Value as TypeNode[];
         int len = val == null ? 0 : val.Length;
         TypeNode[] newVal = val == null ? null : new TypeNode[len];
         for (int i = 0; i < len; i++)
         {
             newVal[i] = this.VisitTypeReference(val[i]);
         }
         return new Literal(newVal, cloneType);
     }
     return (Literal)literal.Clone();
 }
Exemplo n.º 5
0
 private Literal ParseRealLiteral(){
   Debug.Assert(this.currentToken == Token.RealLiteral);
   string tokStr = this.scanner.GetTokenSource();
   SourceContext ctx = this.scanner.CurrentSourceContext;
   TypeCode tc = this.scanner.ScanNumberSuffix();
   ctx.EndPos = this.scanner.endPos;
   Literal result;
   string typeName = null;
   try{
     switch(tc){
       case TypeCode.Single:
         typeName = "float";
         float fVal = Single.Parse(tokStr, NumberStyles.Any, CultureInfo.InvariantCulture);
         if (fVal == 0f && tokStr.IndexOfAny(nonZeroDigits) >= 0)
           this.HandleError(ctx, Error.FloatOverflow, typeName);
         result = new Literal(fVal);
         break;
       case TypeCode.Empty:
       case TypeCode.Double:
         typeName = "double";
         double dVal = Double.Parse(tokStr, NumberStyles.Any, CultureInfo.InvariantCulture);
         if (dVal == 0d && tokStr.IndexOfAny(nonZeroDigits) >= 0)
           this.HandleError(ctx, Error.FloatOverflow, typeName);
         result = new Literal(dVal);
         break;
       case TypeCode.Decimal:
         typeName = "decimal";
         decimal decVal = Decimal.Parse(tokStr, NumberStyles.Any, CultureInfo.InvariantCulture);
         result = new Literal(decVal);
         break;
       default:
         //TODO: give an error message
         goto case TypeCode.Empty;
     }
   }catch(OverflowException){
     this.HandleError(ctx, Error.FloatOverflow, typeName);
     result = new Literal(0);
   }
   result.SourceContext = ctx;
   result.TypeWasExplicitlySpecifiedInSource = tc != TypeCode.Empty;
   this.GetNextToken();
   return result;
 }
Exemplo n.º 6
0
 private Literal ParseIntegerLiteral(){
   Debug.Assert(this.currentToken == Token.IntegerLiteral);
   string tokStr = this.scanner.GetTokenSource();
   SourceContext ctx = this.scanner.CurrentSourceContext;
   TypeCode tc = this.scanner.ScanNumberSuffix();
   ctx.EndPos = this.scanner.endPos;
   Literal result;
   try{
     switch(tc){
       case TypeCode.Single:
         result = new Literal(Single.Parse(tokStr, null));
         break;
       case TypeCode.Double:
         result = new Literal(Double.Parse(tokStr, null));
         break;
       case TypeCode.Decimal:
         result = new Literal(Decimal.Parse(tokStr, null));
         break;
       default:
         ulong ul = UInt64.Parse(tokStr, null);
         if (ul <= int.MaxValue && tc == TypeCode.Empty)
           result = new Literal((int)ul);
         else if (ul <= uint.MaxValue && (tc == TypeCode.Empty || tc == TypeCode.UInt32))
           result = new Literal((uint)ul);
         else if (ul <= long.MaxValue && (tc == TypeCode.Empty || tc == TypeCode.Int64))
           result = new Literal((long)ul);
         else
           result = new Literal(ul);
         break;
     }
   }catch(OverflowException){
     this.HandleError(ctx, Error.IntOverflow);
     result = new Literal(0);
   }catch(ExecutionEngineException){
     this.HandleError(ctx, Error.IntOverflow);
     result = new Literal(0);
   }
   result.SourceContext = ctx;
   result.TypeWasExplicitlySpecifiedInSource = tc != TypeCode.Empty;
   this.GetNextToken();
   return result;
 }
Exemplo n.º 7
0
 private void WriteLiteral(Literal literal, bool showType) {
     TypeNode type = literal.Type;
     Object value = literal.Value;
     if (showType) WriteTypeReference(type);
     if (value == null) {
         writer.WriteElementString("nullValue", String.Empty);
     } else {
         if (type.NodeType == NodeType.EnumNode) {
             EnumNode enumeration = (EnumNode)type;
             FieldList fields = GetAppliedFields(enumeration, Convert.ToInt64(value));
             writer.WriteStartElement("enumValue");
             for (int i = 0; i < fields.Count; i++) {
                 writer.WriteStartElement("field");
                 writer.WriteAttributeString("name", fields[i].Name.Name);
                 writer.WriteEndElement();
             }
             writer.WriteEndElement();
         } else  if (type.FullName == "System.Type") {
             writer.WriteStartElement("typeValue");
             WriteTypeReference((TypeNode)value);
             writer.WriteEndElement();
         } else {
             string text = value.ToString();
             if (!IsValidXmlText(text)) text = String.Empty;
             writer.WriteElementString("value", text);
         }
     }
 }
    protected override object VisitLoadConstant(Variable dest, Literal source, Statement stat, object arg) 
    {
      ExposureState estate=(ExposureState)arg;

      if (source == Literal.False){
        estate.SetToFalse(dest);
      }

      return arg;
    }
Exemplo n.º 9
0
 private Literal LiteralCoercion(Literal/*!*/ lit, TypeNode sourceType, TypeNode targetType, bool explicitCoercion, TypeNode originalTargetType, TypeViewer typeViewer, bool forLabel) {
   if (sourceType == targetType){
     if (sourceType == lit.Type) return lit;
     return new Literal(Convert.ChangeType(lit.Value, sourceType.TypeCode), sourceType, lit.SourceContext);
   }
   object val = lit.Value;
   EnumNode eN = targetType as EnumNode;
   if (eN != null){
     if (sourceType.IsPrimitiveInteger && val is IConvertible && ((IConvertible)val).ToDouble(null) == 0.0){
       if (eN.UnderlyingType == SystemTypes.Int64 || eN.UnderlyingType == SystemTypes.UInt64) val = 0L; else val = 0;
       return new Literal(val, eN, lit.SourceContext);
     }
     goto error;
   }
   if (targetType.TypeCode == TypeCode.Boolean){
     this.HandleError(lit, Error.ConstOutOfRange, lit.SourceContext.SourceText, "bool");
     lit.SourceContext.Document = null;
     return null;
   }
   if (targetType.TypeCode == TypeCode.String){
     if (val != null || lit.Type != SystemTypes.Object){
       this.HandleError(lit, Error.NoImplicitConversion, this.GetTypeName(sourceType), this.GetTypeName(targetType));
       lit.SourceContext.Document = null;
       return null;
     }
     return lit;
   }
   if (targetType.TypeCode == TypeCode.Object){
     if (val == null && sourceType == SystemTypes.Object && (explicitCoercion || !this.IsNonNullType(targetType))) return lit;
     if (val is string && this.IsNonNullType(targetType) && TypeNode.StripModifiers(targetType) == SystemTypes.String) return lit;
     Method coercion = null;
     if (explicitCoercion)
       coercion = this.UserDefinedExplicitCoercionMethod(lit, sourceType, targetType, true, originalTargetType, typeViewer);
     else
       coercion = this.UserDefinedImplicitCoercionMethod(lit, sourceType, targetType, true, typeViewer);
     if (coercion != null) return null;
     this.HandleError(lit, Error.NoImplicitConversion, this.GetTypeName(sourceType), this.GetTypeName(targetType));
     lit.SourceContext.Document = null;
     return null;
   }
   if ((targetType.TypeCode == TypeCode.Char || sourceType.TypeCode == TypeCode.Boolean || sourceType.TypeCode == TypeCode.Decimal) && !forLabel) goto error;
   switch (sourceType.TypeCode){
     case TypeCode.Double:
       switch (targetType.TypeCode){
         case TypeCode.Single: this.HandleError(lit, Error.LiteralDoubleCast, "float", "F"); return lit;
         case TypeCode.Decimal: this.HandleError(lit, Error.LiteralDoubleCast, "decimal", "M"); return lit;
         default: 
           this.HandleError(lit, Error.NoImplicitConversion, this.GetTypeName(sourceType), this.GetTypeName(targetType));
           lit.SourceContext.Document = null;
           return null;
       }
     case TypeCode.Single:
       switch (targetType.TypeCode){
         case TypeCode.Double: break;
         default: 
           this.HandleError(lit, Error.NoImplicitConversion, this.GetTypeName(sourceType), this.GetTypeName(targetType));
           lit.SourceContext.Document = null;
           return null;
       }
       break;
     case TypeCode.Int64:
     case TypeCode.UInt64:
       switch (targetType.TypeCode){
         case TypeCode.Int64: 
         case TypeCode.UInt64:
         case TypeCode.Decimal:
         case TypeCode.Single:
         case TypeCode.Double:
           break;
         default: 
           if (explicitCoercion || !lit.TypeWasExplicitlySpecifiedInSource) break;
           this.HandleError(lit, Error.NoImplicitConversion, this.GetTypeName(sourceType), this.GetTypeName(targetType));
           lit.SourceContext.Document = null;
           return null;
       }
       break;
   }
   try{
     if (val == null){
       if (targetType.IsValueType) goto error;
     }else
       val = System.Convert.ChangeType(val, targetType.TypeCode);
     return new Literal(val, targetType, lit.SourceContext);
   }catch(InvalidCastException){
   }catch(OverflowException){
   }catch(FormatException){}
 error:
   if (sourceType.IsPrimitiveNumeric && lit.SourceContext.Document != null){
     Error e = Error.ConstOutOfRange;
     if (explicitCoercion) e = Error.ConstOutOfRangeChecked;
     this.HandleError(lit, e, lit.SourceContext.SourceText, this.GetTypeName(targetType));
   }else
     this.HandleError(lit, Error.NoImplicitConversion, this.GetTypeName(sourceType), this.GetTypeName(targetType));
   if (this.ErrorHandler != null) lit.SourceContext.Document = null;
   return null;
 }
Exemplo n.º 10
0
 private Parameter ParseParameter(TokenSet followers, bool allowRefParameters, bool namesAreOptional, bool typesAreOptional){
   Parameter p = new Parameter();
   p.SourceContext = this.scanner.CurrentSourceContext;
   Token tok = this.currentToken;
   p.Attributes = this.ParseAttributes(null, followers|Parser.ParameterTypeStart);
   p.Flags = ParameterFlags.None;
   bool byRef = false;
   switch(this.currentToken){
     case Token.Out:
       //TODO: error if !allowRefParameters && typesAreOptional
       p.Flags = ParameterFlags.Out;
       goto case Token.Ref;
     case Token.Ref:
       //TODO: error if !allowRefParameters && typesAreOptional
       if (!allowRefParameters)
         this.HandleError(Error.IndexerWithRefParam);
       byRef = true;
       this.GetNextToken();
       if (this.currentToken == Token.Params){
         this.HandleError(Error.ParamsCantBeRefOut);
         this.GetNextToken();
       }
       break;
     case Token.Params:
       //TODO: error if !allowRefParameters && typesAreOptional
       Literal lit = new Literal(TypeExpressionFor("System", "ParamArrayAttribute"), null, this.scanner.CurrentSourceContext);
       AttributeNode paramsAttribute = new AttributeNode(lit, null);
       if (p.Attributes == null) p.Attributes = new AttributeList(1);
       p.Attributes.Add(paramsAttribute);
       this.GetNextToken();
       if (this.currentToken == Token.Out || this.currentToken == Token.Ref){
         this.HandleError(Error.ParamsCantBeRefOut);
         if (this.currentToken == Token.Out) goto case Token.Out;
         goto case Token.Ref;
       }
       break;
   }
   bool voidParam = false;
   if (this.currentToken == Token.Void){
     if (this.inUnsafeCode){
       TypeNode voidT = this.TypeExpressionFor(Token.Void);
       SourceContext sctx = this.scanner.CurrentSourceContext;
       this.GetNextToken();
       sctx.EndPos = this.scanner.endPos;
       this.Skip(Token.Multiply);
       p.Type = p.TypeExpression = new PointerTypeExpression(voidT, sctx);
     }else{
       this.HandleError(Error.NoVoidParameter);
       p.Type = this.TypeExpressionFor(Token.Object);
       p.TypeExpression = new TypeExpression(this.scanner.GetIdentifier(), this.scanner.CurrentSourceContext);
       this.GetNextToken();
       voidParam = true;
     }
   }else if (this.currentToken == Token.Delegate)
     p.Type = p.TypeExpression = this.ParseDelegateDeclaration(null, null, null, TypeFlags.None, p.SourceContext, followers);
   else if (p.Type == null){
     p.Type = p.TypeExpression = this.ParseTypeExpression(null, followers|Parser.IdentifierOrNonReservedKeyword);
   }
   if (byRef) p.Type = p.TypeExpression = new ReferenceTypeExpression(p.Type);
   if ((this.currentToken == Token.Comma || this.currentToken == Token.RightParenthesis) && p.TypeExpression is TypeExpression &&
     ((TypeExpression)p.TypeExpression).Expression is Identifier && typesAreOptional) {
     p.Name = (Identifier)((TypeExpression)p.TypeExpression).Expression;
     p.Type = p.TypeExpression = null;
   }else{
     p.Name = this.scanner.GetIdentifier();
   }
   p.SourceContext.EndPos = this.scanner.endPos;
   if (!voidParam || Parser.IdentifierOrNonReservedKeyword[this.currentToken]){
     if (Parser.IdentifierOrNonReservedKeyword[this.currentToken])
       this.GetNextToken();
     else{
       if (namesAreOptional)
         p.Name = Identifier.Empty;
       else
         this.SkipIdentifierOrNonReservedKeyword();
     }
   }
   if (this.currentToken == Token.LeftBracket){
     this.HandleError(Error.BadArraySyntax);
     int endPos = this.scanner.endPos;
     int rank = this.ParseRankSpecifier(true, followers|Token.LeftBracket);
     if (rank > 0)
       p.Type = p.TypeExpression = this.ParseArrayType(rank, p.Type, followers);
     else{
       this.currentToken = Token.LeftBracket;
       this.scanner.endPos = endPos;
       this.GetNextToken();
       while (!this.scanner.TokenIsFirstAfterLineBreak &&
         this.currentToken != Token.RightBracket && this.currentToken != Token.Comma && this.currentToken != Token.RightParenthesis)
         this.GetNextToken();
       if (this.currentToken == Token.RightBracket) this.GetNextToken();
     }
   }else if (this.currentToken == Token.Assign){
     this.HandleError(Error.NoDefaultArgs);
     this.GetNextToken();
     if (Parser.UnaryStart[this.currentToken]){
       this.ParseExpression(followers);
       return p;
     }
   }
   this.SkipTo(followers);
   return p;
 }
Exemplo n.º 11
0
        /// <summary>
        /// Returns the invariant condition or null if statement is not invariant method call
        /// </summary>
        /// <param name="name">Optional string of invariant</param>
        public Expression IsInvariant(Statement s, out Literal name, out Literal sourceText)
        {
            name = null;
            sourceText = null;
            if (s == null) return null;

            ExpressionStatement es = s as ExpressionStatement;
            if (es == null) return null;

            MethodCall mc = es.Expression as MethodCall;
            if (mc == null) return null;

            MemberBinding mb = mc.Callee as MemberBinding;
            if (mb == null) return null;

            Method m = mb.BoundMember as Method;
            if (m == null) return null;

            if (this.IsInvariantMethod(m))
            {
                if (mc.Operands.Count > 1)
                {
                    name = mc.Operands[1] as Literal;
                }

                if (mc.Operands.Count > 2)
                {
                    sourceText = mc.Operands[2] as Literal;
                }

                return mc.Operands[0];
            }
            
            return null;
        }
Exemplo n.º 12
0
    //HS D
    private BlockHole ParseBlockHole(TokenSet followers){	
	Debug.Assert(this.currentToken == Token.Hole);
	Hashtable templateParams = new Hashtable();
	this.GetNextToken();
	this.Skip(Token.LeftBrace);
	if (this.currentToken != Token.RightBrace){
	    string templateParam = this.scanner.GetTokenSource();
	    this.GetNextToken();
	    this.Skip(Token.Colon);
	    Expression templateParamVal = 
		this.currentToken == Token.IntegerLiteral ? this.ParseIntegerLiteral() : 
		(this.currentToken == Token.RealLiteral ? 
		 this.ParseRealLiteral() : this.ParseCommaSeparetedIdentifierSet());
	    templateParams[templateParam] = templateParamVal;
	    while (this.currentToken == Token.Comma){
		this.GetNextToken();
		templateParam = this.scanner.GetTokenSource();
		this.GetNextToken();
		this.Skip(Token.Colon);
		templateParamVal = 
		    this.currentToken == Token.IntegerLiteral ? this.ParseIntegerLiteral() : 
		    (this.currentToken == Token.RealLiteral ? 
		     this.ParseRealLiteral() : this.ParseCommaSeparetedIdentifierSet());
		templateParams[templateParam] = templateParamVal;
	    }
	}
	this.Skip(Token.RightBrace);
	Literal one = new Literal(1);
	ConstructArray empty = new ConstructArray();
	Literal repeat = templateParams.ContainsKey("repeat") ? (Literal) templateParams["repeat"] : one;
	Literal ifbranches = templateParams.ContainsKey("ifbranches") ? (Literal) templateParams["ifbranches"] : one;
	Literal branchops = templateParams.ContainsKey("branchops") ? (Literal) templateParams["branchops"] : one;
	Literal conjunctions = templateParams.ContainsKey("conjunctions") ? (Literal) templateParams["conjunctions"] : one;
	ConstructArray ops = templateParams.ContainsKey("ops") ? (ConstructArray) templateParams["ops"] : empty;
	ConstructArray condvars = templateParams.ContainsKey("condvars") ? (ConstructArray) templateParams["condvars"] : empty;
	ConstructArray argvars = templateParams.ContainsKey("argvars") ? (ConstructArray) templateParams["argvars"] : empty;
	SourceContext sctx = this.scanner.CurrentSourceContext;
	BlockHole result = new BlockHole(sctx, repeat, ifbranches, branchops, conjunctions, ops, condvars, argvars); //, this.currMethod, opMethods); 
	result.SourceContext = sctx;
	//HS D: HACK FIXME	
	DefineBlockHoleMethod(this.currentTypeNode);

	return result;
    }
Exemplo n.º 13
0
    public ValidationState CheckExpression(Expression litExpr, TypeNode ceType, System.Compiler.TypeSystem typeSystem, Hashtable schemaElementDeclCache) {
      TypeNode litType = litExpr.Type;
      Error e = Error.None;

      if (typeSystem.ImplicitCoercionFromTo(litExpr, litType, schemaType)) {
        context.HasMatched = true;
        return context;
      }

      if (validator != null ){
 
        if (litType.IsPrimitive || litType is ArrayType || validator is AllElementsContentValidator) {

          Member schElemMember = null;
          TypeNode schElemType = null;
          TerminalNode node = null;

          // See if any of the expected elements can be coerced 
          // into the given type and pick the first match.
          // Throw an error if there's multiple fields that match.
          ArrayList list = (validator != null) ? validator.ExpectedElements(context, false, false) : null;
          TerminalNode bestNode = null;
          if (list != null) {
            foreach (TerminalNode n in list) {
              Member mem = n.Member;
              TypeNode memType = n.TypeNode;     
              if (memType is TypeUnion) {
                memType = ((Method)mem).ReturnType;
              }
            
              if (memType != null) {
                // Special case for string to char conversion.
                if (memType == SystemTypes.Char && litExpr is Literal) 
                {
                  Literal lit = (Literal)litExpr;
                  if (lit.Type == SystemTypes.String) 
                  {
                    string value = (string)lit.Value;
                    if (value.Length == 1) 
                    {
                      litExpr = new Literal(value[0], SystemTypes.Char, litExpr.SourceContext);
                      litType = SystemTypes.Char;
                    }
                  }
                }
                if ((mem is Method && // we are assigning to a collection
                    typeSystem.ImplicitCoercionFromTo(litExpr, ceType, memType)) || 
                    typeSystem.ImplicitCoercionFromTo(litExpr, litType, memType)) {
                  if (bestNode != null) {
                    if (typeSystem.IsBetterMatch(memType, bestNode.TypeNode, ceType) ||
                      typeSystem.IsBetterMatch(memType, bestNode.TypeNode, litType)) {
                      bestNode = n;
                      e = Error.None; // cancel any prior errors.
                    } else {
                      e = Error.AmbiguousLiteralExpression;
                    }
                  } else {
                    bestNode = n;
                  }
                }
              }
            }
          }
          if (e == Error.None && bestNode != null) {
            node = bestNode;
            schElemMember = node.Member;
            schElemType = node.TypeNode;
          }
          if (node != null) {
            // This will assign the CurrentNode
            Identifier name = (node is NamedNode) ? ((NamedNode)node).Name : 
              ((schElemMember != null && !(schElemMember is Method)) ? schElemMember.Name : schElemType.Name);
            validator.ValidateElement(name, context);          
          } else if (e == Error.None) {
            if (list == null) {
              e = Error.InvalidElementContentNone;            
            } else {
              e = Error.InvalidContentExpecting;
            } 
          }
        } else {
          SchemaElementDecl sd = SchemaElementDecl.Compile(this.targetModule, litType, ceType, this.context.ErrorHandler, schemaElementDeclCache);
          SchemaValidator v = sd.CreateValidator(this.context.ErrorHandler);
          if (this.validator.ValidateExpression(this.context, v.validator) < 0) {            
            e = Error.InvalidContentExpecting;
          }
        }
      }
      if (e != Error.None) { 
        string currentElement = null;
        if (context.Name != null) {
          currentElement = context.Name.ToString();
        } else {
          TypeNode current = (this.context.CurrentNode == null) ? this.validator.RootType : this.context.CurrentNode.TypeNode;            
          if (current == null) current = this.schemaType;
          currentElement = ErrorHandler.GetTypeNameFor(current);
        }
        ArrayList list = validator.ExpectedElements(this.context, false, false);
        string arg = (list != null) ? validator.GetExpectedElements(list) : null;
        context.HandleError(this.RootNode, litExpr, e, currentElement, ErrorHandler.GetTypeNameFor(litType), arg);
      }
      return context;
    }
Exemplo n.º 14
0
 public override bool Matches(ContentNode other) {
   // This recurrsive search figures out whether something like (A|(B|C)) matches (B|(A|C))
   // by visiting all the members of the right hand side, then searching to see if the
   // left hand side "contains" that choice.  So it will also return true if "this" has
   // more choices than "other", which is what we want.  So (A|B) matches (A|B|C).
   if (other is TerminalNode) { 
     
     return Contains(this.LeftChild, other as TerminalNode) || 
            Contains(this.RightChild, other as TerminalNode);
   } else if (other is NopNode) {
     return this.Matches(((NopNode)other).Child);
   } if (other is ChoiceNode) {                
     ChoiceNode choice = other as ChoiceNode;
     Literal e = new Literal("", choice.TypeNode);
     ErrorHandler eh = new ErrorHandler(new ErrorNodeList());
     TypeSystem ts = new TypeSystem(eh);
     return (ts.ExplicitCoercion(e, this.TypeNode) != null);
     //return this.Matches(choice.LeftChild) && this.Matches(choice.RightChild);
   }
   return false;
 }
Exemplo n.º 15
0
 public Continue(Literal level)
     : base(NodeType.Continue)
 {
     this.Level = level;
 }
Exemplo n.º 16
0
 public override Literal ImplicitLiteralCoercion(Literal lit, TypeNode sourceType, TypeNode targetType, TypeViewer typeViewer) {
   return this.LiteralCoercion(lit, sourceType, targetType, false, targetType, typeViewer, false);
 }
Exemplo n.º 17
0
 private Expression ParseConditional(Expression condition, TokenSet followers){
   Debug.Assert(this.currentToken == Token.Conditional);
   this.GetNextToken();
   Expression trueExpr = this.ParseExpression(followers|Token.Colon);
   if (trueExpr == null) //Supply a dummy
     trueExpr = new Literal(null, null, this.scanner.CurrentSourceContext);
   Expression falseExpr;
   if (this.currentToken == Token.Colon){
     this.GetNextToken();
     falseExpr = this.ParseExpression(followers);
   }else{
     this.Skip(Token.Colon); //gives appropriate error message
     if (!followers[this.currentToken])
       //Assume that only the : is missing. Go ahead as if it were specified.
       falseExpr = this.ParseExpression(followers);
     else
       falseExpr = null;
   }
   if (falseExpr == null) //Supply a dummy
     falseExpr = new Literal(null, null, this.scanner.CurrentSourceContext);
   TernaryExpression result = new TernaryExpression(condition, trueExpr, falseExpr, NodeType.Conditional, null);
   result.SourceContext = condition.SourceContext;
   result.SourceContext.EndPos = falseExpr.SourceContext.EndPos;
   this.SkipTo(followers);
   return result;
 }
    protected override object VisitLoadNull(Variable dest, Literal source, Statement stat, object arg) {
      ExposureState estate=(ExposureState)arg;

      return arg;
    }
Exemplo n.º 19
0
    private Expression ParsePrimaryExpression(TokenSet followers){
      Expression expression = null;
      SourceContext sctx = this.scanner.CurrentSourceContext;
      switch(this.currentToken){
        case Token.ArgList:
          this.GetNextToken();
          expression = new ArglistExpression(sctx);
          break;
        case Token.Delegate:{
          this.GetNextToken();
          ParameterList parameters = null;
          if (this.currentToken == Token.LeftParenthesis)
            parameters = this.ParseParameters(Token.RightParenthesis, followers|Token.LeftBrace);
          Block block = null;
          if (this.currentToken == Token.LeftBrace)
            block = this.ParseBlock(this.scanner.CurrentSourceContext, followers);
          else
            this.SkipTo(followers, Error.ExpectedLeftBrace);
          sctx.EndPos = this.scanner.endPos;
          return new AnonymousNestedDelegate(parameters, block, sctx);}
        case Token.New:
          expression = this.ParseNew(followers|Token.Dot|Token.LeftBracket|Token.Arrow);
          break;
        case Token.Identifier:
          expression = this.scanner.GetIdentifier();
          if (this.sink != null) {
            this.sink.StartName((Identifier)expression);
          }
          this.GetNextToken();
          if (this.currentToken == Token.DoubleColon){
            this.GetNextToken();
            Identifier id = this.scanner.GetIdentifier();
            id.Prefix = (Identifier)expression;
            id.SourceContext.StartPos = expression.SourceContext.StartPos;
            expression = id;
            if (this.currentToken != Token.EndOfFile)
              this.GetNextToken();
          }else if (this.currentToken == Token.Lambda){
            Parameter par = new Parameter((Identifier)expression, null);
            par.SourceContext = expression.SourceContext;
            return this.ParseLambdaExpression(par.SourceContext, new ParameterList(par), followers);
          }
          break;
        case Token.Null:
          expression = new Literal(null, null, sctx);
          this.GetNextToken();
          break;
        case Token.True:
          expression = new Literal(true, null, sctx);
          this.GetNextToken();
          break;
        case Token.False:
          expression = new Literal(false, null, sctx);
          this.GetNextToken();
          break;
        case Token.CharLiteral:
          expression = new Literal(this.scanner.charLiteralValue, null, sctx);
          this.GetNextToken();
          break;
        case Token.HexLiteral:
          expression = this.ParseHexLiteral();
          break;
        case Token.IntegerLiteral:
          expression = this.ParseIntegerLiteral();
          break;
        case Token.RealLiteral:
          expression = this.ParseRealLiteral();
          break;
        case Token.StringLiteral:
          expression = this.scanner.GetStringLiteral();
          this.GetNextToken();
          break;
        case Token.This:
          expression = new This(sctx, false);
          if (this.sink != null) {
            this.sink.StartName(expression);
          }
          this.GetNextToken();
          if (this.currentToken == Token.LeftParenthesis
            && (this.inInstanceConstructor==BaseOrThisCallKind.None
            || this.inInstanceConstructor==BaseOrThisCallKind.InCtorBodyThisSeen)){
            QualifiedIdentifier thisCons = new QualifiedIdentifier(expression, StandardIds.Ctor, this.scanner.CurrentSourceContext);
            MethodCall thisConstructorCall = new MethodCall(thisCons, null, NodeType.Call);
            thisConstructorCall.SourceContext = sctx;
            SourceContext lpCtx = this.scanner.CurrentSourceContext;
            this.Skip(Token.LeftParenthesis);
            thisConstructorCall.Operands = this.ParseArgumentList(followers|Token.LeftBrace|Token.Semicolon, lpCtx, out thisConstructorCall.SourceContext.EndPos);
            expression = thisConstructorCall;
            this.inInstanceConstructor=BaseOrThisCallKind.InCtorBodyThisSeen;
            goto done;
          }
          break;
        case Token.Base:
          Base ba = new Base(sctx, false);
          expression = ba;
          if (this.sink != null) {
            this.sink.StartName(expression);
          }
          this.GetNextToken();
          if (this.currentToken == Token.Semicolon &&
            (this.inInstanceConstructor == BaseOrThisCallKind.ColonThisOrBaseSeen
            || this.inInstanceConstructor == BaseOrThisCallKind.None)) {
            // When there are non-null fields, then the base ctor call can happen only after they are
            // initialized.
            // In Spec#, we allow a base ctor call in the body of the ctor. But if someone is using
            // the C# comment convention, then they cannot do that.
            // So allow "base;" as a marker to indicate where the base ctor call should happen.
            // There may be an explicit "colon base call" or it may be implicit.
            //
            // Just leave expression as a bare "Base" node; later pipeline stages will all have
            // to ignore it. Mark the current ctor as having (at least) one of these bad boys
            // in it.
            ba.UsedAsMarker = true;
            this.currentCtor.ContainsBaseMarkerBecauseOfNonNullFields = true;
            goto done;
          }
          if (this.currentToken == Token.LeftParenthesis
            && (this.inInstanceConstructor==BaseOrThisCallKind.None
              || this.inInstanceConstructor==BaseOrThisCallKind.InCtorBodyBaseSeen)){
            QualifiedIdentifier supCons = new QualifiedIdentifier(expression, StandardIds.Ctor, this.scanner.CurrentSourceContext);
            MethodCall superConstructorCall = new MethodCall(supCons, null, NodeType.Call);
            superConstructorCall.SourceContext = sctx;
            SourceContext lpCtx = this.scanner.CurrentSourceContext;
            this.Skip(Token.LeftParenthesis);
            superConstructorCall.Operands = this.ParseArgumentList(followers|Token.LeftBrace|Token.Semicolon, lpCtx, out superConstructorCall.SourceContext.EndPos);
            expression = superConstructorCall;
            this.inInstanceConstructor=BaseOrThisCallKind.InCtorBodyBaseSeen;
            goto done;
          }
          break;
        case Token.Typeof:
        case Token.Sizeof:
        case Token.Default:{
          //if (this.currentToken == Token.Sizeof && !this.inUnsafeCode)
            //this.HandleError(Error.SizeofUnsafe);
          UnaryExpression uex = new UnaryExpression(null,
            this.currentToken == Token.Typeof ? NodeType.Typeof : this.currentToken == Token.Sizeof ? NodeType.Sizeof : NodeType.DefaultValue);
          uex.SourceContext = sctx;
          this.GetNextToken();
          this.Skip(Token.LeftParenthesis);
          TypeNode t = null;
          if (this.currentToken == Token.Void && uex.NodeType == NodeType.Typeof){
            t = this.TypeExpressionFor(Token.Void); this.GetNextToken();
          }else
            t = this.ParseTypeExpression(null, followers|Token.RightParenthesis, false, false, uex.NodeType == NodeType.Typeof);
          if (t == null){this.SkipTo(followers); return null;}
          uex.Operand = new MemberBinding(null, t, t.SourceContext, null);
          uex.Operand.SourceContext = t.SourceContext;
          uex.SourceContext.EndPos = this.scanner.endPos;
          this.Skip(Token.RightParenthesis);
          expression = uex;
          break;}
        case Token.Stackalloc:{
          this.GetNextToken();
          TypeNode elementType = this.ParseBaseTypeExpression(null, followers|Token.LeftBracket, false, false);
          if (elementType == null){this.SkipTo(followers); return null;}
          Token openingDelimiter = this.currentToken;
          if (this.currentToken != Token.LeftBracket){
            this.HandleError(Error.BadStackAllocExpr);
            if (this.currentToken == Token.LeftParenthesis) this.GetNextToken();
          }else
            this.GetNextToken();
          Expression numElements = this.ParseExpression(followers|Token.RightBracket|Token.RightParenthesis);
          sctx.EndPos = this.scanner.endPos;
          if (this.currentToken == Token.RightParenthesis && openingDelimiter == Token.LeftParenthesis)
            this.GetNextToken();
          else
            this.Skip(Token.RightBracket);
          this.SkipTo(followers);
          return new StackAlloc(elementType, numElements, sctx);}
        case Token.Checked:
        case Token.Unchecked:
          //TODO: use NodeType.SkipCheck and NodeType.EnforceCheck
          Block b = new Block(new StatementList(1), this.currentToken == Token.Checked, this.currentToken == Token.Unchecked, this.inUnsafeCode);
          b.SourceContext = sctx;
          this.GetNextToken();
          this.Skip(Token.LeftParenthesis);
          b.Statements.Add(new ExpressionStatement(this.ParseExpression(followers|Token.RightParenthesis)));
          this.Skip(Token.RightParenthesis);
          expression = new BlockExpression(b);
          expression.SourceContext = b.SourceContext;
          break;
        case Token.RefType:{
          this.GetNextToken();
          this.Skip(Token.LeftParenthesis);
          Expression e = this.ParseExpression(followers|Token.RightParenthesis);
          this.Skip(Token.RightParenthesis);
          expression = new RefTypeExpression(e, sctx);
          break;
        }
        case Token.RefValue:{
          this.GetNextToken();
          this.Skip(Token.LeftParenthesis);
          Expression e = this.ParseExpression(followers|Token.Comma);
          this.Skip(Token.Comma);
          TypeNode te = this.ParseTypeOrFunctionTypeExpression(followers|Token.RightParenthesis, false, true);
          Expression operand2 = new MemberBinding(null, te);
          if (te is TypeExpression)
            operand2.SourceContext = te.SourceContext;
          else
            operand2.SourceContext = sctx;
          this.Skip(Token.RightParenthesis);
          expression = new RefValueExpression(e, operand2, sctx);
          break;
        }
        case Token.Bool:
        case Token.Decimal:
        case Token.Sbyte:
        case Token.Byte:
        case Token.Short:
        case Token.Ushort:
        case Token.Int:
        case Token.Uint:
        case Token.Long:
        case Token.Ulong:
        case Token.Char:
        case Token.Float:
        case Token.Double:
        case Token.Object:
        case Token.String:
          MemberBinding mb = new MemberBinding(null, this.TypeExpressionFor(this.currentToken), sctx);
          this.GetNextToken();
          expression = this.ParseIndexerCallOrSelector(mb, followers);
          goto done;
        case Token.LeftParenthesis:
          expression = this.ParseParenthesizedExpression(followers|Token.Dot|Token.LeftBracket|Token.Arrow, true);
          break;
        default:
          if (Parser.IdentifierOrNonReservedKeyword[this.currentToken]) goto case Token.Identifier;
          if (Parser.InfixOperators[this.currentToken]){
            this.HandleError(Error.InvalidExprTerm, this.scanner.GetTokenSource());
            this.GetNextToken();
          }else
            this.SkipTo(followers|Parser.PrimaryStart, Error.InvalidExprTerm, this.scanner.GetTokenSource());
          if (Parser.PrimaryStart[this.currentToken]) return this.ParsePrimaryExpression(followers);
          goto done;
      }
      if (expression is Base && this.currentToken != Token.Dot && this.currentToken != Token.LeftBracket){
        this.HandleError(expression.SourceContext, Error.BaseIllegal);
        expression = null;
      }

      expression = this.ParseIndexerCallOrSelector(expression, followers|Token.AddOne|Token.SubtractOne);
      for(;;){
        switch(this.currentToken){
          case Token.AddOne:
          case Token.SubtractOne:
            SourceContext ctx = expression.SourceContext;
            ctx.EndPos = this.scanner.endPos;
            PostfixExpression pex = new PostfixExpression(expression, Parser.ConvertToBinaryNodeType(this.currentToken), ctx);
            this.GetNextToken();
            expression = pex;
            break;
          case Token.Dot:
            expression = this.ParseIndexerCallOrSelector(expression, followers|Token.AddOne|Token.SubtractOne);
            break;
          default:
            goto done;
        }
      }
      done:
        this.SkipTo(followers);
      return expression;
    }
Exemplo n.º 20
0
 private void WriteLiteral(Literal literal) {
     WriteLiteral(literal, true);
 }
Exemplo n.º 21
0
 private Literal ParseHexLiteral(){
   Debug.Assert(this.currentToken == Token.HexLiteral);
   string tokStr = this.scanner.GetTokenSource();
   SourceContext ctx = this.scanner.CurrentSourceContext;
   TypeCode tc = this.scanner.ScanNumberSuffix();
   Literal result;
   try{
     switch(tc){
       case TypeCode.Single:
       case TypeCode.Double:
       case TypeCode.Decimal:
         this.HandleError(Error.ExpectedSemicolon);
         goto default;
       default:
         ulong ul = UInt64.Parse(tokStr.Substring(2), System.Globalization.NumberStyles.HexNumber, null);
         if (ul <= int.MaxValue && tc == TypeCode.Empty)
           result = new Literal((int)ul);
         else if (ul <= uint.MaxValue && (tc == TypeCode.Empty || tc == TypeCode.UInt32))
           result = new Literal((uint)ul);
         else if (ul <= long.MaxValue && (tc == TypeCode.Empty || tc == TypeCode.Int64))
           result = new Literal((long)ul);
         else
           result = new Literal(ul);
         break;
     }
   }catch(OverflowException){
     this.HandleError(ctx, Error.IntOverflow);
     result = new Literal(0);
   }
   ctx.EndPos = this.scanner.endPos;
   result.SourceContext = ctx;
   result.TypeWasExplicitlySpecifiedInSource = tc != TypeCode.Empty;
   this.GetNextToken();
   return result;
 }
Exemplo n.º 22
0
        public override Expression VisitLiteral(Literal literal)
        {
            // TODO: probably need special cases here for the various integer & real types.
            // Also need to investigate quoting behavior in string literals.
            if (literal.Value == null)
                Write("null");
            else if (literal.Value is string)
                Write("@\"{0}\"", literal.Value.ToString().Replace("\"", "\"\""));
            else if (literal.Value is bool)
                Write(((bool)literal.Value) ? "true" : "false");
            else if (literal.Value is char)
                Write("'\\x{0:X4}'", ((ushort)(char)literal.Value));
            else if (literal.Value is TypeNode)
                this.VisitTypeReference((TypeNode)literal.Value);
            else if (literal.Type == SystemTypes.UInt64)
                Write("{0}ul", literal.Value);
            else
                Write("{0}", literal.Value);

            return literal;
        }
Exemplo n.º 23
0
 public Exit(Literal level)
     : base(NodeType.Exit)
 {
     this.Level = level;
 }
Exemplo n.º 24
0
    void AddWriteElement(StatementList statements, TypeNode referringType, Identifier writer, Identifier name, Expression src, TypeNode mt, bool emptyElementOnNull) {

      if (mt.Template == SystemTypes.GenericBoxed) {
        statements = AddCheckForNull(statements, Duplicate(src, referringType), mt);     
        mt = Checker.GetCollectionElementType(mt); // check for null and unbox 
        src = CastTo(src, mt); //unbox it
      }

      Literal nameLit = new Literal(name.ToString(), SystemTypes.String);
      Literal nsLit = (name.Prefix != null) ? new Literal(name.Prefix.Name, SystemTypes.String) : Literal.Null;

      if (!emptyElementOnNull) {
        statements = AddCheckForNull(statements, Duplicate(src, referringType), mt);         
      }
      if (!AddWriteSimpleType(mt, statements, referringType, writer, src, nameLit, nsLit)) {
        AddCallSerializer(mt, statements, src, writer, nameLit, nsLit);
      }

    }
Exemplo n.º 25
0
 void GetNameAndNamespace(TypeNode type, out Expression name, out Expression ns) {
   name = Literal.Null;
   ns = Literal.Null;
   if (!IsStructuralType(type)) {
     Identifier id = Checker.GetDefaultElementName(type);
     name = new Literal(id.Name, SystemTypes.String);
     if (id.Prefix != null) {
       ns = new Literal(id.Prefix.Name, SystemTypes.String);
     }
   }
 }
Exemplo n.º 26
0
    bool AddWriteSimpleType(TypeNode simpleType, StatementList statements, TypeNode referringType, Identifier writer, Expression src, Expression name, Expression ns) {

      Identifier method = null;
      TypeNode type = Unwrap(simpleType);

      ExpressionList args = new ExpressionList(src);

      if (type == SystemTypes.String) {
        method = Identifier.For("WriteString");
      } else if( type == SystemTypes.Boolean) {
        method = Identifier.For("WriteBoolean");
      } else if( type == SystemTypes.Int8) {
        method = Identifier.For("WriteSByte");
      } else if( type == SystemTypes.Char) {
        method = Identifier.For("WriteChar");
      } else if( type == SystemTypes.DateTime) {
        method = Identifier.For("WriteDateTime");
      } else if( type == SystemTypes.Decimal) {
        method = Identifier.For("WriteDecimal");
      } else if( type == SystemTypes.Double) {
        method = Identifier.For("WriteDouble");
      } else if( type == SystemTypes.Guid) {
        method = Identifier.For("WriteGuid");
      } else if( type == SystemTypes.Int16) {
        method = Identifier.For("WriteInt16");
      } else if( type == SystemTypes.Int32) {
        method = Identifier.For("WriteInt32");
      } else if( type == SystemTypes.Int64) {
        method = Identifier.For("WriteInt64");
      } else if( type == SystemTypes.UInt8) {
        method = Identifier.For("WriteByte");
      } else if( type == SystemTypes.Single) {
        method = Identifier.For("WriteSingle");
      } else if( type == SystemTypes.TimeSpan) {
        method = Identifier.For("WriteTimeSpan");
      } else if( type == SystemTypes.UInt16 ) {
        method = Identifier.For("WriteUInt16");
      } else if( type == SystemTypes.UInt32) {
        method = Identifier.For("WriteUInt32");
      } else if( type == SystemTypes.UInt64) {
        method = Identifier.For("WriteUInt64");
      } else {
        Expression conversion = GetConvertToString(type, src, false);
        if (conversion != null) {
          statements = AddCheckForNull(statements, Duplicate(src, referringType), type);
          method = Identifier.For("WriteString");
          args = new ExpressionList(conversion);
        } else {
          return false;
        } 
      }
    
      if (name != null) {        
        Identifier id = Checker.GetDefaultElementName(type);
        string defaultName = id.Name;
        string defaultNamespace = (id.Prefix != null) ? id.Prefix.Name : null;
        Expression localName = new Local(SystemTypes.String);
        Expression localNamespace = new Local(SystemTypes.String);
        Expression safeName = name;
        if (name is Literal) {
          if (name == Literal.Null) {
            localName =  new Literal(defaultName, SystemTypes.String);
            localNamespace = new Literal(defaultNamespace, SystemTypes.String);
          } else {
            localName = name;
            localNamespace = ns;
          }
        } else {
          If nameNull = new If(new BinaryExpression(name, Literal.Null, NodeType.Eq), new Block(new StatementList()), new Block(new StatementList()));
          nameNull.TrueBlock.Statements.Add(new AssignmentStatement(localName, new Literal(defaultName, SystemTypes.String)));
          nameNull.TrueBlock.Statements.Add(new AssignmentStatement(localNamespace, new Literal(defaultNamespace, SystemTypes.String)));
          nameNull.FalseBlock.Statements.Add(new AssignmentStatement(localName, name));
          nameNull.FalseBlock.Statements.Add(new AssignmentStatement(localNamespace, ns));
          statements.Add(nameNull);
        }

        MethodCall call = new MethodCall();
        call.Callee = new QualifiedIdentifier(writer,Identifier.For("WriteStartElement"));
        call.Operands = new ExpressionList();
        call.Operands.Add(localName);
        call.Operands.Add(localNamespace);
        statements.Add( new ExpressionStatement( call ) );
      }
      StatementList notNull = statements;
      if (!type.IsValueType) {
        notNull = AddCheckForNull(statements, Duplicate(src, referringType), type);
      }        
      notNull.Add(new ExpressionStatement(new MethodCall(new QualifiedIdentifier(writer, method), args)));

      if (name != null) {
        MethodCall call = new MethodCall();
        call.Callee = new QualifiedIdentifier(writer,Identifier.For("WriteEndElement"));
        call.Operands = new ExpressionList();
        statements.Add( new ExpressionStatement( call ) );      
      }
      return true;
    }
Exemplo n.º 27
0
        public override Expression VisitLiteral(Literal literal)
        {
            // All nulls get translated to our equivalent (zero)
            if (literal.Value == null)
                literal = new Literal(0, SystemTypes.UInt32);

            if (literal.Type != null && literal.Type is EnumNode)
            {
                // Enum field references get turned into constants by the resolver.
                // When they're referenced, we need to emit a suitable cast to make
                // them compatible with their intended usage.

                //    int EnumTypeRestoration = ((_enumType) _enumValue);
                Expression enumTypeRestore = Templates.GetExpressionTemplate("EnumTypeRestoration");
                Replacer.Replace(enumTypeRestore, "_enumType", literal.Type.Name);
                Replacer.Replace(enumTypeRestore, "_enumValue", literal);
                return enumTypeRestore;
            }

            return literal;
        }
Exemplo n.º 28
0
            public override Expression VisitMethodCall(MethodCall call)
            {
                var result = base.VisitMethodCall(call);

                call = result as MethodCall;
                if (call == null) return result;

                var mb = call.Callee as MemberBinding;

                if (IsInvariantCall(mb))
                {
                    if (1 < call.Operands.Count)
                    {
                        Member dummy;
                        this.userMessage = SanitizeUserMessageInternal(this.autoProp.Getter, call.Operands[1], out dummy);
                    }

                    if (2 < call.Operands.Count)
                    {
                        this.conditionString = call.Operands[2] as Literal;
                    }

                    return call.Operands[0];
                }

                if (call.Operands.Count != 0) return call; // only nullary properties.

                if (IsAutoPropGetterCall(mb))
                {
                    if (makeRequires)
                    {
                        return this.autoProp.Setter.Parameters[0];
                    }
                    
                    return new ReturnValue(autoProp.Type);
                }

                return result;
            }
Exemplo n.º 29
0
 public virtual Expression VisitLiteral(Literal literal)
 {
     return literal;
 }
Exemplo n.º 30
-1
 public override Invariant VisitInvariant(Invariant @invariant) {
   if (@invariant == null) return null;
   SourceContext sctx = @invariant.SourceContext;
   if (invariant.SourceConditionText != null)
   {
     this.sourceTextOfInvariant = invariant.SourceConditionText;
   }
   else if (sctx.IsValid && sctx.Document.Text != null && sctx.Document.Text.Source != null)
   {
     this.sourceTextOfInvariant = new Literal(sctx.Document.Text.Source, SystemTypes.String);
   } else {
     this.sourceTextOfInvariant = Literal.Null;
     //this.sourceTextOfInvariant = new Literal("No other information available", SystemTypes.String);
   }
   return base.VisitInvariant(@invariant);
 }