Esempio n. 1
0
 public InvokeStatic(Object ID, MethodInfo mi)
 {
     _methodInfo = mi;
     _implictExecutive = false;
     ParameterInfo[] parameter_info = _methodInfo.GetParameters();
     List<Executive.Parameter> parameters = new List<Executive.Parameter>();
     foreach (ParameterInfo pi in parameter_info)
     {
         if (pi.IsByRefParameter())
             throw new ArgumentException("ByRef parameter is not allowed");
         Executive.Parameter p = new Executive.Parameter();
         p.Type = pi.ParameterType;
         if (pi.Position == 0 && pi.ParameterType == typeof(Executive))
         {
             object[] attrs = pi.GetCustomAttributes(true);
             foreach (object atr in attrs)
                 if (atr is ImplictAttribute)
                 {
                     _implictExecutive = true;
                     break;
                 }
             if (_implictExecutive)
                 continue;
         }
         else if (pi.ParameterType.IsArray && 
             pi.Position == parameter_info.Length - 1)
         {
             object[] attrs = pi.GetCustomAttributes(true);
             foreach (object atr in attrs)
                 if (atr is System.ParamArrayAttribute)
                 {
                     p.VariableParam = true;
                     p.Type = pi.ParameterType.GetElementType();
                     break;
                 }
         }
         parameters.Add(p);
     }
     Name = new FuncName(ID, parameters.ToArray());
 }
Esempio n. 2
0
 public void Register(object id, MethodInfo method)
 {
     bool context = false;
     XQueryFunctionRecord rec = new XQueryFunctionRecord();
     rec.id = id;
     object[] attrs = method.GetCustomAttributes(typeof(XQuerySignatureAttribute), false);
     XQuerySignatureAttribute sig = null;
     if (attrs.Length > 0)
         sig = (XQuerySignatureAttribute)attrs[0];
     ParameterInfo[] parameter_info = method.GetParameters();
     List<XQuerySequenceType> type_list = new List<XQuerySequenceType>();
     int implict = -1;
     foreach (ParameterInfo pi in parameter_info)
     {
         if (pi.ParameterType == typeof(IContextProvider))
         {
             if (context)
                 throw new ArgumentException(pi.Name);
             context = true;
             continue;
         }
         bool customized = false;
         bool variableParam = false;                
         object[] pi_attrs = pi.GetCustomAttributes(false);
         foreach (object pi_atr in pi_attrs)
         {
             if (pi_atr is System.ParamArrayAttribute)
                 variableParam = true;
             else if (pi_atr is ImplictAttribute)
             {
                 customized = true;
                 if (implict != -1)
                     throw new ArgumentException(pi.Name);
                 implict = pi.Position;
             }
             else
             {
                 XQueryParameterAttribute xattr = pi_atr as XQueryParameterAttribute;
                 if (xattr != null)
                 {
                     type_list.Add(new XQuerySequenceType(xattr.TypeCode, xattr.Cardinality, variableParam ?
                         pi.ParameterType.GetElementType() : pi.ParameterType));                            
                     customized = true;
                     break;
                 }
             }
         }
         if (!customized)
         {
             if (pi.ParameterType == typeof(XQueryNodeIterator))
                 type_list.Add(new XQuerySequenceType(XmlTypeCode.Item, XmlTypeCardinality.ZeroOrMore, pi.ParameterType));
             else
                 type_list.Add(new XQuerySequenceType(pi.ParameterType, XmlTypeCardinality.One));
         }
     }
     if (sig != null && sig.Return != XmlTypeCode.None)
         rec.returnType = new XQuerySequenceType(sig.Return, sig.Cardinality, method.ReturnType);
     else
     {
         if (method.ReturnType == typeof(XQueryNodeIterator))
             rec.returnType = new XQuerySequenceType(XmlTypeCode.Item, XmlTypeCardinality.ZeroOrMore, method.ReturnType);
         else
             rec.returnType = new XQuerySequenceType(method.ReturnType, XmlTypeCardinality.One);
     }
     if (sig != null)
     {
         rec.variableParams = sig.VariableParams;
         rec.validationReader = sig.ValidationReaderDemanded;
     }
     rec.parameters = type_list.ToArray();
     FunctionSocket sock = new FunctionSocket(rec);
     FunctionSocket next;
     if (m_table.TryGetValue(rec.id, out next))
     {
         FunctionSocket curr = next;
         while (curr != null)
         {
             if (curr.rec.parameters.Length == rec.parameters.Length &&
                 curr.rec.variableParams == rec.variableParams)
                 throw new InvalidOperationException(method.ToString());
             curr = curr.next;
         }
         sock.next = next;
     }
     m_table[rec.id] = sock;
     GlobalSymbols.DefineStaticOperator(rec.id, method);
     if (context)
     {
         object[] body;                 
         Executive.Parameter[] parameters;
         if (implict == -1)
         {
             parameters = new Executive.Parameter[parameter_info.Length - 1];
             body = new object[parameter_info.Length + 2];
         }
         else
         {
             parameters = new Executive.Parameter[parameter_info.Length - 2];
             body = new object[parameter_info.Length + 1];
         }
         int k = 0;
         int i = 2;
         body[0] = Funcs.List;
         body[1] = Lisp.List(Lisp.QUOTE, rec.id);
         foreach (ParameterInfo pi in parameter_info)
         {
             if (pi.Position != implict)
             {
                 if (pi.ParameterType != typeof(IContextProvider))
                 {
                     parameters[k] = new Executive.Parameter();
                     parameters[k].ID = ATOM.Create(String.Format("p{0}", k + 1));
                     parameters[k].Type = typeof(System.Object);
                     parameters[k].VariableParam = false;
                     body[i++] = parameters[k].ID;
                     k++;
                 }
                 else
                     body[i++] = Lisp.List(Lisp.QUOTE, ID.Context);
             }
         }
         GlobalSymbols.Defmacro(rec.id, parameters, Lisp.List(body));
     }
 }
Esempio n. 3
0
 private void ProcessFuncDecl(Notation notation, Notation.Record rec)
 {
     int stack_pos = _varTable.BeginFrame();
     FunctionDecl decl = _fdecl[rec.sym];
     Executive.Parameter[] executiveParameters = new Executive.Parameter[decl.parameters.Length];
     for (int k = 0; k < decl.parameters.Length; k++)
     {
         FunctionParameter p = decl.parameters[k];                
         executiveParameters[k].ID = p.id;
         executiveParameters[k].Type = p.type.ValueType;
         executiveParameters[k].VariableParam = false;
         _varTable.PushVar(p.id, p.type);
     }
     if (rec.args.Length > 3)
     {
         if (rec.args[3] == null) // external
             throw new NotImplementedException();
         else
         {
             XQueryExprBase expr = (XQueryExprBase)ProcessExpr(notation, rec.args[3]);
             object body = expr.ToLispFunction();
             if (decl.returnType != XQuerySequenceType.Item)
             {
                 XQuerySequenceType type = EvalExprType(body);
                 if (!decl.returnType.Equals(type))
                     body = Lisp.List(ID.CastArg, body, decl.returnType);
             }
             LambdaExpr lambdaExpr = new LambdaExpr(decl.f, executiveParameters, typeof(System.Object), body);
             _context.Engine.Defun(lambdaExpr);
         }
     }
     else
     {
         if (rec.args[2] == null) // external
             throw new NotImplementedException();
         else
         {
             XQueryExprBase expr = (XQueryExprBase)ProcessExpr(notation, rec.args[2]);
             LambdaExpr lambdaExpr = new LambdaExpr(decl.f, executiveParameters, typeof(System.Object),
                 expr.ToLispFunction());
             _context.Engine.Defun(lambdaExpr);
         }
     }
     _varTable.EndFrame(stack_pos);
 }
Esempio n. 4
0
 public static bool ForAny([Implict] Executive engine, Resultset rs, object param, object body)        
 {
     FunctionLink compiledBody = new FunctionLink();
     Executive.Parameter[] parameters = new Executive.Parameter[1];
     parameters[0].ID = param;
     parameters[0].Type = typeof(System.Object);
     object[] args = new object[1];
     while (rs.Begin != null)
     {
         Row row = rs.Dequeue();
         if (!row.HasNullValues)
         {
             if (row.Length == 1)
                 args[0] = row.ItemArray[0];
             else
                 args[0] = Lisp.List(row.ItemArray);
             object res = engine.Apply(null, parameters, body, args, compiledBody, engine.DefaultPool);
             if (res != null && res != Undefined.Value)
             {
                 rs.Cancel();
                 return true;
             }
         }
     }
     return false;
 }