Class new title: MessageDict
	subclassof: HashSet
	fields: 'methods "<Vector of Strings> which are the compiled methods for each message"
		literals "<Vector of Vectors> which hold pointers to literals used in the methods"
		code "<Vector of Strings> which are the source text for each message"
		backpointers "<Vector of Vectors> which are the tables of text location vs pc for each message"'
	declare: ''

close | t1  
	[for t1 to: methods length do
		[methods  t1  nil  []
		self freeMethod: methods  t1].
	self init]

code [code]

code: t1 
	[NoteTaker  ['no code' asParagraph]
	code  (self findorerror: t1)]

code: t1 _ t2 
	[NoteTaker  [t2]
	code  self findorerror: t1 _ t2]

copyfrom: t1 
	[self objects_ t1 objects copy.
	methods _ t1 methods copy.
	code _ t1 code copy]

delete: t1 | t2 
	[t2 _ self findorerror: t1.
	self freeMethod: methods  t2.
	methods  t2 _ nil.
	[NoteTaker  []
	code  t2 _ nil].
	super delete: t1]

freeLiterals: t1 | t2 t3 t4  
	[t1 length = 0  []
	t2 _ t1 nail.
	for t3 to: t1 length do
		[t4 _ mem  (t2 + t3 - 1).
		t1  t3 _ nil.
		mem  t2 + t3 - 1 _ t4].
	t1 unNail]

freeMethod: t1 
	[t1  nil  []
	NoteTaker  [(nil swap [t1]) free]
	t1 refct > 2  [MethodKeeper next_ t1]
	self rawLiteralsIn: t1]

freeMethods | t1 t2  
	[t1 _ MethodKeeper contents.
	MethodKeeper _ (Vector new: 10) asStream.
	for t2 to: t1 length do
		[self freeMethod: t1  t2]]

growto: t1 | t2 t3 t4  
	[t3 _ MessageDict new init: t1.
	for t2 from: self do
		[t4 _ self findorerror: t2.
		t3 _ t3 insert: t2 method: methods  t4 literals: [literals  nil  [nil]
				literals  t4] code: [NoteTaker  [nil]
				code  t4] backpointers: nil].
	t3]

holdLiterals: t1 
	[NoteTaker  [t1]
	t1  nil  [t1]
	t1 length = 0  [t1]
	BitBlt new bltObj: t1 copy field: 1 to: t1 length fromObj: nil field: 0.
	t1]

holdMethods: t1 | t2  
	[for t2 to: t1 length do
		[self insert: t2 method: t1  t2 literals: nil code: nil backpointers: nil]]

init: t1 
	[methods _ Vector new: t1.
	[NoteTaker  []
	code _ Vector new: t1].
	super init: t1]

insert: t1 method: t2 literals: t3 code: t4 backpointers: t5 | t6 t7 
	[t6 _ self find: t1.
	t6 
		[self freeMethod: methods  t6.
		[NoteTaker  []
		self holdLiterals: t3].
		methods  t6 _ t2.
		NoteTaker  []
		code  t6 _ t4]
	t7 _ [self sparse  [self]
			self growto: methods length * 2].
	t7 objects  t7 findornil: t1 _ t1.
	t7 insert: t1 method: t2 literals: t3 code: t4 backpointers: t5]

invert: t1 | t2  
	[for t2 to: methods length do
		[methods  t2  t1  [objects  t2]].
	false]

literals: t1 
	[self literalsIn: methods  (self findorerror: t1)]

literalsIn: t1 
	[NoteTaker 
		[t1  nil  [Vector new: 0]
		t1 literals]
	self holdLiterals: (self rawLiteralsIn: t1)]

method: t1 
	[methods  (self findorerror: t1)]

methodorfalse: t1 | t2 
	[t2 _ self find: t1.
	t2  [methods  t2]
	false]

methods [methods]

purge: t1 
	[]

rawLiteralsIn: t1 | t2 t3 
	[t1  nil  [Vector new: 0]
	t1 length < 10  [Vector new: 0]
	t3 _ t1  6 - 6 / 2.
	t2 _ Vector new: (t3 max: 2).
	BitBlt new bltObj: t2 field: 1 to: t3 fromObj: t1 field: 4.
	t2]

swap: t1 with: t2 
	[methods swap: t1 with: t2.
	[NoteTaker  []
	code swap: t1 with: t2].
	super swap: t1 with: t2]