Use URLs instead of file paths for managing sources.

Author: objecthub

Sources/LispKit/Compiler/Scanner.swift

@@ -30,6 +30,9 @@ public final class Scanner {
   /// Input of source code
   private let input: TextInput
 
+  /// Source id of source code
+  internal let sourceId: UInt16
+  
   /// Buffer for characters read during one invocation of `next`
   private var buffer: ScanBuffer
 
@@ -49,13 +52,23 @@ public final class Scanner {
   internal var token: Token
 
   /// Creates a new scanner for the given string.
-  public convenience init(string: String, foldCase: Bool = false, prescan: Bool = true) {
-    self.init(input: TextInput(string: string), foldCase: foldCase, prescan: prescan)
+  public convenience init(string: String,
+                          sourceId: UInt16 = SourceManager.unknownSourceId,
+                          foldCase: Bool = false,
+                          prescan: Bool = true) {
+    self.init(input: TextInput(string: string),
+              sourceId: sourceId,
+              foldCase: foldCase,
+              prescan: prescan)
   }
 
   /// Creates a new scanner for the given string.
-  public init(input: TextInput, foldCase: Bool = false, prescan: Bool = true) {
+  public init(input: TextInput,
+              sourceId: UInt16 = SourceManager.unknownSourceId,
+              foldCase: Bool = false,
+              prescan: Bool = true) {
     self.input = input
+    self.sourceId = sourceId
     self.buffer = ScanBuffer()
     self.foldCase = foldCase
     self.pos = Position(1, 1)
@@ -76,6 +89,11 @@ public final class Scanner {
     }
   }
 
+  /// Returns the source position of the current token.
+  public var sourcePosition: SourcePosition {
+    return SourcePosition(self.sourceId, self.lpos.line, self.lpos.col)
+  }
+  
   /// Returns true if the current token has one of the given token kinds.
   public func hasToken(_ kind: TokenKind...) -> Bool {
     for k in kind {

Sources/LispKit/Compiler/SourcePosition.swift

@@ -65,10 +65,10 @@ public struct SourcePosition: Equatable, Hashable, CustomStringConvertible {
   }
 
   public func fullDescription(_ sourceManager: SourceManager) -> String {
-    guard let sourcePath = sourceManager.sourcePath(for: self.sourceId) else {
+    guard let sourceUrl = sourceManager.sourceUrl(for: self.sourceId) else {
       return self.description
     }
-    return "\(sourcePath) \(self.description)"
+    return "\(sourceUrl.lastPathComponent) \(self.description)"
   }
 
   public var description: String {

Sources/LispKit/Primitives/SystemLibrary.swift

@@ -84,6 +84,7 @@ public final class SystemLibrary: NativeLibrary {
     self.define(Procedure("trace-calls", self.traceCalls))
     self.define(Procedure("available-symbols", self.availableSymbols))
     self.define(Procedure("loaded-libraries", self.loadedLibraries))
+    self.define(Procedure("loaded-sources", self.loadedSources))
     self.define(Procedure("environment-info", self.environmentInfo))
     self.define("time", as: SpecialForm(self.compileTime))
     self.define(Procedure("seconds-from-gmt", self.secondsFromGmt))
@@ -446,6 +447,14 @@ public final class SystemLibrary: NativeLibrary {
     return res
   }
 
+  private func loadedSources() -> Expr {
+    var res = Expr.null
+    for url in self.context.sourceManager.sourceUrls {
+      res = .pair(.makeString(url.path), res)
+    }
+    return res
+  }
+  
   private func environmentInfo() -> Expr {
     context.console.print("OBJECT SIZES\n")
     context.console.print("  atom size          : \(MemoryLayout<Expr>.size) bytes\n")

Sources/LispKit/Runtime/SourceManager.swift

@@ -21,47 +21,70 @@
 import Foundation
 
 public final class SourceManager {
-  private var sources: [String]
-  private var sourceIds: [String: UInt16]
+  internal var sourceUrls: [URL]
+  private var sourceIds: [URL: UInt16]
 
   init() {
-    self.sources = ["console"]
+    self.sourceUrls = [URL(string: "console")!]
     self.sourceIds = [:]
   }
 
   public static let consoleSourceId: UInt16 = 0
   public static let unknownSourceId: UInt16 = UInt16.max
 
+  public func sourceId(for url: URL) -> UInt16? {
+    return self.sourceIds[self.absoluteUrl(url)]
+  }
+  
   public func sourceId(for path: String) -> UInt16? {
-    return self.sourceIds[path]
+    return self.sourceIds[self.absoluteUrl(path)]
   }
 
   public func obtainSourceId(for path: String) -> UInt16 {
-    if let id = self.sourceId(for: path) {
+    return self.obtainSourceId(for: URL(fileURLWithPath: path))
+  }
+  
+  public func obtainSourceId(for url: URL) -> UInt16 {
+    let canonicalUrl = self.absoluteUrl(url)
+    if let id = self.sourceIds[canonicalUrl] {
       return id
-    } else if self.sources.count == UInt16.max {
+    } else if self.sourceUrls.count == UInt16.max {
       return SourceManager.unknownSourceId
     } else {
-      self.sources.append(path)
-      return UInt16(self.sources.count - 1)
+      let newSourceId = UInt16(self.sourceUrls.count)
+      self.sourceUrls.append(canonicalUrl)
+      self.sourceIds[canonicalUrl] = newSourceId
+      return newSourceId
     }
   }
 
-  public func sourcePath(for sourceId: UInt16) -> String? {
+  public func sourceUrl(for sourceId: UInt16) -> URL? {
     guard sourceId != SourceManager.unknownSourceId else {
       return nil
     }
-    return self.sources[Int(sourceId)]
+    return self.sourceUrls[Int(sourceId)]
   }
 
   public func readSource(for sourceId: UInt16) throws -> String {
-    guard let sourcePath = self.sourcePath(for: sourceId) else {
+    guard let sourceUrl = self.sourceUrl(for: sourceId) else {
       throw EvalError.unknownFile("<path for source id = \(sourceId)>")
     }
-    return try String(contentsOfFile: sourcePath, encoding: String.Encoding.utf8)
+    return try String(contentsOf: sourceUrl)
+  }
+  
+  public func readSource(for url: URL) throws -> String {
+    return try self.readSource(for: self.obtainSourceId(for: url))
+  }
+  
+  public func readSource(for path: String) throws -> String {
+    return try self.readSource(for: self.obtainSourceId(for: path))
+  }
+  
+  private func absoluteUrl(_ url: URL) -> URL {
+    return url.standardizedFileURL.absoluteURL
   }
 
-  public func readSource(for filepath: String) throws -> String {
-    return try self.readSource(for: self.obtainSourceId(for: filepath))
+  private func absoluteUrl(_ path: String) -> URL {
+    return self.absoluteUrl(URL(fileURLWithPath: path))
   }
 }

Sources/LispKit/Runtime/VirtualMachine.swift

@@ -292,7 +292,7 @@ public final class VirtualMachine: TrackedObject {
                    in env: Env,
                    optimize: Bool = true,
                    foldCase: Bool = false) throws -> Expr {
-    return try self.eval(str: try String(contentsOfFile: path, encoding: String.Encoding.utf8),
+    return try self.eval(str: self.context.sourceManager.readSource(for: path),
                          in: env,
                          optimize: optimize,
                          inDirectory: self.context.fileHandler.directory(path),
@@ -349,7 +349,7 @@ public final class VirtualMachine: TrackedObject {
 
   /// Parses the given file and returns a list of parsed expressions.
   public func parse(file path: String, foldCase: Bool = false) throws -> Expr {
-    return try self.parse(str: try String(contentsOfFile: path, encoding: String.Encoding.utf8),
+    return try self.parse(str: self.context.sourceManager.readSource(for: path),
                           foldCase: foldCase)
   }
 
@@ -360,9 +360,8 @@ public final class VirtualMachine: TrackedObject {
 
   /// Parses the given string and returns an array of parsed expressions.
   public func parseExprs(file path: String, foldCase: Bool = false) throws -> Exprs {
-    return try self.parseExprs(
-      str: try String(contentsOfFile: path, encoding: String.Encoding.utf8),
-      foldCase: foldCase)
+    return try self.parseExprs(str: self.context.sourceManager.readSource(for: path),
+                               foldCase: foldCase)
   }
 
   /// Parses the given string and returns an array of parsed expressions.