Example #1
0
		public CGExtern(CGExpr[] es)
			: base(es, null) {
			if (es.Length < 1) {
				errorValue = ErrorValue.argCountError;
			}
			else {
				CGTextConst nameAndSignatureConst = es[0] as CGTextConst;
				if (nameAndSignatureConst == null) {
					errorValue = ErrorValue.argTypeError;
				}
				else {
					try {
						// This retrieves the method from cache, or creates it:
						ef = ExternalFunction.Make(nameAndSignatureConst.value.value);
						if (ef.arity != es.Length - 1) {
							ef = null;
							errorValue = ErrorValue.argCountError;
						}
						else {
							resType = FromType(ef.ResType);
							argTypes = new Typ[ef.arity];
							for (int i = 0; i < argTypes.Length; i++) {
								argTypes[i] = FromType(ef.ArgType(i));
							}
						}
					}
					catch (Exception exn) // Covers a multitude of sins
					{
						errorValue = ErrorValue.Make(exn.Message);
					}
				}
			}
		}
Example #2
0
 public static ExternalFunction Make(String nameAndSignature)
 {
     ExternalFunction res;
       if (!cache.TryGetValue(nameAndSignature, out res)) {
     res = new ExternalFunction(nameAndSignature);
     cache.Add(nameAndSignature, res);
       }
       return res;
 }
Example #3
0
        // Before the call, tokens.Current is the first token of the type
        // to parse; and after the call it is the first token after that type.

        private static SdfType ParseOneType(IEnumerator <SigToken> tokens)
        {
            if (tokens.Current is LPar)
            {
                tokens.MoveNext();
                return(ParseFunctionSignature(tokens));
            }
            else if (tokens.Current is LBrk)
            {
                tokens.MoveNext();
                return(ParseArraySignature(tokens, 1));
            }
            else if (tokens.Current is LBre)
            {
                tokens.MoveNext();
                return(ParseArraySignature(tokens, 2));
            }
            else if (tokens.Current is TypenameToken)
            {
                TypenameToken token = tokens.Current as TypenameToken;
                tokens.MoveNext();
                switch (token.typename)
                {
                case "Z":
                    return(new SimpleType(typeof(System.Boolean)));

                case "C":
                    return(new SimpleType(typeof(System.Char)));

                case "B":
                    return(new SimpleType(typeof(System.SByte)));

                case "b":
                    return(new SimpleType(typeof(System.Byte)));

                case "S":
                    return(new SimpleType(typeof(System.Int16)));

                case "s":
                    return(new SimpleType(typeof(System.UInt16)));

                case "I":
                    return(new SimpleType(typeof(System.Int32)));

                case "i":
                    return(new SimpleType(typeof(System.UInt32)));

                case "J":
                    return(new SimpleType(typeof(System.Int64)));

                case "j":
                    return(new SimpleType(typeof(System.UInt64)));

                case "F":
                    return(new SimpleType(typeof(System.Single)));

                case "D":
                case "N":
                    return(new SimpleType(typeof(System.Double)));

                case "M":
                    return(new SimpleType(typeof(System.Decimal)));

                case "V":
                    return(new SimpleType(Value.type));

                case "W":
                    return(new SimpleType(typeof(void)));

                case "T":
                    return(new SimpleType(typeof(System.String)));

                case "O":
                    return(new SimpleType(typeof(System.Object)));

                default:
                    return(new SimpleType(ExternalFunction.FindType(token.typename)));
                }
            }
            else if (tokens.Current is Eof)
            {
                throw new SigParseException("Unexpected end of signature");
            }
            else
            {
                throw new SigParseException("Unexpected token " + tokens.Current);
            }
        }