Stub in serialization context builder, with some explanation of what it's aimed at doing.

Author: jnthn

build/Makefile.in

@@ -67,6 +67,7 @@ HLL_SOURCES = \
   src/HLL/Actions.pm \
   src/HLL/Compiler.pm \
   src/HLL/CommandLine.pm \
+  src/HLL/SerializationContextBuilder.pm \
 
 P6REGEX_SOURCES = \
   src/Regex/P6Regex.pir \
@@ -114,6 +115,7 @@ HLLGRAMMAR_A    = gen/hllgrammar-actions.pir
 
 HLLCOMPILER_PIR = gen/hllcompiler.pir
 HLLCOMMANDLINE_PIR = gen/hllcommandline.pir
+HLLSERIALIZATIONCONTEXTBUILDER_PIR = gen/hllserializationcontextbuilder.pir
 
 P6REGEX_PBC     = P6Regex.pbc
 P6REGEX_G       = gen/p6regex-grammar.pir
@@ -257,6 +259,9 @@ $(STAGE1)/$(HLL_PBC): $(STAGE0_PBCS) $(HLL_SOURCES)
 	$(PARROT) --library=$(STAGE0) $(STAGE0)/$(NQP_PBC) \
 	    --target=pir --output=$(STAGE1)/$(HLLCOMMANDLINE_PIR) \
 	    src/HLL/CommandLine.pm
+	$(PARROT) --library=$(STAGE0) $(STAGE0)/$(NQP_PBC) \
+	    --target=pir --output=$(STAGE1)/$(HLLSERIALIZATIONCONTEXTBUILDER_PIR) \
+	    src/HLL/SerializationContextBuilder.pm
 	$(PARROT) --include=$(STAGE1) -o $(STAGE1)/$(HLL_PBC) \
 	    src/HLL.pir
 
@@ -310,6 +315,9 @@ $(STAGE2)/$(HLL_PBC): $(STAGE1_PBCS) $(HLL_SOURCES)
 	$(PARROT) --library=$(STAGE1) $(STAGE1)/$(NQP_PBC) \
 	    --target=pir --output=$(STAGE2)/$(HLLCOMMANDLINE_PIR) \
 	    src/HLL/CommandLine.pm
+	$(PARROT) --library=$(STAGE1) $(STAGE1)/$(NQP_PBC) \
+	    --target=pir --output=$(STAGE2)/$(HLLSERIALIZATIONCONTEXTBUILDER_PIR) \
+	    src/HLL/SerializationContextBuilder.pm
 	$(PARROT) --include=$(STAGE2) -o $(STAGE2)/$(HLL_PBC) \
 	    src/HLL.pir
 

src/HLL.pir

@@ -26,6 +26,7 @@ and HLL::Grammar.
 .include 'gen/hllgrammar-actions.pir'
 .include 'gen/hllcompiler.pir'
 .include 'gen/hllcommandline.pir'
+.include 'gen/hllserializationcontextbuilder.pir'
 
 .sub '' :anon :load :init
     $P0 = get_hll_global ['HLL'], 'Compiler'

src/HLL/SerializationContextBuilder.pm

@@ -0,0 +1,26 @@
+# A serialization context contains a bunch of objects that we want to persist
+# across the compile time / run time boundary.
+#
+# The long term goal is that we'll support actually serializing these in an
+# efficient way, and be able to do load-time linking between objects in
+# different libraries. For now, that's a lot of work, so we adopt a simpler
+# approach, in the hope that it will be upgradeable to a "full blown"
+# mechanism in the future.
+#
+# A serialization context is essentially made up of objects and "events" that
+# we perform on them. By performing an action on an object through the context
+# builder, it ensures that the action is performed both on the object now, and
+# also enough information is persisted to be able to re-create an object with
+# the same state. There are two common situations.
+#
+# 1) We compile some code and run it straight away. In this case, the objects
+#    have already been created, and we only need to do some fixing up.
+# 2) We compile some code and persist it as PIR. In this case, the objects need
+#    to be re-created by replaying the event stream that creates them.
+#
+# Essentially, we use PIR as our serialization language until we can do better.
+# Note that deserialization and installation aren't the same thing; the first
+# step sees us producing an array of objects, while the second is about putting
+# them in places the HLL can find them.
+class HLL::Compiler::SerializationContextBuilder {
+}