slisp/slisp.cpp at master · luis-l/slisp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

#include "slisp.h"
#include "Evaluator.h"
#include "Parser.h"
#include "SValue.h"
#include "Utility.h"

#include <filesystem>
#include <iostream>

void loadStandardLibrary( Environment& e, std::ostream& out )
{
  for ( const auto& dir : std::filesystem::recursive_directory_iterator( "standard" ) )
  {
    if ( dir.is_regular_file() && dir.path().extension() == ".slisp" )
    {
      auto root = makeDefaultSValue();
      root->cells()->append( makeSValue( dir.path().string() ) );
      SValue* result = evalLoad( e, root.get() );
      if ( result->isError() )
      {
        out << *result << '\n';
      }
    }
  }
}

Environment createDefaultEnvironment( std::ostream& out )
{
  Environment env;
  addCoreFunctions( env );
  try
  {
    loadStandardLibrary( env, out );
  }
  catch ( const std::exception& e )
  {
    out << e.what() << '\n';
  }
  return env;
}

class InteractiveEvaluator
{
public:
  void runInteractiveMode()
  {
    out << std::boolalpha;

    Environment env = createDefaultEnvironment( out );

    bool isDone = false;
    while ( !isDone )
    {
      out << ">> ";
      std::string input;
      std::getline( in, input );

      if ( input == "exit" )
      {
        isDone = true;
        out << "Exiting\n";
      }
      else if ( input == "env" )
      {
        // Special command to show the environment.
        out << env << '\n';
      }
      else if ( input.empty() )
      {
        // Ignore blanks.
        continue;
      }
      else
      {
        try
        {
          auto root = parse( input.cbegin(), input.cend() );
          out << "ast:\n";
          out << *root << '\n';
          //show( out, *root ) << '\n';

          auto result = evaluate( env, root.get() );
          show( out, *result ) << '\n';
        }
        catch ( const std::exception& e )
        {
          out << e.what() << '\n';
        }
      }
    }
  }

  std::ostream& out = std::cout;
  std::istream& in = std::cin;
};

int main( int argc, char** argv )
{
  if ( argc >= 2 )
  {
    Environment env = createDefaultEnvironment( std::cout );

    const std::string filename( argv[ 1 ] );
    auto root = makeDefaultSValue();
    root->cells()->append( makeSValue( filename ) );

    try
    {
      SValue* result = evalLoad( env, root.get() );
      show( std::cout, *result ) << '\n';
    }
    catch ( const std::exception& e )
    {
      std::cout << e.what() << '\n';
    }
  }
  else
  {
    std::cout << "*hxor's LISP v0.1\n";
    InteractiveEvaluator runner;
    runner.runInteractiveMode();
  }

  return 0;
}