public void Print( mysToken output ) { if ( output != null ) { string outputstring = string.Join( ", ", output ); if ( outputstring != "" ) { Console.WriteLine( outputstring ); } } Console.WriteLine( "Ok.\n" ); }
public Type DeepType( Stack<mysSymbolSpace> spaceStack ) { mysToken temp = new mysToken( new mysSymbol( ToString() ) ); while ( temp.Type == typeof(mysSymbol) ) { // EvaluateSymbol clones the stack by itself temp = Value( spaceStack ); } return temp.Type; }
// arg 1 function // arg 2 instance (with . operator) // arg 3+ arguments public List<mysToken> Call( mysToken target, List<mysToken> arguments, mysState state, Stack<mysSymbolSpace> spaceStack ) { object targetObject = null; if ( target.Type != typeof(Type) ) { targetObject = target.Value; } List<object> realArguments = new List<object>(); foreach ( mysToken t in arguments ) { mysToken current = t; while ( current.Type == typeof(mysSymbol) ) { current = (current.Value as mysSymbol) .Value( spaceStack ); } realArguments.Add( current.Value ); } object result = method.Invoke( targetObject, realArguments.ToArray() ); if ( result == null ) { return null; } return new List<mysToken>() { Builtins.Clr.ClrTools.ConvertClrObject( result ) }; }
public static double Promote( mysToken n ) { if ( n.Type == typeof(int) ) return (int)n.Value; if ( n.Type == typeof(long) ) return (long)n.Value; if ( n.Type == typeof(float) ) return (float)n.Value; if ( n.Type == typeof(double) ) return (double)n.Value; throw new ArgumentException(); }
public void Define( mysSymbol symbol, mysToken value ) { Values[ symbol ] = value; }
// given a type from our sig, and the token supplied as a potential // argument, see if they match bool typeCheck( Type type, mysToken token, Stack<mysSymbolSpace> spaceStack ) { // we might need to do weird shit with symbols in here? // like, you should only really be able to send a quoted symbol // in (mainly for ease of reading the code, easy to see reasoning // etc., less likely for bugs to occur because of an accidental sig // match). bool plainAssignable = mysToken.AssignableFrom( type, token.Type ); bool complexAssignable = false; if ( token.Type == typeof(mysSymbol) && !token.Quoted ) { mysSymbol s = (token.Value as mysSymbol); Type t = s.DeepType( spaceStack ); if ( t != null ) { complexAssignable = mysToken.AssignableFrom( type, t ); } } return plainAssignable || complexAssignable; }
mysToken resolveClrMethod( Type targetType, string methodName ) { List<MethodInfo> variants = targetType .GetMethods() .Where( m => m.Name == methodName ) .ToList() ; int signatureLength = variants .Max( v => v.GetParameters().Length ); clrFunction f = null; for ( int j = signatureLength; j >= 0; j-- ) { List<mysToken> args = tokens .Skip( current + 2 ) .Take( j ) .ToList() ; f = clrFunctionGroup.Judge( variants, args, spaceStack ); if ( f != null ) { mysToken t = new mysToken( f ); // replace clrfg token with clrf token tokens.RemoveAt( current ); tokens.Insert( current, t ); return t; } } // maybe actually evaluate the function here?? idk return null; }
mysToken resolveClrConstructor( Type targetType ) { List<ConstructorInfo> variants = targetType .GetConstructors() .ToList() ; int signatureLength = variants .Max( v => v.GetParameters().Length ); ConstructorInfo ci; List<mysToken> args; for ( int j = signatureLength; j >= 0; j-- ) { args = tokens .Skip( current + 2 ) .Take( j ) .ToList() ; ci = clrFunctionGroup.Judge( variants, args, spaceStack ); if ( ci != null ) { mysToken t = new mysToken( ci.Invoke( args.Select( a => a.Value ).ToArray() ) ); // rem new-token, type-token, and args tokens.RemoveRange( current, args.Count + 2 ); tokens.Insert( current, t ); return t; } } return null; }