Commit 4797228524e785f9c30759855da3b4adabc58078

Thomas Leonard
Mon Feb 22 13:32:14 CET 2010

Tree SHA1: f29db3c
Parent SHA1: b979de8 (Added <elang:interp.ELoaderAuthor>)
raw diff | raw patch

Updated ELoaderAuthor based on feedback from Kevin Reid

- safeScope no longer contains the extra bindings.
- Construct the new environments without using Scope.fromState.
- Use "env" instead of "scope" in a few places.
- Added nestOuter call, so that bindings can be overridden.

- <this> is not added automatically. Pass it explicitly if desired.
- getRoot() has been removed. Extra methods can be added to <this>
  by extending it and passing the new object as <this>.

Diff rendering mode:
inline
side by side


11	11	myObject in its safeScope:
12	12
13	13	? def myObject := 42
14		? def <loader> := makeELoader(<file:.>, [ => myObject ], "updoc$")
	14	? def <this> := makeELoader(<file:.>, [ => myObject, => <this> ], "updoc$")
15	15	# value: <loader>
16	16
17		Use the loader to load a test file:
	17	Use the this to load a test file. myObject is in the file's top-level environment:
18	18
19		? def obj := <loader:test/A>
	19	? def obj := <this:test/A>
20	20	# stdout: updoc$test/A: myObject == 42
21		# updoc$test/A: safeScope.myObject == 42
22	21	#
23	22
	23	However, myObject is not in A's safeScope:
	24
	25	? obj.getSafeScope()["myObject"]
	26	# problem: <NullPointerException: Internal: Variable definition not found: myObject>
	27
	28	safeScope does contain traceln:
	29
	30	? obj.getSafeScope()["traceln"]("Hi")
	31	# stdout: updoc$test/A: Hi
	32	#
	33
24	34	Check the loaded object has the correct type:
25	35
26	36	? obj.__getAllegedType().getFQName()
…	…
40	40
41	41	? def b := obj.loadB()
42	42	# stdout: updoc$test/B: B's myObject == 42
	43	# updoc$test/A: loaded B
43	44	#
44	45
45	46	# value: <objB>


5	5	pragma.syntax("0.9")
6	6
7	7	def eParser := <elang:syntax.makeEParser>
	8	def makeOuterNounExpr := <elang:evm.makeOuterNounExpr>
	9	def makeFinalPattern := <elang:evm.makeFinalPattern>
8	10
9	11	# These loaders are similar to the normal E <import> mechanism, except that
10	12	# they load code from a given directory rather than from classpath.
11	13	#
12		# You can specify extra bindings to be added to the scope of each imported file.
13		# This is useful for testing and for doing dependency injection. In addition,
14		# every loaded emaker file gets an extra <this> in scope, which is the loader
15		# itself. This allows it to import other files from the same module.
	14	# You can specify extra bindings to be added to the environment (scope) of each
	15	# imported file. This is useful for testing and for doing dependency injection.
16	16	#
17		# Notes:
	17	# By convention, these bindings include the loader itself as <this>, allowing a
	18	# file to import other files from the same module.
18	19	#
19		# - The loader will freely give out (a readonly version of) sourceDir to
20		# any emaker it loads that asks for it. This allows programs to find
21		# resource files (e.g. icons) easily.
22		#
23		# - Every file gets a scope that extends a single shared scope. The shared scope
24		# (which is the loader's own safeScope, plus scopeExtras) must not therefore
25		# contain objects that break confinement or confer authority, but this is not
26		# enforced.
	20	# envExtras should not contain objects that break confinement or confer
	21	# authority, but this is not enforced. Typically, they are all E loaders
	22	# themselves, giving modules access to their dependencies.
27	23	def loaderAuthor(makeScope, makeTraceln) {
28		return def makeLoader(var sourceDir, scopeExtras :Map, fqnPrefix :String) {
	24	return def makeLoader(sourceDir, envExtras :Map, fqnPrefix :String) {
29	25	#traceln(`creating loader for $fqnPrefix from $sourceDir`)
30	26
31		sourceDir := sourceDir.deepReadOnly()
	27	# There are several scope layouts:
	28	# - our safeScope's layout
	29	# - each loaded file's safeScope layout (with the file's FQName)
	30	# - defaultScopeLayout (containing envExtras's names)
	31	# - each loaded file's top-level scope layout (defaultScopeLayout + FQName)
32	32
33		def loader
34		def realScopeExtras := scopeExtras.with("this__uriGetter", loader)
35		def theScope := makeScope.fromState(safeScope.getState() \| realScopeExtras, fqnPrefix)
	33	# There are also several environments (scopes):
	34	# - our safeScope (from <import>; contains our private traceln)
	35	# - each loaded file's safeScope (contains the file's traceln)
	36	# - each loaded file's top-level scope (the file's safeScope + envExtras' values)
36	37
37		# Create an extension of SafeScope with the right FQName, so __getAllegedType works.
	38	# Create a ScopeLayout describing baseScope + envExtras
	39	def makeScopeLayout(baseScope, FQName) {
	40	var scopeLayout := baseScope.getScopeLayout()
	41
	42	var i := scopeLayout.getOuterCount()
	43	require(i >= 0)
	44	for name => value in envExtras {
	45	def nounExpr := makeOuterNounExpr(null, name, i, null)
	46	def nounPattern := makeFinalPattern(null, nounExpr, null, true, null)
	47	scopeLayout with= (name, nounPattern)
	48	i += 1
	49	}
	50
	51	return scopeLayout.nestOuter().withPrefix(FQName)
	52	}
	53
	54	def getEvalContext(scope) {
	55	# (passing 0 here is special; it returns the current context)
	56	# See: http://www.eros-os.org/pipermail/e-lang/2010-February/013448.html
	57	return scope.newContext(0)
	58	}
	59
	60	# Create an extension of baseScope with the extended layout,
	61	# and the right FQName (so __getAllegedType works).
38	62	def makeFileScope(baseScope, suffix) {
39	63	def fileFQName := fqnPrefix + suffix
40		def scopeLayout := baseScope.getScopeLayout().withPrefix(fileFQName + "$")
	64	def fileTraceln := makeTraceln(fileFQName)
41	65
42		def fileScope := baseScope.update(scopeLayout)
43		def evalContext := fileScope.newContext(0)
	66	# Create the file's safeScope object
	67	def safeOuters := getEvalContext(safeScope).outers()
	68	def fileSafeScopeLayout := safeScope.getScopeLayout().withPrefix(fileFQName + "$")
	69	def fileSafeScope := makeScope.outer(fileSafeScopeLayout, safeOuters)
44	70
45		# We need to override traceln in each new file's scope.
46		def safeScopeNoun := scopeLayout.getNoun("safeScope")
47		def tracelnNoun := scopeLayout.getNoun("traceln")
48		tracelnNoun.initFinal(evalContext, makeTraceln(fileFQName))
49		safeScopeNoun.initFinal(evalContext, fileScope)
	71	# Override traceln in the new safeScope
	72	def tracelnNoun := fileSafeScopeLayout.getNoun("traceln")
	73	tracelnNoun.initFinal(getEvalContext(fileSafeScope), fileTraceln)
50	74
	75	# Make fileSafeScope.safeScope point to itself
	76	def safeScopeNoun := fileSafeScopeLayout.getNoun("safeScope")
	77	safeScopeNoun.initFinal(getEvalContext(fileSafeScope), fileSafeScope)
	78
	79	# Create the file's top-level environment
	80	def fileScopeLayout := makeScopeLayout(baseScope, fileFQName + "$")
	81	def fileScope := baseScope.update(fileScopeLayout)
	82	def fileEvalContext := getEvalContext(fileScope)
	83
	84	# Override traceln in the new fileScope
	85	def fileTracelnNoun := fileScopeLayout.getNoun("traceln")
	86	fileTracelnNoun.initFinal(fileEvalContext, fileTraceln)
	87
	88	# Make fileSafeScope.safeScope point to the file's safeScope
	89	def fileScopeNoun := fileScopeLayout.getNoun("safeScope")
	90	fileScopeNoun.initFinal(fileEvalContext, fileSafeScope)
	91
	92	# Fill in the new slots with the values from envExtras
	93	for name => value in envExtras {
	94	def noun := fileScopeLayout.getNoun(name)
	95	noun.initFinal(fileEvalContext, value)
	96	}
	97
51	98	return fileScope
52	99	}
53	100
54		return bind loader {
	101	return def loader {
55	102	to get(name) {
56	103	def src := sourceDir[`$name.emaker`].getTwine()
57		return eParser(src).eval(makeFileScope(theScope, name))
	104	return eParser(src).eval(makeFileScope(safeScope, name))
58	105	}
59	106
60	107	to getWithBase(pathName, baseScope) {
61	108	def i := pathName.lastIndexOf1('.')
62	109	def name := pathName(0, i)
63	110	def src := sourceDir[pathName].getTwine()
64		def scope := makeScope.fromState(baseScope \| realScopeExtras, fqnPrefix)
65		return eParser(src).eval(makeFileScope(scope, name))
66		}
67
68		to getRoot() {
69		return sourceDir
	111	return eParser(src).eval(makeFileScope(baseScope, name))
70	112	}
71	113	}
72	114	}


1	1	traceln(`myObject == $myObject`)
2	2
3		safeScope["traceln"](`safeScope.myObject == ${safeScope["myObject"]}`)
4
5	3	def obj {
6	4	to loadB() {
7		return <this:test/B>
	5	def b := <this:test/B>
	6	traceln("loaded B")
	7	return b
	8	}
	9
	10	to getSafeScope() {
	11	return safeScope
8	12	}
9	13	}

Commit 4797228524e785f9c30759855da3b4adabc58078

Gitorious