CompileExtensionPostfix.n

using Nemerle.Collections;
using Nemerle.Text;
using Nemerle.Utility;
using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;
using Nemerle.Compiler.Typedtree;

using System;
using System.Linq;
using SCG = System.Collections.Generic;

using Nemerle.Parser.Internal;

namespace Nemerle.Parser
{
  partial internal class RuleCompiler
  {
    public CompileExtensionPostfix(rd : RuleDefinition.ExtentionPostfix) : void
    {
      def className = _grammarCompiller.DecorateRuleClassName(rd);
      def returnType = _grammarCompiller.GetBaseRuleNType(rd);
      def makeBody(useResult)
      {
        def body = if (useResult)
        {
          def (varNames, setResult) = MakeHandlerCall(rd.rule);
          def subRulesCode = CompileRule(rd.rule, varNames);

          DefVars(varNames, <[
            mutable prefixResult = result;
            def newPos = $subRulesCode;
            if (newPos > 0)
              $setResult;
            else
              $(SetParsingErrorCode($"#$(rd.Name)"));
            newPos;
          ]>)
        }
        else
          <[
            $(CompileRule(rd.rule, []))
          ]>;

        <[
          unchecked // востановление после ошибок тут не нужно
          {         // оно будет произведено в точке расширения
            mutable c : char;
            _ = c; // eliminate warning "a local value c was never used"
            mutable isBest = false;
            $body;
          }
        ]>
      }

      def implClass = <[decl:
        public class $(className : dyn) : ExtensionPostfixBase[$(returnType : typed)]
        {
          private _grammar : $(_grammarCompiller.GrammarImplTB.ParsedTypeName);
          public this(grammar : IGrammar)
          {
            base($(rd.bindingPower : int), char.MinValue, char.MaxValue);//TODO:FIXME
            _grammar = grammar :> $(_grammarCompiller.GrammarImplTB.ParsedTypeName);
          }

          public override Descriptor : RuleDescriptor { get { GrammarDescriptorImpl.$(className : dyn).StaticDescriptor } }
        }
      ]>;
      def tb = _grammarCompiller.GrammarImplTB.DefineNestedType(implClass);
      //_ = tb.DefineWithSource(
      //  <[decl:
      //    public override Parse(pos : int, text : string) : int
      //    {
      //      $(makeBody(false))
      //    }
      //  ]>);

      _ = tb.DefineWithSource(
        <[decl:
          public override Parse(startPos : int, pos : int, text : string, bestOffsets : array[int], result : ref $(returnType : typed)) : int
          {
            _ = startPos; //TODO: узнать у хардкейса что там за химия с локейшенами
            $(makeBody(true))
          }
        ]>);
      tb.Compile();
    }
  }
}