public override Value Invoke( List Arguments )
{
var list = Arguments.GetValues();
if ( list[ 0 ] is Function ) onLoad = list[ 0 ] as Function;
if ( list[ 1 ] is Function ) onUpdate = list[ 1 ] as Function;
Firefly.Initialize( 800, 500, "Firefly Window", LoadEventInterface, true );
return this;
}
public override List<Token> Tokenize()
{
var returnList = new List<Token>();
for (TokenListNode node = list.First; node != null; node = node.Next)
{
returnList.AddRange(((Value) node.Value).Tokenize());
}
return returnList;
}
public Value Output( List Arguments )
{
foreach ( var val in Arguments.GetValues() )
{
Console.Write( val );
}
Console.WriteLine();
return NoValue.Value;
}
public Value SetPolygons( List Arguments )
{
var fillPolys = FilledPoly.ToArray<SLPolygon>();
var outlinePolys = OutlinePoly.ToArray<SLPolygon>();
Shape.FilledPolygons = new LinkedList<Polygon>( fillPolys.Select( X => X.Polygon ) );
Shape.OutlinePolygons = new LinkedList<Polygon>( outlinePolys.Select( X => X.Polygon ) );
Shape.SetPolygons();
return NoValue.Value;
}
public virtual Value Invoke( List Arguments )
{
if ( Identifiers.ContainsKey( "Constructor" ) )
{
Value constructor = Identifiers[ "Constructor" ].ReferencingValue;
if ( constructor is IInvokable )
{
( constructor as IInvokable ).Invoke( Arguments );
}
}
return this;
}
public override Value Invoke( List Arguments )
{
Shape = new ColoredShape();
Firefly.AddToRenderList( Shape );
FilledPoly = new Array();
OutlinePoly = new Array();
Identifiers[ "FilledPolygons" ] = new Reference( FilledPoly );
Identifiers[ "OutlinePolygons" ] = new Reference( OutlinePoly );
Identifiers[ "SetPolygons" ] = new Reference( new ExternalFunction( "SetPolygons", false, SetPolygons ) );
Identifiers[ "X" ] = new Reference( new ExternalProperty( "X", false, XChange, () => new Number( Shape.X ) ) );
Identifiers[ "Y" ] = new Reference( new ExternalProperty( "Y", false, YChange, () => new Number( Shape.Y ) ) );
Identifiers[ "Rotation" ] = new Reference( new ExternalProperty( "Rotation", false, X => Shape.Rotation = (float)( (Number)X ).Val, () => new Number( Shape.Rotation ) ) );
return this;
}
public override Value Invoke( List Arguments )
{
var list = Arguments.GetValues();
if ( list[ 0 ] is Boolean )
{
var temp = new List<float>();
for ( int i = 1 ; i < list.Count ; ++i )
{
if ( list[ i ] is Number ) temp.Add( (float)( (Number)list[ i ] ).Val );
}
Polygon = new Polygon( ( (Boolean)list[ 0 ] ).Val, temp.ToArray() );
} else throw new Exception( "First argument of the polygon constructor must be a boolean" );
return this;
}
public override Value Invoke( List Arguments )
{
if ( Arguments.Arr.Count == 3 )
{
var list = Arguments.GetValues();
Value first = list[ 0 ], second = list[ 1 ], third = list[ 2 ];
if ( first is Number && second is Number && third is Number )
{
red = first as Number;
green = second as Number;
blue = third as Number;
return this;
}
}
throw new Exception( "Color constructor takes 3 numbers" );
}
public Value LocationOf( List Arguments )
{
var adresses = Arguments.Arr.OfType<Reference>().Select( Reference => new Number( Reference.Index ) );
return new Array( adresses.Select( X => new Reference( X ) ).ToList() );
}
public static Value ParseInfixString( string Infix )
{
var tokens = new TokenList();
IEnumerable<string> array = SplitString( Infix );
foreach ( string str in array )
{
switch ( GetCharType( str[ 0 ] ) )
{
case ParseState.Letters:
if ( str[ 0 ] == '"' )
{
tokens.Add( new String( str.Substring( 1, str.Length - 2 ) ) );
} else
{
if ( Operators.OperatorDictionary.ContainsKey( str ) )
{
tokens.Add( (Token)Activator.CreateInstance( Operators.OperatorDictionary[ str ] ) );
} else
{
switch ( str )
{
case "true":
tokens.Add( new Boolean( true ) );
break;
case "false":
tokens.Add( new Boolean( false ) );
break;
default:
tokens.Add( new Identifier( str ) );
break;
}
}
}
break;
case ParseState.Numbers:
tokens.Add( new Number( double.Parse( str, CultureInfo.InvariantCulture ) ) );
break;
case ParseState.Signs:
string str1 = str;
Func<BracketType, bool> fn = ( X => Operators.RepresentationDictionary[ X.OpeningBracket ] == str1 );
if ( Operators.Brackets.Any( fn ) )
{
if ( str1 == "[" && !( tokens.Last.Value is Identifier ) && !( tokens.Last.Value is ParenthesisClosed ) ) tokens.Add( new MakeArray() );
else tokens.Add( (Token)Activator.CreateInstance( Operators.Brackets.First( fn ).SpecialOperator ) );
tokens.Add( new ParenthesisOpen() );
} else if ( Operators.Brackets.Any( X => Operators.RepresentationDictionary[ X.ClosingBracket ] == str1 ) )
{
tokens.Add( new ParenthesisClosed() );
} else
{
if ( tokens.Last.Value is Identifier && str1 == "(" )
{
tokens.Add( new InvokeOperator() );
tokens.Add( new ParenthesisOpen() );
} else if ( !( tokens.Last.Value is Number || tokens.Last.Value is ParenthesisClosed || tokens.Last.Value is Identifier ) && str1 == "-" )
{
tokens.Add( new Number( 0 ) );
tokens.Add( new Subtraction() );
} else if ( Operators.OperatorDictionary.ContainsKey( str1 ) )
{
tokens.Add( (Operator)Activator.CreateInstance( Operators.OperatorDictionary[ str1 ] ) );
} else
{
tokens.Add( new Unidentified() );
}
}
break;
}
}
originalTokenOrder = tokens.ToLinkedList().ToList();
Value test = Expression.CreateValueFromExpression( tokens );
return test;
}
private static IEnumerable<string> SplitString( string Exp )
{
int commentStart;
while ( ( commentStart = Exp.IndexOf( "//" ) ) != -1 )
{
int end = Exp.IndexOf( '\n', commentStart );
if ( end != -1 )
{
Exp = Exp.Remove( commentStart, end - commentStart );
} else Exp = Exp.Remove( commentStart );
}
var expression = new StringBuilder( Exp );
expression.Replace( '\n', ' ' );
expression.Replace( '\t', ' ' );
expression.Replace( '\r', ' ' );
expression.Replace( @"\n", '\n' + "" );
expression.Replace( @"\r", '\r' + "" );
expression.Replace( @"\t", '\t' + "" );
var alreadyDone = new List<bool>();
//Stores the already processed operators so the ones like ++ and + don't get processed twice
bool inQuote = false;
for ( int i = 0 ; i < expression.Length ; ++i ) //Quotation pass
{
if ( expression[ i ] == '"' ) inQuote = inQuote ? false : true;
if ( inQuote && expression[ i ] == ' ' ) expression[ i ] = (char)7;
alreadyDone.Add( inQuote );
}
for ( int i = 0 ; i < expression.Length ; ++i ) //Decimal number pass
{
if ( expression[ i ] == '.' && GetCharType( expression[ i - 1 ] ) == ParseState.Numbers &&
GetCharType( expression[ i + 1 ] ) == ParseState.Numbers )
{
alreadyDone[ i ] = true;
}
}
List<string> operatorList = Operators.RepresentationDictionary.Values.ToList();
operatorList.Sort( new Comparison<string>( ( X, Y ) => Y.Length - X.Length ) );
foreach ( var t in operatorList )
{
for ( int j = 0 ; j <= expression.Length - t.Length ; j++ )
{
if ( !alreadyDone[ j ] && expression.ToString( j, t.Length ) == t )
{
for ( int k = 0 ; k < t.Length ; ++k )
{
alreadyDone[ j + k ] = true;
}
alreadyDone.Insert( j + t.Length, true );
alreadyDone.Insert( j, true );
expression = expression.Insert( j + t.Length, " " );
expression = expression.Insert( j, " " );
}
}
}
var temp = new LinkedList<string>( expression.ToString().Split( new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries ) );
for ( LinkedListNode<string> node = temp.First ; node != null ; node = node.Next )
{
node.Value = node.Value.Replace( '\a', ' ' );
}
return temp;
}
public Value Random( List Arguments )
{
return new Number( random.NextDouble() );
}
public CodeBlock( List<Token> Code )
{
value = Code;
}
public Value Tan( List Arguments )
{
if ( Arguments.GetValue( 0 ) is Number )
return new Number( Math.Tan( ( (Number)Arguments.GetValue( 0 ) ).Val ) );
throw new Exception( "Tan function takes only a number" );
}
public static void Run( List<Token> Code )
{
StandardLibrary.Load();
Scope defaultScope = StandardLibrary.Library;
GlobalScope = defaultScope;
scopeList.AddLast( defaultScope );
Runtime = true;
timer = new Stopwatch();
timer.Start();
new CodeBlock( Code ).Run();
timer.Stop();
}
public Value Clear( List Arguments )
{
Console.Clear();
return NoValue.Value;
}
public Value Input( List Arguments )
{
return new String( Console.ReadLine() );
}
public Value Initialize( List Arguments )
{
return new SLWindow().Invoke( Arguments );
}
public Type( Type BaseClass, List<Token> Code )
: base(Code)
{
Identifiers = BaseClass.Identifiers.Clone();
Type = CodeBlockType.Type;
}
public CodeBlock( Expression Code )
{
value = Code.Tokenize();
}
public override List<Token> Tokenize()
{
var rpn = new List<Token>();
if ( op is DotOperator ) //Special case for the dot operator which needs to be arranged like a sufix unary
{
if ( first is Expression || first is ExpressionSequence ) rpn.AddRange( first.Tokenize() );
else rpn.Add( first );
rpn.Add( op );
if ( second is Expression || second is ExpressionSequence ) rpn.AddRange( second.Tokenize() );
else if ( !( second is NoValue ) ) rpn.Add( second );
} else
{
if ( first is Expression || first is ExpressionSequence ) rpn.AddRange( first.Tokenize() );
else rpn.Add( first );
if ( second is Expression || second is ExpressionSequence ) rpn.AddRange( second.Tokenize() );
else if ( !( second is NoValue ) ) rpn.Add( second );
rpn.Add( op );
}
return rpn;
}
public List( List<Value> List )
{
Arr = List;
}
