/// <summary>
        /// File-in and process the actions contained in the node.
        /// </summary>
        /// <param name="processor">Interchange format processor responsible for the processing context.</param>
        /// <param name="parseErrorSink">Error sink for reporting parse errors.</param>
        /// <param name="sourceCodeService">Source code service that can convert tokens to source code span and reports issues.</param>
        /// <returns>Return an interchange unit node for annotation, usually just self.</returns>
        public override InterchangeUnitNode FileIn(InterchangeFormatProcessor processor, IParseErrorSink parseErrorSink, ISourceCodeReferenceService sourceCodeService)
        {
            if (processor == null)
                throw new ArgumentNullException("processor");
            if (parseErrorSink == null)
                throw new ArgumentNullException("parseErrorSink");
            if (sourceCodeService == null)
                throw new ArgumentNullException("sourceCodeService");
            // ALL instance vars must be set. If one is missing, then source code bug, and
            //   InterchangeFormatParser.ParseGlobalInitialization() should have reported the error.
            if (this.GlobalName == null)
                return this;

            // <globalValueInitialization> ::= <globalName> ’initializer’ <elementSeparator>
            //      <variableInitializer> <elementSeparator>
            // <variableInitializer> ::= <initializer definition>

            ISourceCodeReferenceService methodSourceCodeService;
            InitializerNode initializer = processor.ParseInitializer(out methodSourceCodeService);
            if (initializer == null)
                return this; // Processor/Parser should have reported errors
            if (!initializer.Accept(IronSmalltalk.Compiler.Visiting.ParseTreeValidatingVisitor.Current))
            {
                // We expect the parser to have reported the errors. Just in case, we do it once more to the installer.
                // Bad practice here is to use the 'processor.SourcePosition', but we don't have anything better :-/
                if (processor.ErrorSink != null)
                    processor.ErrorSink.AddInterchangeError(processor.SourcePosition, processor.SourcePosition, "Invalid initializer source code.");
                return this;
            }

            GlobalInitializer definition = new GlobalInitializer(
                processor.CreateSourceReference(this.GlobalName.Value, this.GlobalName, sourceCodeService),
                sourceCodeService,
                methodSourceCodeService,
                new AstIntermediateInitializerCode(initializer));
            this.Definfition = definition;
            // This may fail, but we don't care. If failed, it reported the error through its error sink.
            processor.FileInProcessor.FileInGlobalInitializer(definition);

            return this;
        }
Exemplo n.º 2
0
 /// <summary>
 /// Add a global initializer definition to the installation context.
 /// </summary>
 /// <param name="definition">Definition of the global initializer to be added.</param>
 public void AddGlobalInitializer(GlobalInitializer initializer)
 {
     this._initializers.Add(initializer);
 }