1 //------------------------------------------------------------------------------
2 // <copyright file="FilterException.cs" company="Microsoft">
3 //     Copyright (c) Microsoft Corporation.  All rights reserved.
4 // </copyright>
5 // <owner current="true" primary="true">Microsoft</owner>
6 // <owner current="true" primary="false">Microsoft</owner>
7 // <owner current="false" primary="false">Microsoft</owner>
8 //------------------------------------------------------------------------------
9 
10 namespace System.Data {
11     using System;
12     using System.Diagnostics;
13     using System.Globalization;
14     using System.Runtime.Serialization;
15 
16     /// <devdoc>
17     ///    <para>[To be supplied.]</para>
18     /// </devdoc>
19     [Serializable]
20     public class InvalidExpressionException : DataException {
InvalidExpressionException(SerializationInfo info, StreamingContext context)21         protected InvalidExpressionException(SerializationInfo info, StreamingContext context)
22         : base(info, context) {
23         }
24 
25         /// <devdoc>
26         ///    <para>[To be supplied.]</para>
27         /// </devdoc>
InvalidExpressionException()28         public InvalidExpressionException() : base() {}
29         /// <devdoc>
30         ///    <para>[To be supplied.]</para>
31         /// </devdoc>
InvalidExpressionException(string s)32         public InvalidExpressionException(string s) : base(s) {}
33 
InvalidExpressionException(string message, Exception innerException)34         public InvalidExpressionException(string message, Exception innerException)  : base(message, innerException) {}
35     }
36 
37     /// <devdoc>
38     ///    <para>[To be supplied.]</para>
39     /// </devdoc>
40     [Serializable]
41     public class EvaluateException : InvalidExpressionException {
EvaluateException(SerializationInfo info, StreamingContext context)42         protected EvaluateException(SerializationInfo info, StreamingContext context)
43         : base(info, context) {
44         }
45         /// <devdoc>
46         ///    <para>[To be supplied.]</para>
47         /// </devdoc>
EvaluateException()48         public EvaluateException() : base() {}
49         /// <devdoc>
50         ///    <para>[To be supplied.]</para>
51         /// </devdoc>
EvaluateException(string s)52         public EvaluateException(string s) : base(s) {}
53 
EvaluateException(string message, Exception innerException)54         public EvaluateException(string message, Exception innerException)  : base(message, innerException) {}
55     }
56 
57     /// <devdoc>
58     ///    <para>[To be supplied.]</para>
59     /// </devdoc>
60     [Serializable]
61     public class SyntaxErrorException : InvalidExpressionException {
SyntaxErrorException(SerializationInfo info, StreamingContext context)62         protected SyntaxErrorException(SerializationInfo info, StreamingContext context)
63         : base(info, context) {
64         }
65 
66         /// <devdoc>
67         ///    <para>[To be supplied.]</para>
68         /// </devdoc>
SyntaxErrorException()69         public SyntaxErrorException() : base() {}
70         /// <devdoc>
71         ///    <para>[To be supplied.]</para>
72         /// </devdoc>
SyntaxErrorException(string s)73         public SyntaxErrorException(string s) : base(s) {}
74 
SyntaxErrorException(string message, Exception innerException)75         public SyntaxErrorException(string message, Exception innerException)  : base(message, innerException) {}
76     }
77 
78     internal sealed class ExprException {
ExprException()79         private ExprException() { /* prevent utility class from being insantiated*/ }
80 
_Overflow(string error)81         static private OverflowException _Overflow(string error) {
82             OverflowException e = new OverflowException(error);
83             ExceptionBuilder.TraceExceptionAsReturnValue(e);
84             return e;
85         }
_Expr(string error)86         static private InvalidExpressionException _Expr(string error) {
87             InvalidExpressionException e = new InvalidExpressionException(error);
88             ExceptionBuilder.TraceExceptionAsReturnValue(e);
89             return e;
90         }
_Syntax(string error)91         static private SyntaxErrorException _Syntax(string error) {
92             SyntaxErrorException e = new SyntaxErrorException(error);
93             ExceptionBuilder.TraceExceptionAsReturnValue(e);
94             return e;
95         }
_Eval(string error)96         static private EvaluateException _Eval(string error) {
97             EvaluateException e = new EvaluateException(error);
98             ExceptionBuilder.TraceExceptionAsReturnValue(e);
99             return e;
100         }
_Eval(string error, Exception innerException)101         static private EvaluateException _Eval(string error, Exception innerException) {
102             EvaluateException e = new EvaluateException(error/*, innerException*/); //
103             ExceptionBuilder.TraceExceptionAsReturnValue(e);
104             return e;
105         }
106 
InvokeArgument()107         static public Exception InvokeArgument() {
108             return ExceptionBuilder._Argument(Res.GetString(Res.Expr_InvokeArgument));
109         }
110 
NYI(string moreinfo)111         static public Exception NYI(string moreinfo) {
112             string err = Res.GetString(Res.Expr_NYI, moreinfo);
113             Debug.Fail(err);
114             return _Expr(err);
115         }
116 
MissingOperand(OperatorInfo before)117         static public Exception MissingOperand(OperatorInfo before) {
118             return _Syntax(Res.GetString(Res.Expr_MissingOperand, Operators.ToString(before.op)));
119         }
120 
MissingOperator(string token)121         static public Exception MissingOperator(string token) {
122             return _Syntax(Res.GetString(Res.Expr_MissingOperand, token));
123         }
124 
TypeMismatch(string expr)125         static public Exception TypeMismatch(string expr) {
126             return _Eval(Res.GetString(Res.Expr_TypeMismatch, expr));
127         }
128 
FunctionArgumentOutOfRange(string arg, string func)129         static public Exception FunctionArgumentOutOfRange(string arg, string func) {
130             return ExceptionBuilder._ArgumentOutOfRange(arg, Res.GetString(Res.Expr_ArgumentOutofRange, func));
131         }
132 
ExpressionTooComplex()133         static public Exception ExpressionTooComplex() {
134             return _Eval(Res.GetString(Res.Expr_ExpressionTooComplex));
135         }
136 
UnboundName(string name)137         static public Exception UnboundName(string name) {
138             return _Eval(Res.GetString(Res.Expr_UnboundName, name));
139         }
140 
InvalidString(string str)141         static public Exception InvalidString(string str) {
142             return _Syntax(Res.GetString(Res.Expr_InvalidString, str));
143         }
144 
UndefinedFunction(string name)145         static public Exception UndefinedFunction(string name) {
146             return _Eval(Res.GetString(Res.Expr_UndefinedFunction, name));
147         }
148 
SyntaxError()149         static public Exception SyntaxError() {
150             return _Syntax(Res.GetString(Res.Expr_Syntax));
151         }
152 
FunctionArgumentCount(string name)153         static public Exception FunctionArgumentCount(string name) {
154             return _Eval(Res.GetString(Res.Expr_FunctionArgumentCount, name));
155         }
156 
MissingRightParen()157         static public Exception MissingRightParen() {
158             return _Syntax(Res.GetString(Res.Expr_MissingRightParen));
159         }
160 
UnknownToken(string token, int position)161         static public Exception UnknownToken(string token, int position) {
162             return _Syntax(Res.GetString(Res.Expr_UnknownToken, token, position.ToString(CultureInfo.InvariantCulture)));
163         }
164 
UnknownToken(Tokens tokExpected, Tokens tokCurr, int position)165         static public Exception UnknownToken(Tokens tokExpected, Tokens tokCurr, int position) {
166             return _Syntax(Res.GetString(Res.Expr_UnknownToken1, tokExpected.ToString(), tokCurr.ToString(), position.ToString(CultureInfo.InvariantCulture)));
167         }
168 
DatatypeConvertion(Type type1, Type type2)169         static public Exception DatatypeConvertion(Type type1, Type type2) {
170             return _Eval(Res.GetString(Res.Expr_DatatypeConvertion, type1.ToString(), type2.ToString()));
171         }
172 
DatavalueConvertion(object value, Type type, Exception innerException)173         static public Exception DatavalueConvertion(object value, Type type, Exception innerException) {
174             return _Eval(Res.GetString(Res.Expr_DatavalueConvertion, value.ToString(), type.ToString()), innerException);
175         }
176 
InvalidName(string name)177         static public Exception InvalidName(string name) {
178             return _Syntax(Res.GetString(Res.Expr_InvalidName, name));
179         }
180 
InvalidDate(string date)181         static public Exception InvalidDate(string date) {
182             return _Syntax(Res.GetString(Res.Expr_InvalidDate, date));
183         }
184 
NonConstantArgument()185         static public Exception NonConstantArgument() {
186             return _Eval(Res.GetString(Res.Expr_NonConstantArgument));
187         }
188 
InvalidPattern(string pat)189         static public Exception InvalidPattern(string pat) {
190             return _Eval(Res.GetString(Res.Expr_InvalidPattern, pat));
191         }
192 
InWithoutParentheses()193         static public Exception InWithoutParentheses() {
194             return _Syntax(Res.GetString(Res.Expr_InWithoutParentheses));
195         }
196 
InWithoutList()197         static public Exception InWithoutList() {
198             return _Syntax(Res.GetString(Res.Expr_InWithoutList));
199         }
200 
InvalidIsSyntax()201         static public Exception InvalidIsSyntax() {
202             return _Syntax(Res.GetString(Res.Expr_IsSyntax));
203         }
204 
Overflow(Type type)205         static public Exception Overflow(Type type) {
206             return _Overflow(Res.GetString(Res.Expr_Overflow, type.Name));
207         }
208 
ArgumentType(string function, int arg, Type type)209         static public Exception ArgumentType(string function, int arg, Type type) {
210             return _Eval(Res.GetString(Res.Expr_ArgumentType, function, arg.ToString(CultureInfo.InvariantCulture), type.ToString()));
211         }
212 
ArgumentTypeInteger(string function, int arg)213         static public Exception ArgumentTypeInteger(string function, int arg) {
214             return _Eval(Res.GetString(Res.Expr_ArgumentTypeInteger, function, arg.ToString(CultureInfo.InvariantCulture)));
215         }
216 
TypeMismatchInBinop(int op, Type type1, Type type2)217         static public Exception TypeMismatchInBinop(int op, Type type1, Type type2) {
218             return _Eval(Res.GetString(Res.Expr_TypeMismatchInBinop, Operators.ToString(op), type1.ToString(), type2.ToString()));
219         }
220 
AmbiguousBinop(int op, Type type1, Type type2)221         static public Exception AmbiguousBinop(int op, Type type1, Type type2) {
222             return _Eval(Res.GetString(Res.Expr_AmbiguousBinop, Operators.ToString(op), type1.ToString(), type2.ToString()));
223         }
224 
UnsupportedOperator(int op)225         static public Exception UnsupportedOperator(int op) {
226             return _Eval(Res.GetString(Res.Expr_UnsupportedOperator, Operators.ToString(op)));
227         }
228 
InvalidNameBracketing(string name)229         static public Exception InvalidNameBracketing(string name) {
230             return _Syntax(Res.GetString(Res.Expr_InvalidNameBracketing, name));
231         }
232 
MissingOperandBefore(string op)233         static public Exception MissingOperandBefore(string op) {
234             return _Syntax(Res.GetString(Res.Expr_MissingOperandBefore, op));
235         }
236 
TooManyRightParentheses()237         static public Exception TooManyRightParentheses() {
238             return _Syntax(Res.GetString(Res.Expr_TooManyRightParentheses));
239         }
240 
UnresolvedRelation(string name, string expr)241         static public Exception UnresolvedRelation(string name, string expr) {
242             return _Eval(Res.GetString(Res.Expr_UnresolvedRelation, name, expr));
243         }
244 
BindFailure(string relationName)245         static internal EvaluateException BindFailure(string relationName) {
246             return _Eval(Res.GetString(Res.Expr_BindFailure, relationName));
247         }
248 
AggregateArgument()249         static public Exception AggregateArgument() {
250             return _Syntax(Res.GetString(Res.Expr_AggregateArgument));
251         }
252 
AggregateUnbound(string expr)253         static public Exception AggregateUnbound(string expr) {
254             return _Eval(Res.GetString(Res.Expr_AggregateUnbound, expr));
255         }
256 
EvalNoContext()257         static public Exception EvalNoContext() {
258             return _Eval(Res.GetString(Res.Expr_EvalNoContext));
259         }
260 
ExpressionUnbound(string expr)261         static public Exception ExpressionUnbound(string expr) {
262             return _Eval(Res.GetString(Res.Expr_ExpressionUnbound, expr));
263         }
264 
ComputeNotAggregate(string expr)265         static public Exception ComputeNotAggregate(string expr) {
266             return _Eval(Res.GetString(Res.Expr_ComputeNotAggregate, expr));
267         }
268 
FilterConvertion(string expr)269         static public Exception FilterConvertion(string expr) {
270             return _Eval(Res.GetString(Res.Expr_FilterConvertion, expr));
271         }
272 
LookupArgument()273         static public Exception LookupArgument() {
274             return _Syntax(Res.GetString(Res.Expr_LookupArgument));
275         }
276 
InvalidType(string typeName)277         static public Exception InvalidType(string typeName) {
278             return _Eval(Res.GetString(Res.Expr_InvalidType, typeName));
279         }
280 
InvalidHoursArgument()281         static public Exception InvalidHoursArgument() {
282             return _Eval(Res.GetString(Res.Expr_InvalidHoursArgument));
283         }
284 
InvalidMinutesArgument()285         static public Exception InvalidMinutesArgument() {
286             return _Eval(Res.GetString(Res.Expr_InvalidMinutesArgument));
287         }
288 
InvalidTimeZoneRange()289         static public Exception InvalidTimeZoneRange() {
290             return _Eval(Res.GetString(Res.Expr_InvalidTimeZoneRange));
291         }
292 
MismatchKindandTimeSpan()293         static public Exception MismatchKindandTimeSpan() {
294             return _Eval(Res.GetString(Res.Expr_MismatchKindandTimeSpan));
295         }
296 
UnsupportedDataType(Type type)297         static public Exception UnsupportedDataType(Type type)
298         {
299             return ExceptionBuilder._Argument(Res.GetString(Res.Expr_UnsupportedType, type.FullName));
300         }
301     }
302 }
303