Inheritance: IScheminType
Exemplo n.º 1
0
        public override IScheminType Execute(Environment env, Evaluator eval, ScheminList args)
        {
            ScheminVector vec = new ScheminVector();

            if ((args as ScheminList) != null)
            {
                ScheminList temp = (ScheminList) args;
                foreach (IScheminType type in temp)
                {
                    vec.List.Add(type);
                }
            }
            else
            {
                vec.List.Add(args);
            }

            return vec;
        }
Exemplo n.º 2
0
        public override IScheminType Execute(Environment env, Evaluator eval, ScheminPair args)
        {
            ScheminInteger len = (ScheminInteger) args.Car;
            IScheminType init = args.ListCdr().Car;

            ScheminVector vec = new ScheminVector();
            if (args.Length == 1)
            {
                ScheminPair empty = new ScheminPair();
                for (int i = 0; i < len.IntegerValue(); i++)
                {
                    vec.List.Add(empty);
                }
            }
            else
            {
                for (int i = 0; i < len.IntegerValue(); i++)
                {
                    vec.List.Add(init);
                }
            }

            return vec;
        }
Exemplo n.º 3
0
        private KeyValuePair<ScheminList, int> ParseInternal(List<Token> tokens, int startIndex)
        {
            ScheminList parsed = new ScheminList();

            while (startIndex < tokens.Count)
            {
                if (tokens[startIndex].Type == TokenType.VectorLiteral)
                {
                    if (tokens[startIndex + 1].Type == TokenType.OpenParen)
                    {
                        KeyValuePair<ScheminList, int> descended = ParseInternal(tokens, startIndex + 2);
                        ScheminVector vec = new ScheminVector();
                        foreach (IScheminType type in descended.Key)
                        {
                            type.Quote();
                            vec.List.Add(type);
                        }

                        parsed.Append(vec);
                        startIndex = descended.Value;
                    }

                }
                else if (tokens[startIndex].Type == TokenType.OpenParen)
                {
                    KeyValuePair<ScheminList, int> descended = ParseInternal(tokens, startIndex + 1);
                    parsed.Append(descended.Key);

                    startIndex = descended.Value;
                }
                else if (tokens[startIndex].Type == TokenType.CloseParen)
                {
                    break;
                }
                else if (tokens[startIndex].Type == TokenType.Quote)
                {
                    parsed.Append(new ScheminAtom("'"));
                }
                else if (tokens[startIndex].Type == TokenType.BackQuote)
                {
                    parsed.Append(new ScheminAtom("`"));
                }
                else if (tokens[startIndex].Type == TokenType.AtComma)
                {
                    parsed.Append(new ScheminAtom(",@"));
                }
                else if (tokens[startIndex].Type == TokenType.Comma)
                {
                    parsed.Append(new ScheminAtom(","));
                }
                else
                {
                    IScheminType converted = ConvertToken(tokens[startIndex]);
                    parsed.Append(converted);
                }

                startIndex++;
            }

            return new KeyValuePair<ScheminList, int>(parsed, startIndex);
        }