Index 扉へ 首頁
人類の品種・宇宙人・系外銀河など
"Advanced" compiler of Simulang (source code)
0   商湯      2026年2月25日 水 11:18
Download source files:
http://www.jkofsp.net/files/
Please unzip bmp files from "@added-bmp-files.rar", then add these to "\bin\Debug\" or "\bin\Release\"

This "Advanced" version contains some syntax
of "cached...endcached" "state...endstate" "dif...enddiff"
(*see sample files ".sl")

<Simp.cs>

public static partial class Compiler
{

   public static void Simp(int endOfGlobal, ListEx<TokenLine> tokenLines)
   {
       ListEx<TokenLine> cacheds = new ListEx<TokenLine>();
       ListEx<TokenLine> cachedFlushes = new ListEx<TokenLine>();

       ListEx<TokenLine> states = new ListEx<TokenLine>();
       ListEx<TokenLine> stateInits = new ListEx<TokenLine>();
       ListEx<TokenLine> stateUpdates = new ListEx<TokenLine>();
       ListEx<TokenLine> stateFlushes = new ListEx<TokenLine>();

       ListEx<TokenLine> diffs = new ListEx<TokenLine>();
       ListEx<TokenLine> diffInits = new ListEx<TokenLine>();
       ListEx<TokenLine> diffUpdates = new ListEx<TokenLine>();
       ListEx<TokenLine> diffFlushes = new ListEx<TokenLine>();

       int i = endOfGlobal + 1;

   _Begin:
       if (i > tokenLines.Max)
           goto _Exit;

       if (tokenLines[i].Tokens[0].Type == TokenType.Key
           && (tokenLines[i].Tokens[0].Val == "endfunc"
               || tokenLines[i].Tokens[0].Val == "endcached"
               || tokenLines[i].Tokens[0].Val == "endstate"
               || tokenLines[i].Tokens[0].Val == "enddiff"))
           throw new MyException(tokenLines[i].Ln);
       else if (tokenLines[i].Tokens[0].Type == TokenType.Key && tokenLines[i].Tokens[0].Val == "func")
       {
           for (int j = i + 1; j <= tokenLines.Max; j++)
           {
               if (tokenLines[j].Tokens[0].Type == TokenType.Key && tokenLines[j].Tokens[0].Val == "func")
                   throw new MyException(tokenLines[j].Ln);
               if (tokenLines[j].Tokens[0].Type == TokenType.Key
                   && (tokenLines[j].Tokens[0].Val == "endcached"
                       || tokenLines[j].Tokens[0].Val == "endstate"
                       || tokenLines[j].Tokens[0].Val == "enddiff"))
                   throw new MyException(tokenLines[j].Ln);
               else if (tokenLines[j].Tokens[0].Type == TokenType.Key
                   && (tokenLines[j].Tokens[0].Val == "cached"
                       || tokenLines[j].Tokens[0].Val == "state"
                       || tokenLines[j].Tokens[0].Val == "diff"))
                   throw new MyException(tokenLines[j].Ln);
               else if (tokenLines[j].Tokens[0].Type == TokenType.Key && tokenLines[j].Tokens[0].Val == "endfunc")
               {
                   if (tokenLines[j].Tokens.Count != 1)
                       throw new MyException(tokenLines[j].Ln);

                   i = j + 1;
                   goto _Begin;
               }
           }
           throw new MyException(tokenLines.End.Ln);
       }
       else if (tokenLines[i].Tokens[0].Type == TokenType.Key && tokenLines[i].Tokens[0].Val == "cached")
       {
           for (int j = i + 1; j <= tokenLines.Max; j++)
           {
               if (tokenLines[j].Tokens[0].Type == TokenType.Key && tokenLines[j].Tokens[0].Val == "cached")
                   throw new MyException(tokenLines[j].Ln);
               if (tokenLines[j].Tokens[0].Type == TokenType.Key
                   && (tokenLines[j].Tokens[0].Val == "endfunc"
                       || tokenLines[j].Tokens[0].Val == "endstate"
                       || tokenLines[j].Tokens[0].Val == "enddiff"))
                   throw new MyException(tokenLines[j].Ln);
               else if (tokenLines[j].Tokens[0].Type == TokenType.Key
                   && (tokenLines[j].Tokens[0].Val == "func"
                       || tokenLines[j].Tokens[0].Val == "state"
                       || tokenLines[j].Tokens[0].Val == "diff"))
                   throw new MyException(tokenLines[j].Ln);
               else if (tokenLines[j].Tokens[0].Type == TokenType.Key && tokenLines[j].Tokens[0].Val == "endcached")
               {
                   if (tokenLines[j].Tokens.Count != 1)
                       throw new MyException(tokenLines[j].Ln);

                   if (tokenLines[i].Tokens.Max == 4
                       && tokenLines[i].Tokens[1].Type == TokenType.Id
                       && tokenLines[i].Tokens[2].Type == TokenType.Op && tokenLines[i].Tokens[2].Val == "∈"
                       && tokenLines[i].Tokens[3].Type == TokenType.Key
                       && tokenLines[i].Tokens[4].Type == TokenType.Op && tokenLines[i].Tokens[4].Val == "=")
                   {
                       string cachedName = tokenLines[i].Tokens[1].Val;
                       string _cachedType = tokenLines[i].Tokens[3].Val;
                       byte cachedType = TransType(_cachedType);

                       Globals.Add(new Global());
                       Globals.End.Ln = tokenLines[i].Ln;
                       Globals.End.Var.Name = cachedName + "α" + "val";
                       Globals.End.Var.Type = cachedType;

                       Globals.Add(new Global());
                       Globals.End.Ln = tokenLines[i].Ln;
                       Globals.End.Var.Name = cachedName + "α" + "flag";
                       Globals.End.Var.Type = 1;

                       ////

                       // func y() : T =
                       // if yαflag goto |L
                       // goto |L2
                       // |L1
                       //     ret yαval
                       // |L2
                       //     yαval <- yαfunc()
                       //     yαflag <- true
                       //     ret yαval
                       // endfunc

                       cacheds.Add(new TokenLine());
                       cacheds.End.Ln = tokenLines[i].Ln;
                       cacheds.End.Tokens.Add(new Token(TokenType.Key, "func"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Id, cachedName));
                       cacheds.End.Tokens.Add(new Token(TokenType.Op, "("));
                       cacheds.End.Tokens.Add(new Token(TokenType.Op, ")"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Op, "∈"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Key, _cachedType));
                       cacheds.End.Tokens.Add(new Token(TokenType.Op, "="));

                       cacheds.Add(new TokenLine());
                       cacheds.End.Ln = tokenLines[i].Ln;
                       cacheds.End.Tokens.Add(new Token(TokenType.Key, "if"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Id, cachedName + "α" + "flag"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Key, "goto"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Label, "L1"));

                       cacheds.Add(new TokenLine());
                       cacheds.End.Ln = tokenLines[i].Ln;
                       cacheds.End.Tokens.Add(new Token(TokenType.Key, "goto"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Label, "L2"));

                       cacheds.Add(new TokenLine());
                       cacheds.End.Ln = tokenLines[i].Ln;
                       cacheds.End.Tokens.Add(new Token(TokenType.Label, "L1"));

                       cacheds.Add(new TokenLine());
                       cacheds.End.Ln = tokenLines[i].Ln;
                       cacheds.End.Tokens.Add(new Token(TokenType.Key, "ret"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Id, cachedName + "α" + "val"));

                       cacheds.Add(new TokenLine());
                       cacheds.End.Ln = tokenLines[i].Ln;
                       cacheds.End.Tokens.Add(new Token(TokenType.Label, "L2"));

                       cacheds.Add(new TokenLine());
                       cacheds.End.Tokens.Add(new Token(TokenType.Id, cachedName + "α" + "val"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Op, "←"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Id, cachedName + "α" + "func"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Op, "("));
                       cacheds.End.Tokens.Add(new Token(TokenType.Op, ")"));

                       cacheds.Add(new TokenLine());
                       cacheds.End.Tokens.Add(new Token(TokenType.Id, cachedName + "α" + "flag"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Op, "←"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Im, "true"));

                       cacheds.Add(new TokenLine());
                       cacheds.End.Ln = tokenLines[i].Ln;
                       cacheds.End.Tokens.Add(new Token(TokenType.Key, "ret"));
                       cacheds.End.Tokens.Add(new Token(TokenType.Id, cachedName + "α" + "val"));

                       cacheds.Add(new TokenLine());
                       cacheds.End.Ln = tokenLines[i].Ln;
                       cacheds.End.Tokens.Add(new Token(TokenType.Key, "endfunc"));

                       ////

                       tokenLines[i].Tokens[0] = new Token(TokenType.Key, "func");
                       tokenLines[i].Tokens[1] = new Token(TokenType.Id, tokenLines[i].Tokens[1].Val + "αfunc");
                       tokenLines[i].Tokens.Insert(2, new Token(TokenType.Op, "("));
                       tokenLines[i].Tokens.Insert(3, new Token(TokenType.Op, ")"));

                       tokenLines[j].Tokens[0] = new Token(TokenType.Key, "endfunc");

                       ////

                       cachedFlushes.Add(new TokenLine());
                       cachedFlushes.End.Ln = tokenLines[i].Ln;
                       cachedFlushes.End.Tokens.Add(new Token(TokenType.Id, cachedName + "α" + "flag"));
                       cachedFlushes.End.Tokens.Add(new Token(TokenType.Op, "←"));
                       cachedFlushes.End.Tokens.Add(new Token(TokenType.Im, "false"));
                   }
                   else
                       throw new MyException(tokenLines[i].Ln);

                   i = j + 1;
                   goto _Begin;
               }
           }
           throw new MyException(tokenLines.End.Ln);
       }
       else if (tokenLines[i].Tokens[0].Type == TokenType.Key && tokenLines[i].Tokens[0].Val == "state")
       {
           for (int j = i + 1; j <= tokenLines.Max; j++)
           {
               if (tokenLines[j].Tokens[0].Type == TokenType.Key && tokenLines[j].Tokens[0].Val == "state")
                   throw new MyException(tokenLines[j].Ln);
               if (tokenLines[j].Tokens[0].Type == TokenType.Key
                   && (tokenLines[j].Tokens[0].Val == "endfunc"
                       || tokenLines[j].Tokens[0].Val == "endcached"
                       || tokenLines[j].Tokens[0].Val == "enddiff"))
                   throw new MyException(tokenLines[j].Ln);
               else if (tokenLines[j].Tokens[0].Type == TokenType.Key
                   && (tokenLines[j].Tokens[0].Val == "func"
                       || tokenLines[j].Tokens[0].Val == "cached"
                       || tokenLines[j].Tokens[0].Val == "diff"))
                   throw new MyException(tokenLines[j].Ln);
               else if (tokenLines[j].Tokens[0].Type == TokenType.Key && tokenLines[j].Tokens[0].Val == "endstate")
               {
                   if (tokenLines[j].Tokens.Count != 1)
                       throw new MyException(tokenLines[j].Ln);

                   if (tokenLines[i].Tokens.Max == 5
                       && tokenLines[i].Tokens[1].Type == TokenType.Id
                       && tokenLines[i].Tokens[2].Type == TokenType.Op && tokenLines[i].Tokens[2].Val == "∈"
                       && tokenLines[i].Tokens[3].Type == TokenType.Key
                       && (tokenLines[i].Tokens[4].Type == TokenType.Im || tokenLines[i].Tokens[4].Type == TokenType.Id)
                       && tokenLines[i].Tokens[5].Type == TokenType.Op && tokenLines[i].Tokens[5].Val == "=")
                   {
                       string stateName = tokenLines[i].Tokens[1].Val;
                       string _stateType = tokenLines[i].Tokens[3].Val;
                       byte stateType = TransType(_stateType);
                       Token _stateDefault = tokenLines[i].Tokens[4];

                       Globals.Add(new Global());
                       Globals.End.Ln = tokenLines[i].Ln;
                       Globals.End.Var.Name = stateName + "α" + "current";
                       Globals.End.Var.Type = stateType;

                       Globals.Add(new Global());
                       Globals.End.Ln = tokenLines[i].Ln;
                       Globals.End.Var.Name = stateName + "α" + "next";
                       Globals.End.Var.Type = stateType;

                       ////

                       // func s() : T =
                       //     ret sαcurrent
                       // endfunc

                       states.Add(new TokenLine());
                       states.End.Ln = tokenLines[i].Ln;
                       states.End.Tokens.Add(new Token(TokenType.Key, "func"));
                       states.End.Tokens.Add(new Token(TokenType.Id, stateName));
                       states.End.Tokens.Add(new Token(TokenType.Op, "("));
                       states.End.Tokens.Add(new Token(TokenType.Op, ")"));
                       states.End.Tokens.Add(new Token(TokenType.Op, "∈"));
                       states.End.Tokens.Add(new Token(TokenType.Key, _stateType));
                       states.End.Tokens.Add(new Token(TokenType.Op, "="));

                       states.Add(new TokenLine());
                       states.End.Ln = tokenLines[i].Ln;
                       states.End.Tokens.Add(new Token(TokenType.Key, "ret"));
                       states.End.Tokens.Add(new Token(TokenType.Id, stateName + "α" + "current"));

                       states.Add(new TokenLine());
                       states.End.Ln = tokenLines[i].Ln;
                       states.End.Tokens.Add(new Token(TokenType.Key, "endfunc"));

                       ////

                       tokenLines[i].Tokens[0] = new Token(TokenType.Key, "func");
                       tokenLines[i].Tokens[1] = new Token(TokenType.Id, tokenLines[i].Tokens[1].Val + "αfunc");
                       tokenLines[i].Tokens.Insert(2, new Token(TokenType.Op, "("));
                       tokenLines[i].Tokens.Insert(3, new Token(TokenType.Id, "s1"));
                       tokenLines[i].Tokens.Insert(4, new Token(TokenType.Op, "∈"));
                       tokenLines[i].Tokens.Insert(5, new Token(TokenType.Key, _stateType));
                       tokenLines[i].Tokens.Insert(6, new Token(TokenType.Op, ")"));
                       tokenLines[i].Tokens.RemoveAt(9);

                       tokenLines[j].Tokens[0] = new Token(TokenType.Key, "endfunc");

                       ////

                       stateInits.Add(new TokenLine());
                       stateInits.End.Ln = tokenLines[i].Ln;
                       stateInits.End.Tokens.Add(new Token(TokenType.Id, stateName + "α" + "current"));
                       stateInits.End.Tokens.Add(new Token(TokenType.Op, "←"));
                       stateInits.End.Tokens.Add(_stateDefault);

                       ////

                       stateUpdates.Add(new TokenLine());
                       stateUpdates.End.Ln = tokenLines[i].Ln;
                       stateUpdates.End.Tokens.Add(new Token(TokenType.Id, stateName + "α" + "next"));
                       stateUpdates.End.Tokens.Add(new Token(TokenType.Op, "←"));
                       stateUpdates.End.Tokens.Add(new Token(TokenType.Id, stateName + "α" + "func"));
                       stateUpdates.End.Tokens.Add(new Token(TokenType.Op, "("));
                       stateUpdates.End.Tokens.Add(new Token(TokenType.Id, stateName + "α" + "current"));
                       stateUpdates.End.Tokens.Add(new Token(TokenType.Op, ")"));

                       ////

                       stateFlushes.Add(new TokenLine());
                       stateFlushes.End.Ln = tokenLines[i].Ln;
                       stateFlushes.End.Tokens.Add(new Token(TokenType.Id, stateName + "α" + "current"));
                       stateFlushes.End.Tokens.Add(new Token(TokenType.Op, "←"));
                       stateFlushes.End.Tokens.Add(new Token(TokenType.Id, stateName + "α" + "next"));
                   }
                   else
                       throw new MyException(tokenLines[i].Ln);

                   i = j + 1;
                   goto _Begin;
               }
           }
           throw new MyException(tokenLines.End.Ln);
       }
       else if (tokenLines[i].Tokens[0].Type == TokenType.Key && tokenLines[i].Tokens[0].Val == "diff")
       {
           for (int j = i + 1; j <= tokenLines.Max; j++)
           {
               if (tokenLines[j].Tokens[0].Type == TokenType.Key && tokenLines[j].Tokens[0].Val == "diff")
                   throw new MyException(tokenLines[j].Ln);
               if (tokenLines[j].Tokens[0].Type == TokenType.Key
                   && (tokenLines[j].Tokens[0].Val == "endfunc"
                       || tokenLines[j].Tokens[0].Val == "endcached"
                       || tokenLines[j].Tokens[0].Val == "endstate"))
                   throw new MyException(tokenLines[j].Ln);
               else if (tokenLines[j].Tokens[0].Type == TokenType.Key
                   && (tokenLines[j].Tokens[0].Val == "func"
                       || tokenLines[j].Tokens[0].Val == "cached"
                       || tokenLines[j].Tokens[0].Val == "state"))
                   throw new MyException(tokenLines[j].Ln);
               else if (tokenLines[j].Tokens[0].Type == TokenType.Key && tokenLines[j].Tokens[0].Val == "enddiff")
               {
                   if (tokenLines[j].Tokens.Count != 1)
                       throw new MyException(tokenLines[j].Ln);

                   if (tokenLines[i].Tokens.Max == 5
                       && tokenLines[i].Tokens[1].Type == TokenType.Id
                       && tokenLines[i].Tokens[2].Type == TokenType.Op && tokenLines[i].Tokens[2].Val == "∈"
                       && tokenLines[i].Tokens[3].Type == TokenType.Key
                       && (tokenLines[i].Tokens[4].Type == TokenType.Im || tokenLines[i].Tokens[4].Type == TokenType.Id)
                       && tokenLines[i].Tokens[5].Type == TokenType.Op && tokenLines[i].Tokens[5].Val == "=")
                   {
                       string diffName = tokenLines[i].Tokens[1].Val;
                       string _diffType = tokenLines[i].Tokens[3].Val;
                       byte diffType = TransType(_diffType);
                       Token _diffDefault = tokenLines[i].Tokens[4];

                       if (diffType != 4 && diffType != 8)
                           throw new MyException(tokenLines[i].Ln);

                       Globals.Add(new Global());
                       Globals.End.Ln = tokenLines[i].Ln;
                       Globals.End.Var.Name = diffName + "α" + "old";
                       Globals.End.Var.Type = diffType;

                       Globals.Add(new Global());
                       Globals.End.Ln = tokenLines[i].Ln;
                       Globals.End.Var.Name = diffName + "α" + "current";
                       Globals.End.Var.Type = diffType;

                       ////

                       // func d() : T =
                       // auto
                       //   α : T
                       // endauto
                       // α <- dαcrrent - dαold
                       //     ret α
                       // endfunc

                       diffs.Add(new TokenLine());
                       diffs.End.Ln = tokenLines[i].Ln;
                       diffs.End.Tokens.Add(new Token(TokenType.Key, "func"));
                       diffs.End.Tokens.Add(new Token(TokenType.Id, diffName));
                       diffs.End.Tokens.Add(new Token(TokenType.Op, "("));
                       diffs.End.Tokens.Add(new Token(TokenType.Op, ")"));
                       diffs.End.Tokens.Add(new Token(TokenType.Op, "∈"));
                       diffs.End.Tokens.Add(new Token(TokenType.Key, _diffType));
                       diffs.End.Tokens.Add(new Token(TokenType.Op, "="));

                       diffs.Add(new TokenLine());
                       diffs.End.Ln = tokenLines[i].Ln;
                       diffs.End.Tokens.Add(new Token(TokenType.Key, "auto"));

                       diffs.Add(new TokenLine());
                       diffs.End.Ln = tokenLines[i].Ln;
                       diffs.End.Tokens.Add(new Token(TokenType.Id, "α"));
                       diffs.End.Tokens.Add(new Token(TokenType.Op, "∈"));
                       diffs.End.Tokens.Add(new Token(TokenType.Key, _diffType));

                       diffs.Add(new TokenLine());
                       diffs.End.Ln = tokenLines[i].Ln;
                       diffs.End.Tokens.Add(new Token(TokenType.Key, "endauto"));

                       diffs.Add(new TokenLine());
                       diffs.End.Ln = tokenLines[i].Ln;
                       diffs.End.Tokens.Add(new Token(TokenType.Id, "α"));
                       diffs.End.Tokens.Add(new Token(TokenType.Op, "←"));
                       diffs.End.Tokens.Add(new Token(TokenType.Id, diffName + "α" + "current"));
                       diffs.End.Tokens.Add(new Token(TokenType.Op, "-"));
                       diffs.End.Tokens.Add(new Token(TokenType.Id, diffName + "α" + "old"));

                       diffs.Add(new TokenLine());
                       diffs.End.Ln = tokenLines[i].Ln;
                       diffs.End.Tokens.Add(new Token(TokenType.Key, "ret"));
                       diffs.End.Tokens.Add(new Token(TokenType.Id, "α"));

                       diffs.Add(new TokenLine());
                       diffs.End.Ln = tokenLines[i].Ln;
                       diffs.End.Tokens.Add(new Token(TokenType.Key, "endfunc"));

                       ////

                       tokenLines[i].Tokens[0] = new Token(TokenType.Key, "func");
                       tokenLines[i].Tokens[1] = new Token(TokenType.Id, tokenLines[i].Tokens[1].Val + "αfunc");
                       tokenLines[i].Tokens.Insert(2, new Token(TokenType.Op, "("));
                       tokenLines[i].Tokens.Insert(3, new Token(TokenType.Op, ")"));
                       tokenLines[i].Tokens.RemoveAt(6);

                       tokenLines[j].Tokens[0] = new Token(TokenType.Key, "endfunc");

                       ////

                       diffInits.Add(new TokenLine());
                       diffInits.End.Ln = tokenLines[i].Ln;
                       diffInits.End.Tokens.Add(new Token(TokenType.Id, diffName + "α" + "old"));
                       diffInits.End.Tokens.Add(new Token(TokenType.Op, "←"));
                       diffInits.End.Tokens.Add(_diffDefault);
                       
                       ////

                       diffUpdates.Add(new TokenLine());
                       diffUpdates.End.Ln = tokenLines[i].Ln;
                       diffUpdates.End.Tokens.Add(new Token(TokenType.Id, diffName + "α" + "current"));
                       diffUpdates.End.Tokens.Add(new Token(TokenType.Op, "←"));
                       diffUpdates.End.Tokens.Add(new Token(TokenType.Id, diffName + "α" + "func"));
                       diffUpdates.End.Tokens.Add(new Token(TokenType.Op, "("));
                       diffUpdates.End.Tokens.Add(new Token(TokenType.Op, ")"));

                       ////

                       diffFlushes.Add(new TokenLine());
                       diffFlushes.End.Ln = tokenLines[i].Ln;
                       diffFlushes.End.Tokens.Add(new Token(TokenType.Id, diffName + "α" + "old"));
                       diffFlushes.End.Tokens.Add(new Token(TokenType.Op, "←"));
                       diffFlushes.End.Tokens.Add(new Token(TokenType.Id, diffName + "α" + "current"));
                   }
                   else
                       throw new MyException(tokenLines[i].Ln);

                   i = j + 1;
                   goto _Begin;
               }
           }
           throw new MyException(tokenLines.End.Ln);
       }
       else
           throw new MyException(tokenLines[i].Ln);

   _Exit:

       if (cacheds.Count > 0)
       {
           foreach (TokenLine a in cacheds)
           {
               tokenLines.Add(a);
           }
       }

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "func"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Id, "CachedFlush"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "("));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, ")"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "="));

       if (cachedFlushes.Count == 0)
       {
           tokenLines.Add(new TokenLine());
           tokenLines.End.Ln = 0;
           tokenLines.End.Tokens.Add(new Token(TokenType.Key, "ret"));
       }
       else
       {
           foreach (TokenLine b in cachedFlushes)
           {
               tokenLines.Add(b);
           }
       }

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "endfunc"));

       //////////

       if (states.Count > 0)
       {
           foreach (TokenLine a in states)
           {
               tokenLines.Add(a);
           }
       }

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "func"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Id, "StateInit"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "("));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, ")"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "="));

       if (stateInits.Count == 0)
       {
           tokenLines.Add(new TokenLine());
           tokenLines.End.Ln = 0;
           tokenLines.End.Tokens.Add(new Token(TokenType.Key, "ret"));
       }
       else
       {
           foreach (TokenLine b in stateInits)
           {
               tokenLines.Add(b);
           }
       }

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "endfunc"));

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "func"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Id, "StateUpdate"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "("));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, ")"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "="));

       if (stateUpdates.Count == 0)
       {
           tokenLines.Add(new TokenLine());
           tokenLines.End.Ln = 0;
           tokenLines.End.Tokens.Add(new Token(TokenType.Key, "ret"));
       }
       else
       {
           foreach (TokenLine c in stateUpdates)
           {
               tokenLines.Add(c);
           }
       }

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "endfunc"));

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "func"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Id, "StateFlush"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "("));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, ")"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "="));

       if (stateFlushes.Count == 0)
       {
           tokenLines.Add(new TokenLine());
           tokenLines.End.Ln = 0;
           tokenLines.End.Tokens.Add(new Token(TokenType.Key, "ret"));
       }
       else
       {
           foreach (TokenLine d in stateFlushes)
           {
               tokenLines.Add(d);
           }
       }

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "endfunc"));

       //////////

       if (diffs.Count > 0)
       {
           foreach (TokenLine a in diffs)
           {
               tokenLines.Add(a);
           }
       }

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "func"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Id, "DiffInit"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "("));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, ")"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "="));

       if (diffInits.Count == 0)
       {
           tokenLines.Add(new TokenLine());
           tokenLines.End.Ln = 0;
           tokenLines.End.Tokens.Add(new Token(TokenType.Key, "ret"));
       }
       else
       {
           foreach (TokenLine b in diffInits)
           {
               tokenLines.Add(b);
           }
       }

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "endfunc"));

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "func"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Id, "DiffUpdate"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "("));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, ")"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "="));

       if (diffUpdates.Count == 0)
       {
           tokenLines.Add(new TokenLine());
           tokenLines.End.Ln = 0;
           tokenLines.End.Tokens.Add(new Token(TokenType.Key, "ret"));
       }
       else
       {
           foreach (TokenLine c in diffUpdates)
           {
               tokenLines.Add(c);
           }
       }

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "endfunc"));

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "func"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Id, "DiffFlush"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "("));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, ")"));
       tokenLines.End.Tokens.Add(new Token(TokenType.Op, "="));

       if (diffFlushes.Count == 0)
       {
           tokenLines.Add(new TokenLine());
           tokenLines.End.Ln = 0;
           tokenLines.End.Tokens.Add(new Token(TokenType.Key, "ret"));
       }
       else
       {
           foreach (TokenLine d in diffFlushes)
           {
               tokenLines.Add(d);
           }
       }

       tokenLines.Add(new TokenLine());
       tokenLines.End.Ln = 0;
       tokenLines.End.Tokens.Add(new Token(TokenType.Key, "endfunc"));
   }

}
1   商湯      2026年2月25日 水 11:22
<Lexer.cs>

public static void SetupKeys()
{
   Keys.Add("ιstate");
   Keys.Add("ιdiff");

   Keys.Add("bool"); // if (token.Type == TokenType.Key) token.Val (type)
   Keys.Add("char");
   Keys.Add("Z");
   Keys.Add("R");

   Keys.Add("do");
   Keys.Add("ret");
   Keys.Add("goto");
   Keys.Add("if");

   Keys.Add("global"); Keys.Add("endglobal");
   Keys.Add("func"); Keys.Add("endfunc");
   Keys.Add("auto"); Keys.Add("endauto");

   Keys.Add("const"); Keys.Add("endconst");
   Keys.Add("ιstate1"); Keys.Add("ιstate2");
   Keys.Add("ιdiff1"); Keys.Add("ιdiff2");

   Keys.Add("cached");
   Keys.Add("state");
   Keys.Add("diff");
   Keys.Add("endcached");
   Keys.Add("endstate");
   Keys.Add("enddiff");
}
2   商湯      2026年2月25日 水 11:22
<DeclsAndFuncs.cs>

public static int GetConsts(ListEx<TokenLine> tokenLines) // returns endOfGlobal
{
   Consts.Clear();

   int i = tokenLines.FindIndex(x => x.Tokens.Count == 1 && x.Tokens[0].Type == TokenType.Key && x.Tokens[0].Val == "const");
   int j = tokenLines.FindIndex(x => x.Tokens.Count == 1 && x.Tokens[0].Type == TokenType.Key && x.Tokens[0].Val == "endconst");

   if (i < 0 || j < 0)
       return - 1;

   for (int l = i + 1; l <= j - 1; l++)
   {
       if (tokenLines[l].Tokens.Count == 3
              && tokenLines[l].Tokens[1].Type == TokenType.Op && tokenLines[l].Tokens[1].Val == "="
              && tokenLines[l].Tokens[0].Type == TokenType.Id && tokenLines[l].Tokens[2].Type == TokenType.Im)
       {
           Consts.Add(new Const());
           Consts.End.Ln = (uint)l;
           Consts.End.ConstVar = new ConstPair();
           Consts.End.ConstVar.Name = tokenLines[l].Tokens[0].Val;
           Consts.End.ConstVar.Val = tokenLines[l].Tokens[2].Val;
       }
       else if (tokenLines[l].Tokens.Count == 4
           && tokenLines[l].Tokens[0].Type == TokenType.Key && tokenLines[l].Tokens[0].Val == "ιstate1"
           && tokenLines[l].Tokens[2].Type == TokenType.Op && tokenLines[l].Tokens[2].Val == "="
           && tokenLines[l].Tokens[1].Type == TokenType.Id && tokenLines[l].Tokens[3].Type == TokenType.Im)
       {
           Consts.Add(new Const());
           Consts.End.Ln = (uint)l;
           Consts.End.ConstVar = new ConstPair();
           Consts.End.ConstVar.Name = tokenLines[l].Tokens[1].Val + "ιcurrent";
           Consts.End.ConstVar.Val = tokenLines[l].Tokens[3].Val;
       }
       else if (tokenLines[l].Tokens.Count == 4
           && tokenLines[l].Tokens[0].Type == TokenType.Key && tokenLines[l].Tokens[0].Val == "ιstate2"
           && tokenLines[l].Tokens[2].Type == TokenType.Op && tokenLines[l].Tokens[2].Val == "="
           && tokenLines[l].Tokens[1].Type == TokenType.Id && tokenLines[l].Tokens[3].Type == TokenType.Im)
       {
           Consts.Add(new Const());
           Consts.End.Ln = (uint)l;
           Consts.End.ConstVar = new ConstPair();
           Consts.End.ConstVar.Name = tokenLines[l].Tokens[1].Val + "ιnext";
           Consts.End.ConstVar.Val = tokenLines[l].Tokens[3].Val;
       }
       else if (tokenLines[l].Tokens.Count == 4
                       && tokenLines[l].Tokens[0].Type == TokenType.Key && tokenLines[l].Tokens[0].Val == "ιdiff1"
                   && tokenLines[l].Tokens[2].Type == TokenType.Op && tokenLines[l].Tokens[2].Val == "="
                   && tokenLines[l].Tokens[1].Type == TokenType.Id && tokenLines[l].Tokens[3].Type == TokenType.Im)
       {
           Consts.Add(new Const());
           Consts.End.Ln = (uint)l;
           Consts.End.ConstVar = new ConstPair();
           Consts.End.ConstVar.Name = tokenLines[l].Tokens[1].Val + "ιold";
           Consts.End.ConstVar.Val = tokenLines[l].Tokens[3].Val;
       }
       else if (tokenLines[l].Tokens.Count == 4
                       && tokenLines[l].Tokens[0].Type == TokenType.Key && tokenLines[l].Tokens[0].Val == "ιdiff2"
                   && tokenLines[l].Tokens[2].Type == TokenType.Op && tokenLines[l].Tokens[2].Val == "="
                   && tokenLines[l].Tokens[1].Type == TokenType.Id && tokenLines[l].Tokens[3].Type == TokenType.Im)
       {
           Consts.Add(new Const());
           Consts.End.Ln = (uint)l;
           Consts.End.ConstVar = new ConstPair();
           Consts.End.ConstVar.Name = tokenLines[l].Tokens[1].Val + "ιcurrent";
           Consts.End.ConstVar.Val = tokenLines[l].Tokens[3].Val;
       }
       else
           throw new MyException(tokenLines[l].Ln);
   }

   return j;
}

public static int GetGlobals(int endOfConst, ListEx<TokenLine> tokenLines) // returns endOfGlobal
{
   Globals.Clear();

   int i = tokenLines.FindIndex(x => x.Tokens.Count == 1 && x.Tokens[0].Type == TokenType.Key && x.Tokens[0].Val == "global");
   int j = tokenLines.FindIndex(x => x.Tokens.Count == 1 && x.Tokens[0].Type == TokenType.Key && x.Tokens[0].Val == "endglobal");

   if (i < 0 || j < 0)
       return endOfConst;

   if (i <= endOfConst)
       throw new MyException(tokenLines[i].Ln);

   //Globals.Add(new VarPair());
   //Globals.End.Name = "ξexitflag";
   //Globals.End.Type = "bool";

   for (int l = i + 1; l <= j - 1; l++)
   {
       if (tokenLines[l].Tokens.Count == 3
           && tokenLines[l].Tokens[1].Type == TokenType.Op && tokenLines[l].Tokens[1].Val == "∈"
           && tokenLines[l].Tokens[0].Type == TokenType.Id && tokenLines[l].Tokens[2].Type == TokenType.Key)
       {
           Globals.Add(new Global());
           Globals.End.Ln = (uint)l;
           Globals.End.Var = new VarPair();
           Globals.End.Var.Name = tokenLines[l].Tokens[0].Val;
           Globals.End.Var.Type = TransType(tokenLines[l].Tokens[2].Val);
           if (Globals.End.Var.Type == 0)
               throw new MyException(tokenLines[l].Ln);
       }
       else if (tokenLines[l].Tokens.Count == 4
           && tokenLines[l].Tokens[0].Type == TokenType.Key && tokenLines[l].Tokens[0].Val == "ιstate"
       && tokenLines[l].Tokens[2].Type == TokenType.Op && tokenLines[l].Tokens[2].Val == "∈"
       && tokenLines[l].Tokens[1].Type == TokenType.Id && tokenLines[l].Tokens[3].Type == TokenType.Key)
       {
           Globals.Add(new Global());
           Globals.End.Ln = (uint)l;
           Globals.End.Var = new VarPair();
           Globals.End.Var.Name = tokenLines[l].Tokens[1].Val + "ιcurrent";
           Globals.End.Var.Type = TransType(tokenLines[l].Tokens[3].Val);
           if (Globals.End.Var.Type == 0)
               throw new MyException(tokenLines[l].Ln);

           Globals.Add(new Global());
           Globals.End.Ln = (uint)l;
           Globals.End.Var = new VarPair();
           Globals.End.Var.Name = tokenLines[l].Tokens[1].Val + "ιnext";
           Globals.End.Var.Type = TransType(tokenLines[l].Tokens[3].Val);
           if (Globals.End.Var.Type == 0)
               throw new MyException(tokenLines[l].Ln);
       }
       else if (tokenLines[l].Tokens.Count == 4
                       && tokenLines[l].Tokens[0].Type == TokenType.Key && tokenLines[l].Tokens[0].Val == "ιdiff"
                   && tokenLines[l].Tokens[2].Type == TokenType.Op && tokenLines[l].Tokens[2].Val == "∈"
                   && tokenLines[l].Tokens[1].Type == TokenType.Id && tokenLines[l].Tokens[3].Type == TokenType.Key)
       {
           Globals.Add(new Global());
           Globals.End.Ln = (uint)l;
           Globals.End.Var = new VarPair();
           Globals.End.Var.Name = tokenLines[l].Tokens[1].Val + "ιold";
           Globals.End.Var.Type = TransType(tokenLines[l].Tokens[3].Val);
           if (Globals.End.Var.Type == 0)
               throw new MyException(tokenLines[l].Ln);

           Globals.Add(new Global());
           Globals.End.Ln = (uint)l;
           Globals.End.Var = new VarPair();
           Globals.End.Var.Name = tokenLines[l].Tokens[1].Val + "ιcurrent";
           Globals.End.Var.Type = TransType(tokenLines[l].Tokens[3].Val);
           if (Globals.End.Var.Type == 0)
               throw new MyException(tokenLines[l].Ln);
       }
       else
           throw new MyException(tokenLines[l].Ln);
   }

   return j;
}
3   商湯      2026年2月25日 水 11:24
<CompilerMain.cs>

public static void Compile(ListEx<string> srcLines, List<string> asmLines)
{
SetupKeys();

ListEx<ListEx<Token>> tokens = new ListEx<ListEx<Token>>(); // 空行?

for (int i = 0; i <= srcLines.Max; i++)
{
       tokens.Add(new ListEx<Token>());

for (int j = 0; j < srcLines[i].Length; )
{
Token? token;
try
{
token = NextToken(srcLines[i], ref j);
}
catch (Exception)
{
throw new MyException((uint)i);
return;
}
if (token == null)
break;

           if (token.Value.Type == TokenType.Im)
               token = new Token(TokenType.Im, TransIm(token.Value.Val));
           if (token.Value.Type == TokenType.Id)
               token = new Token(TokenType.Id, TransId(token.Value.Val));

if (MapTokenIdToKey(token.Value))
               token = new Token(TokenType.Key, token.Value.Val);

tokens.End.Add(token.Value);
}
}

ListEx<TokenLine> tokenLines = new ListEx<TokenLine>();
for (int i = 0; i <= tokens.Max; i++)
{
       if (tokens[i].Count == 0)
           continue;

tokenLines.Add(new TokenLine());
tokenLines.End.Ln = (uint)i;
tokenLines.End.Tokens.AddRange(tokens[i]);
}

   //List<TokenLines> _tokenLines;
   //_tokenLines = Simp(tokenLines);

   int endOfConst = GetConsts(tokenLines);
int endOfGlobal = GetGlobals(endOfConst, tokenLines);

   Simp(endOfGlobal, tokenLines);
   
GetFuncs(endOfGlobal, tokenLines);

SetupFuncDefs(); // NO from .def file

for (int i = 0; i <= Fns.Max; i++)
{
OutputStmts(Fns[i]);
}

GenGlobalsAddrs();
for (int i = 0; i <= Fns.Max; i++)
{
GenFnsVarsAddrs(Fns[i]);
}
   
   for (int i = 0; i <= Fns.Max; i++)
   {
       ToAsms(Fns[i]);
   }

   asmLines.Clear();
   asmLines.Add("mov4 x0, φmain");
   asmLines.Add("call x0");
   asmLines.Add("end");
   for (int f = 0; f <= Fns.Max; f++)
   {
       for (int  k = 0; k <= Fns[f].AsmsPrefix.Max; k++)
           asmLines.Add(Fns[f].AsmsPrefix[k]);

       for (int i = 0; i <= Fns[f].Lines.Max; i++)
       {
           for (int j = 0; j <= Fns[f].Lines[i].Asms.Max; j++)
           {
               asmLines.Add(Fns[f].Lines[i].Asms[j]);
           }
       }

       for (int k = 0; k <= Fns[f].AsmsSuffix.Max; k++)
           asmLines.Add(Fns[f].AsmsSuffix[k]);        
   }
}
4   商湯      2026年2月25日 水 11:24
<Form1.cs>

       public Form1()
       {
           InitializeComponent();

           CEB.Keywords = new string[] { "bool", "char", "Z", "R", "Y", "N",
               "global", "endglobal", "func", "endfunc", "auto", "endauto",
               "do", "if", "goto", "ret",
               "_state", "_diff",
               "const", "endconst",
               "_state1", "_state2",
               "_diff1", "_diff2",
               "cached", "endcached",
               "state", "endstate",
               "diff", "enddiff" };
           CEB.TextChanged += new EventHandler<EventArgs>(CEB_TextChanged);
           CEB.ViewMouseClick += new EventHandler<EventArgs>(CEB_ViewMouseClick);
       }
名前      編集用パスワード(省略可)    パスワードの記憶
数式 αβγ IPA http:// 画像 B I U 上 下
(添付ファイルは http://www.jkofsp.net/up/ にアップロードしてください)