home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2001 December / dppcpro1201.iso / Extras / maple / Viewer / WebEQ / MMLViewerInstall.cab / MMLViewerApplet.cab / webeq3 / schema / Normalizer.class (.txt) < prev   
Encoding:
Java Class File  |  2001-05-24  |  13.1 KB  |  912 lines
  1. package webeq3.schema;
  2.  
  3. import webeq3.action.SyntaxInfo;
  4. import webeq3.constants.AttributeConstants;
  5. import webeq3.constants.OperatorDictionary;
  6. import webeq3.constants.OperatorFormInfo;
  7. import webeq3.constants.OperatorProperty;
  8. import webeq3.constants.SemanticConstants;
  9. import webeq3.constants.TNormalizationException;
  10. import webeq3.util.IntSet;
  11.  
  12. public class Normalizer implements AttributeConstants, SemanticConstants {
  13.    private static int recursionDepth = 0;
  14.  
  15.    public static void aFenceOperandCheck(Box var0) throws TNormalizationException {
  16.       boolean var1 = false;
  17.       boolean var2 = false;
  18.       int var3 = var0.getNumChildren();
  19.       boolean var4 = false;
  20.  
  21.       for(int var5 = 0; var5 < var3; ++var5) {
  22.          Box var6 = var0.getChild(var5);
  23.          switch (var6.semanticType()) {
  24.             case 1:
  25.             case 2:
  26.             case 3:
  27.                var4 = false;
  28.             case 4:
  29.                break;
  30.             case 5:
  31.             default:
  32.                if (var4) {
  33.                   var2 = true;
  34.                }
  35.  
  36.                var4 = true;
  37.                break;
  38.             case 6:
  39.                var1 = true;
  40.          }
  41.       }
  42.  
  43.       if (var1 && var2) {
  44.          tNormalizeError("can't have absolute value and implied invisible times in the same row", var0);
  45.       }
  46.  
  47.    }
  48.  
  49.    private static boolean arePostfixOperatorSiblings(Box var0, Box var1) {
  50.       return isLeftOperand(var0) && !isRightOperand(var1);
  51.    }
  52.  
  53.    private static boolean arePrefixOperatorSiblings(Box var0, Box var1) {
  54.       return isRightOperand(var1) && !isLeftOperand(var0);
  55.    }
  56.  
  57.    private static void checkMRowEmbedding(Box var0) throws TNormalizationException {
  58.       int var1 = var0.getNumChildren();
  59.       if (var1 > 1) {
  60.          encapsulateChildrenIntoSubrow(var0, 0, var1 - 1);
  61.       }
  62.  
  63.    }
  64.  
  65.    private static void checkOperatorSyntax(Box var0) throws TNormalizationException {
  66.       int var1 = var0.getNumChildren();
  67.  
  68.       for(int var2 = 0; var2 < var1; ++var2) {
  69.          Box var3 = var0.getChild(var2);
  70.          if (var3.semanticType() == 1) {
  71.             Box var5 = null;
  72.  
  73.             for(int var4 = var2 - 1; var5 == null && var4 >= 0; --var4) {
  74.                if (!var0.getChild(var4).is_spacelike) {
  75.                   var5 = var0.getChild(var4);
  76.                }
  77.             }
  78.  
  79.             Box var6 = null;
  80.  
  81.             for(int var10 = var2 + 1; var6 == null && var10 < var1; ++var10) {
  82.                if (!var0.getChild(var10).is_spacelike) {
  83.                   var6 = var0.getChild(var10);
  84.                }
  85.             }
  86.  
  87.             switch (var3.semanticForm()) {
  88.                case 1:
  89.                   boolean var7 = var5 == null || var5.semanticType() != 5;
  90.                   boolean var8 = var6 == null || var6.semanticType() != 5;
  91.                   if (var7 || var8) {
  92.                      String var9 = "an operand";
  93.                      if (var7 && !var8) {
  94.                         var9 = "its left operand";
  95.                      }
  96.  
  97.                      if (var8 && !var7) {
  98.                         var9 = "its right operand";
  99.                      }
  100.  
  101.                      if (var8 && var7) {
  102.                         var9 = "both its operands";
  103.                      }
  104.  
  105.                      tNormalizeError("infix operator seems to be missing " + var9, var3);
  106.                   }
  107.                   break;
  108.                case 2:
  109.                   if (var6 == null || var6.semanticType() != 5) {
  110.                      tNormalizeError("prefix operator seems to be missing its operand", var3);
  111.                   }
  112.                   break;
  113.                case 3:
  114.                   if (var5 == null || var5.semanticType() != 5) {
  115.                      tNormalizeError("postfix operator seems to be missing its operand", var3);
  116.                   }
  117.                   break;
  118.                default:
  119.                   tNormalizeError("unrecognized operator", var3);
  120.             }
  121.          }
  122.  
  123.          checkOperatorSyntax(var3);
  124.       }
  125.  
  126.    }
  127.  
  128.    private static boolean disambiguateFences(Box var0) {
  129.       int var3 = var0.getNumChildren();
  130.  
  131.       int var1;
  132.       for(var1 = 0; var1 < var3 && var0.getChild(var1).semanticType() != 6; ++var1) {
  133.       }
  134.  
  135.       if (var1 >= var3) {
  136.          return true;
  137.       } else {
  138.          while(true) {
  139.             int var2;
  140.             for(var2 = var1 + 1; var2 < var3 && var0.getChild(var2).semanticType() != 6; ++var2) {
  141.             }
  142.  
  143.             if (var2 >= var3) {
  144.                return false;
  145.             }
  146.  
  147.             if (isValidAtom(var0, var1 + 1, var2 - 1)) {
  148.                var0.getChild(var1).setSemanticType(2);
  149.                var0.getChild(var2).setSemanticType(3);
  150.                if (disambiguateFences(var0)) {
  151.                   return true;
  152.                }
  153.             }
  154.  
  155.             var0.getChild(var1).setSemanticType(6);
  156.             var0.getChild(var2).setSemanticType(6);
  157.             var1 = var2;
  158.          }
  159.       }
  160.    }
  161.  
  162.    private static void encapsulateChildrenIntoSubrow(Box var0, int var1, int var2) {
  163.       MRow var3 = new MRow(var0);
  164.       var3.backPtr = var0.getChild(var2).backPtr;
  165.  
  166.       for(int var4 = var1; var4 <= var2; ++var4) {
  167.          Box var5 = var0.getChild(var1);
  168.          var0.removeChildAt(var1);
  169.          var5.setParent(var3);
  170.          ((Box)var3).addChild(var5);
  171.       }
  172.  
  173.       var0.insertChildAt(var3, var1);
  174.       ((Box)var3).setSemanticType(5);
  175.       ((Box)var3).setSyntaxInfo(new SyntaxInfo(2));
  176.    }
  177.  
  178.    private static void subSupFenced(Box var0) {
  179.       if (var0.getChild(2) instanceof MSubsup) {
  180.          MSubsup var1 = (MSubsup)var0.removeChildAt(2);
  181.          Box var2 = var0.removeChildAt(1);
  182.          Box var3 = var0.removeChildAt(0);
  183.  
  184.          Box var4;
  185.          for(var4 = ((Box)var1).removeChildAt(0); !(var4 instanceof MO); var4 = var4.getChild(0).getCopy()) {
  186.          }
  187.  
  188.          MRow var5 = new MRow(var1);
  189.          ((Box)var5).addChild(var3);
  190.          ((Box)var5).addChild(var2);
  191.          ((Box)var5).addChild(var4);
  192.          ((Box)var1).insertChildAt(var5, 0);
  193.          var0.insertChildAt(var1, 0);
  194.          ((Box)var1).setSemanticType(5);
  195.          ((Box)var5).setSemanticType(5);
  196.          ((Box)var1).setSemanticForm(0);
  197.       }
  198.    }
  199.  
  200.    private static void flagFunctions(Box var0) {
  201.       int var1 = var0.getNumChildren();
  202.  
  203.       for(int var2 = 0; var2 < var1 - 1; ++var2) {
  204.          Box var3 = var0.getChild(var2);
  205.          Box var4 = var0.getChild(var2 + 1);
  206.          if (isFunctionName(var3) && var4 instanceof MO && var4.udata.equals(String.valueOf('∩┐╝'))) {
  207.             var3.setSyntaxInfo(new SyntaxInfo(3));
  208.          }
  209.  
  210.          flagFunctions(var3);
  211.       }
  212.  
  213.    }
  214.  
  215.    private static void functionCheck(Box var0) {
  216.       int var1 = var0.getNumChildren();
  217.  
  218.       for(int var2 = 0; var2 < var1; ++var2) {
  219.          Box var3 = var0.getChild(var2);
  220.          if (!(var3 instanceof MI)) {
  221.             if (var3.children != null && var3.children.size() > 0) {
  222.                functionCheck(var3);
  223.             }
  224.          } else if (var3.semanticForm() == 2) {
  225.             MO var4 = new MO(var0);
  226.             var4.backPtr = var0;
  227.             var4.my_view = var3.my_view;
  228.             var4.attribute_stack = var3.attribute_stack;
  229.             var4.attributes = new String[86];
  230.  
  231.             for(int var5 = 0; var5 < 86; ++var5) {
  232.                var4.attributes[var5] = var3.attributes[var5];
  233.             }
  234.  
  235.             var4.udata = var3.udata;
  236.             var4.adata = var3.adata;
  237.             var4.semantic_type = var3.semantic_type;
  238.             var4.semantic_form = var3.semantic_form;
  239.             var4.semantic_prec = var3.semantic_prec;
  240.             if ("lim".equals(var4.adata)) {
  241.                ((Box)var4).setSyntaxInfo(new SyntaxInfo(1));
  242.             } else {
  243.                ((Box)var4).setSyntaxInfo(new SyntaxInfo(3));
  244.             }
  245.  
  246.             var0.setChild(var4, var2);
  247.             propagateEmbellishedOpStatus(var4);
  248.          }
  249.       }
  250.  
  251.    }
  252.  
  253.    private static void propagateEmbellishedOpStatus(Box var0) {
  254.       boolean var1 = false;
  255.       Box var2 = var0.getParent();
  256.       if (var2 instanceof MRow) {
  257.          if (var2.getNumChildren() == 1) {
  258.             var1 = true;
  259.          }
  260.       } else if (!(var2 instanceof MFrac) && !(var2 instanceof MScripts)) {
  261.          if (var2 instanceof MAction && var0.box_id == ((MAction)var2).active_toggle) {
  262.             var1 = true;
  263.          }
  264.       } else if (var0.box_id == 0) {
  265.          var1 = true;
  266.       }
  267.  
  268.       if (var1) {
  269.          var2.embellished_op = true;
  270.          var2.semantic_type = var0.semantic_type;
  271.          var2.semantic_form = var0.semantic_form;
  272.          var2.semantic_prec = var0.semantic_prec;
  273.          propagateEmbellishedOpStatus(var2);
  274.       }
  275.  
  276.    }
  277.  
  278.    private static void insertApplyFunction(Box var0) {
  279.       int var1 = var0.getNumChildren();
  280.  
  281.       for(int var2 = 0; var2 < var1 - 1; ++var2) {
  282.          Box var3;
  283.          for(var3 = var0.getChild(var2); var3.isSpaceLike() && var2 < var1 - 2; var3 = var0.getChild(var2)) {
  284.             ++var2;
  285.          }
  286.  
  287.          int var4 = 1;
  288.  
  289.          Box var5;
  290.          for(var5 = var0.getChild(var2 + var4); var5.isSpaceLike() && var2 + var4 < var1 - 1; var5 = var0.getChild(var2 + var4)) {
  291.             ++var4;
  292.          }
  293.  
  294.          if (isFunctionName(var3) && isMetaLParen(var5)) {
  295.             var3.setSemanticForm(2);
  296.             var3.setSyntaxInfo(new SyntaxInfo(3));
  297.             MO var6 = new MO(var0);
  298.             ((Box)var6).setSemanticType(1);
  299.             ((Box)var6).setSemanticForm(1);
  300.             OperatorProperty var7 = OperatorDictionary.simpleLookUp('∩┐╝');
  301.             ((Box)var6).setSemanticPrecedence(var7.precedence);
  302.             ((Box)var6).setUData(String.valueOf('∩┐╝'));
  303.             ((Box)var6).setAData("⁡");
  304.             var0.insertChildAt(var6, var2 + 1);
  305.             ++var1;
  306.             ++var2;
  307.          }
  308.       }
  309.  
  310.    }
  311.  
  312.    private static void insertInvisibleTimes(Box var0) {
  313.       int var1 = var0.getNumChildren();
  314.  
  315.       for(int var2 = 0; var2 < var1 - 1; ++var2) {
  316.          Box var3 = var0.getChild(var2);
  317.          Box var4 = var0.getChild(var2 + 1);
  318.          if (var3.semanticType() == 5 && var4.semanticType() == 5) {
  319.             boolean var5 = true;
  320.             if (var3 instanceof MSubsup || var3 instanceof MUnderover) {
  321.                for(var3 = var3.getChild(0); var3 != null && var3 instanceof MRow && var3.getNumChildren() == 1; var3 = var3.getChild(0)) {
  322.                }
  323.  
  324.                if (var3 != null && var3 instanceof MO) {
  325.                   var5 = false;
  326.                }
  327.             }
  328.  
  329.             if (var4 instanceof MRow && var4.getNumChildren() > 1) {
  330.                char var6 = var4.getChild(0).udata.length() > 0 ? var4.getChild(0).udata.charAt(0) : 0;
  331.                if (var6 == 8518 || var6 == 8517) {
  332.                   var5 = false;
  333.                }
  334.             }
  335.  
  336.             if (var5) {
  337.                MO var9 = new MO(var0);
  338.                ((Box)var9).setSemanticType(1);
  339.                ((Box)var9).setSemanticForm(1);
  340.                OperatorProperty var7 = OperatorDictionary.simpleLookUp('\ufffb');
  341.                ((Box)var9).setSemanticPrecedence(var7.precedence);
  342.                ((Box)var9).setUData(String.valueOf('\ufffb'));
  343.                ((Box)var9).setAData("⁢");
  344.                ((Box)var9).setSyntaxInfo(new SyntaxInfo(1));
  345.                var0.insertChildAt(var9, var2 + 1);
  346.                ++var1;
  347.                ++var2;
  348.             }
  349.          }
  350.       }
  351.  
  352.    }
  353.  
  354.    private static boolean insureAreInfixOperatorSiblings(Box var0, Box var1, Box var2) throws TNormalizationException {
  355.       boolean var3 = !isLeftOperand(var0);
  356.       boolean var4 = !isRightOperand(var2);
  357.       if (var3 || var4) {
  358.          String var5 = "an operand";
  359.          if (var3 && !var4) {
  360.             var5 = "its left operand";
  361.          }
  362.  
  363.          if (var4 && !var3) {
  364.             var5 = "its right operand";
  365.          }
  366.  
  367.          if (var4 && var3) {
  368.             var5 = "both its operands";
  369.          }
  370.  
  371.          tNormalizeError("infix operator seems to be missing " + var5, var1);
  372.       }
  373.  
  374.       return true;
  375.    }
  376.  
  377.    private static boolean isFunctionName(Box var0) {
  378.       if (var0 instanceof MI) {
  379.          return true;
  380.       } else {
  381.          if (var0 instanceof MSubsup || var0 instanceof MUnderover) {
  382.             for(var0 = var0.getChild(0); var0 != null && var0 instanceof MRow && var0.getNumChildren() == 1; var0 = var0.getChild(0)) {
  383.             }
  384.  
  385.             if (var0 != null && var0 instanceof MI) {
  386.                return true;
  387.             }
  388.          }
  389.  
  390.          return false;
  391.       }
  392.    }
  393.  
  394.    private static boolean isLeftOperand(Box var0) {
  395.       if (var0 == null) {
  396.          return false;
  397.       } else {
  398.          switch (var0.semanticType()) {
  399.             case 1:
  400.                return var0.semanticForm() == 3;
  401.             case 2:
  402.             case 4:
  403.             default:
  404.                return false;
  405.             case 3:
  406.             case 5:
  407.             case 6:
  408.                return true;
  409.          }
  410.       }
  411.    }
  412.  
  413.    private static boolean isMetaLParen(Box var0) {
  414.       if (var0 == null) {
  415.          return false;
  416.       } else if (var0 instanceof MO && var0.udata.equals("(")) {
  417.          return true;
  418.       } else {
  419.          return !(var0 instanceof MRow) ? false : isMetaLParen(var0.getChild(0));
  420.       }
  421.    }
  422.  
  423.    private static boolean isRightOperand(Box var0) {
  424.       if (var0 == null) {
  425.          return false;
  426.       } else {
  427.          switch (var0.semanticType()) {
  428.             case 1:
  429.                return var0.semanticForm() == 2;
  430.             case 2:
  431.             case 5:
  432.             case 6:
  433.                return true;
  434.             case 3:
  435.             case 4:
  436.             default:
  437.                return false;
  438.          }
  439.       }
  440.    }
  441.  
  442.    private static boolean isValidAtom(Box var0, int var1, int var2) {
  443.       boolean var3 = false;
  444.       boolean var4 = false;
  445.  
  446.       for(int var5 = var1; var5 <= var2; ++var5) {
  447.          switch (var0.getChild(var5).semanticType()) {
  448.             case 1:
  449.             case 2:
  450.             case 3:
  451.             case 4:
  452.             default:
  453.                break;
  454.             case 5:
  455.                var3 = true;
  456.                break;
  457.             case 6:
  458.                var4 = true;
  459.          }
  460.       }
  461.  
  462.       return !var4 && var3;
  463.    }
  464.  
  465.    public static void normalize(Box var0) throws TNormalizationException {
  466.       int var1 = var0.getNumChildren();
  467.       if (var0.getClass().getName().equals("webeq3.schema.Box") && (var1 > 1 || !(var0.getChild(0) instanceof MRow))) {
  468.          encapsulateChildrenIntoSubrow(var0, 0, var1 - 1);
  469.       }
  470.  
  471.       processWhitespace(var0);
  472.       setChildSemantics(var0);
  473.       functionCheck(var0);
  474.       flagFunctions(var0);
  475.       recursionDepth = 0;
  476.       normalizeNodes(var0);
  477.    }
  478.  
  479.    private static void normalizeNodes(Box var0) throws TNormalizationException {
  480.       if (var0 instanceof MRow) {
  481.          aFenceOperandCheck(var0);
  482.          if (!disambiguateFences(var0)) {
  483.             tNormalizeError("can't make sense of absolute values", var0);
  484.          }
  485.  
  486.          processFences(var0);
  487.          insertApplyFunction(var0);
  488.          insertInvisibleTimes(var0);
  489.          precedenceParse(var0);
  490.       } else if (var0 instanceof MSqrt) {
  491.          normalizeSqrt(var0);
  492.       } else if (var0 instanceof MStyle || var0 instanceof MTd || var0 instanceof MPadded || var0 instanceof MPhantom) {
  493.          checkMRowEmbedding(var0);
  494.       }
  495.  
  496.       int var1 = var0.getNumChildren();
  497.  
  498.       for(int var2 = 0; var2 < var1; ++var2) {
  499.          Box var3 = var0.getChild(var2);
  500.          normalizeNodes(var3);
  501.       }
  502.  
  503.    }
  504.  
  505.    private static void normalizeSqrt(Box var0) throws TNormalizationException {
  506.       int var2 = var0.getNumChildren();
  507.       if (var2 != 0) {
  508.          byte var3 = 0;
  509.          if (var0.getChild(var2 - 1).getClass().getName().equals("webeq3.schema.Box")) {
  510.             var3 = 1;
  511.          }
  512.  
  513.          if (var2 != 1 + var3 || !(var0.getChild(0) instanceof MRow)) {
  514.             encapsulateChildrenIntoSubrow(var0, 0, var2 - 1 - var3);
  515.          }
  516.  
  517.       }
  518.    }
  519.  
  520.    private static void precedenceParse(Box var0) throws TNormalizationException {
  521.       IntSet var1 = new IntSet();
  522.  
  523.       do {
  524.          int var2 = -2;
  525.          int var3 = -2;
  526.          int var4 = -2;
  527.          int var5 = -2;
  528.          boolean var6 = true;
  529.          var1.clear();
  530.          int var7 = var0.getNumChildren();
  531.  
  532.          for(int var8 = 0; var8 < var7; ++var8) {
  533.             Box var9 = var0.getChild(var8);
  534.             Box var10 = getEmbellishedOp(var9);
  535.             if (var9 instanceof MO || var9.embellished_op || var10 != null) {
  536.                int var11;
  537.                if (!(var9 instanceof MO) && !var9.embellished_op) {
  538.                   var11 = var10.semanticPrecedence();
  539.                } else {
  540.                   var11 = var9.semanticPrecedence();
  541.                }
  542.  
  543.                if (var11 > 0) {
  544.                   if (var11 >= var3) {
  545.                      var3 = var11;
  546.                      if (var11 != var2) {
  547.                         var5 = var8;
  548.                         var4 = var8;
  549.                      } else {
  550.                         var5 = var8;
  551.                      }
  552.                   }
  553.  
  554.                   var2 = var11;
  555.                }
  556.  
  557.                var1.addElement(var11);
  558.             }
  559.          }
  560.  
  561.          if (var1.size() > 1) {
  562.             int var15 = var0.getChild(var4).semanticForm();
  563.             int var16 = var0.getChild(var5).semanticForm();
  564.             int var17;
  565.             if (var15 != 3 && var15 != 1) {
  566.                var17 = var4;
  567.             } else {
  568.                for(var17 = var4 - 1; var17 >= 0 && var0.getChild(var17).semanticType() != 5 && var0.getChild(var17).semanticType() != 1; --var17) {
  569.                }
  570.  
  571.                if (var17 < 0) {
  572.                   tNormalizeError("infix or postfix operator seems to be at beginning of row", var0);
  573.                }
  574.             }
  575.  
  576.             int var12;
  577.             if (var16 != 2 && var16 != 1) {
  578.                var12 = var5;
  579.             } else {
  580.                int var13 = identifyTrailingArgsAndBvars(var0, var5);
  581.                ++var5;
  582.  
  583.                while(var5 < var7 && var0.getChild(var5).semanticType() != 5) {
  584.                   if (var0.getChild(var5).semanticType() != 1) {
  585.                      ++var5;
  586.                   } else {
  587.                      tNormalizeError("infix or prefix operator is missing right operand", var0);
  588.                   }
  589.                }
  590.  
  591.                if (var5 + var13 - 1 >= var7) {
  592.                   tNormalizeError("infix or prefix operator is missing right operand", var0);
  593.                }
  594.  
  595.                var12 = var5 + var13 - 1;
  596.             }
  597.  
  598.             encapsulateChildrenIntoSubrow(var0, var17, var12);
  599.             ++recursionDepth;
  600.             if (recursionDepth > 50) {
  601.                tNormalizeError("recursion depth exceeded -- couldn't normalize expression", var0);
  602.             }
  603.          }
  604.       } while(var1.size() > 1);
  605.  
  606.    }
  607.  
  608.    private static Box getEmbellishedOp(Box var0) {
  609.       Box var1 = null;
  610.       if (var0 instanceof MSubsup || var0 instanceof MUnderover) {
  611.          Box var2 = var0.getChild(0);
  612.          if (var2 instanceof MO && var2.embellished_op) {
  613.             var1 = var2;
  614.          }
  615.       }
  616.  
  617.       return var1;
  618.    }
  619.  
  620.    private static void processFences(Box var0) throws TNormalizationException {
  621.       int var1 = var0.getNumChildren();
  622.       if (var1 != 0) {
  623.          if (var0.getChild(0).semanticType() == 3) {
  624.             if (var0.getNumChildren() <= 1) {
  625.                return;
  626.             }
  627.  
  628.             tNormalizeError("right fence can't be the first thing in a row", var0.getChild(0));
  629.          }
  630.  
  631.          Box var2 = var0.getChild(0);
  632.          Box var3 = var0.getChild(var1 - 1);
  633.          boolean var4 = false;
  634.          if (var2.semanticType() == 2 && var3.semanticType() == 3 && var2.semanticFenceType() == var3.semanticFenceType()) {
  635.             int var5 = 1;
  636.             int var6 = var2.semanticFenceType();
  637.             var4 = true;
  638.  
  639.             for(int var7 = 1; var7 < var1 - 1; ++var7) {
  640.                Box var8 = var0.getChild(var7);
  641.                if (var8.semanticType() == 2 && var8.semanticFenceType() == var6) {
  642.                   ++var5;
  643.                }
  644.  
  645.                if (var8.semanticType() == 3 && var8.semanticFenceType() == var6) {
  646.                   --var5;
  647.                }
  648.  
  649.                if (var5 == 0) {
  650.                   var4 = false;
  651.                }
  652.             }
  653.  
  654.             if (var4 && var5 != 1) {
  655.                tNormalizeError("Fence nesting level mismatch [1]", var0);
  656.             }
  657.          }
  658.  
  659.          if (var4) {
  660.             if (var1 > 2) {
  661.                if (var1 != 3 || !(var0.getChild(1) instanceof MRow)) {
  662.                   encapsulateChildrenIntoSubrow(var0, 1, var1 - 2);
  663.                }
  664.  
  665.                subSupFenced(var0);
  666.             }
  667.          } else {
  668.             boolean var14;
  669.             do {
  670.                var1 = var0.getNumChildren();
  671.                var14 = false;
  672.                boolean var15 = false;
  673.                int var16 = -1;
  674.  
  675.                int var18;
  676.                for(var18 = 0; var18 < var1; ++var18) {
  677.                   if (var0.getChild(var18).semanticType() == 2) {
  678.                      var14 = true;
  679.                      var16 = var0.getChild(var18).semanticFenceType();
  680.                      break;
  681.                   }
  682.                }
  683.  
  684.                int var10 = 0;
  685.  
  686.                int var9;
  687.                for(var9 = var18 + 1; var9 < var1; ++var9) {
  688.                   int var11 = var0.getChild(var9).semanticType();
  689.                   if (var11 == 2) {
  690.                      ++var10;
  691.                   }
  692.  
  693.                   if (var11 == 3) {
  694.                      if (var10 == 0) {
  695.                         if (var0.getChild(var9).semanticFenceType() != var16) {
  696.                            tNormalizeError("Fence nesting error (overlap?)", var0.getChild(var9));
  697.                         }
  698.  
  699.                         var15 = true;
  700.                         break;
  701.                      }
  702.  
  703.                      --var10;
  704.                   }
  705.                }
  706.  
  707.                if (var14) {
  708.                   if (var15) {
  709.                      if (var18 >= var9) {
  710.                         tNormalizeError("Unable to match fences here", var0);
  711.                      }
  712.  
  713.                      encapsulateChildrenIntoSubrow(var0, var18, var9);
  714.                   } else {
  715.                      tNormalizeError("left fence has no matching right one", var0.getChild(var18));
  716.                   }
  717.                }
  718.             } while(var14);
  719.  
  720.             var1 = var0.getNumChildren();
  721.  
  722.             for(int var17 = 0; var17 < var1; ++var17) {
  723.                if (var0.getChild(var17).semanticType() == 3) {
  724.                   tNormalizeError("right fence has no matching left one", var0.getChild(var17));
  725.                }
  726.             }
  727.  
  728.          }
  729.       }
  730.    }
  731.  
  732.    private static void processWhitespace(Box var0) {
  733.       int var1 = var0.getNumChildren();
  734.  
  735.       for(int var2 = 0; var2 < var1; ++var2) {
  736.          Box var3 = var0.getChild(var2);
  737.          if (!(var3 instanceof MI)) {
  738.             if (var3.getNumChildren() > 0) {
  739.                processWhitespace(var3);
  740.             }
  741.          } else if (var3.udata.equals(String.valueOf('ΓÇë')) || var3.udata.equals(String.valueOf('┬á')) || var3.udata.equals(String.valueOf('ΓÇâ')) || var3.udata.equals(String.valueOf('\uf365')) || var3.udata.equals(String.valueOf('\uf380')) || var3.udata.equals(String.valueOf('\uf382')) || var3.udata.equals(String.valueOf('\uf383')) || var3.udata.equals(String.valueOf('\uf384')) || var3.udata.equals(String.valueOf('\uf385')) || var3.udata.equals(String.valueOf('\uf386')) || var3.udata.equals(String.valueOf('\uf387')) || var3.udata.equals(String.valueOf('\uf388')) || var3.udata.equals(String.valueOf('\uf389')) || var3.udata.equals(String.valueOf('∩┐╜'))) {
  742.             MText var4 = new MText(var0);
  743.             var4.is_spacelike = true;
  744.             var4.backPtr = var0;
  745.             var4.my_view = var3.my_view;
  746.             var4.attribute_stack = var3.attribute_stack;
  747.             var4.attributes = new String[86];
  748.  
  749.             for(int var5 = 0; var5 < 86; ++var5) {
  750.                var4.attributes[var5] = var3.attributes[var5];
  751.             }
  752.  
  753.             var4.udata = var3.udata;
  754.             var4.adata = var3.adata;
  755.             var0.setChild(var4, var2);
  756.          }
  757.       }
  758.  
  759.    }
  760.  
  761.    private static void setChildSemantics(Box var0) throws TNormalizationException {
  762.       setChildTypes(var0);
  763.       setChildFormAndPrecedences(var0);
  764.    }
  765.  
  766.    private static void setChildFormAndPrecedences(Box var0) throws TNormalizationException {
  767.       int var1 = var0.getNumChildren();
  768.  
  769.       for(int var2 = 0; var2 < var1; ++var2) {
  770.          Box var3 = var0.getChild(var2);
  771.          if (var3.semanticType() == 1 && OperatorDictionary.isMultiForm(var3.opLookupString())) {
  772.             Box var5 = null;
  773.  
  774.             for(int var4 = var2 - 1; var5 == null && var4 >= 0; --var4) {
  775.                if (!var0.getChild(var4).is_spacelike) {
  776.                   var5 = var0.getChild(var4);
  777.                }
  778.             }
  779.  
  780.             Box var6 = null;
  781.  
  782.             for(int var8 = var2 + 1; var6 == null && var8 < var1; ++var8) {
  783.                if (!var0.getChild(var8).is_spacelike) {
  784.                   var6 = var0.getChild(var8);
  785.                }
  786.             }
  787.  
  788.             OperatorProperty var7;
  789.             if ((var7 = OperatorDictionary.simpleLookUp("_pre_" + var3.opLookupString())) != null && arePrefixOperatorSiblings(var5, var6)) {
  790.                var3.setSemanticForm(2);
  791.                var3.setSemanticPrecedence(var7.precedence);
  792.                continue;
  793.             }
  794.  
  795.             if ((var7 = OperatorDictionary.simpleLookUp("_post_" + var3.opLookupString())) != null && arePostfixOperatorSiblings(var5, var6)) {
  796.                var3.setSemanticForm(3);
  797.                var3.setSemanticPrecedence(var7.precedence);
  798.                continue;
  799.             }
  800.  
  801.             var7 = OperatorDictionary.simpleLookUp(var3.opLookupString());
  802.             if (var7 == null) {
  803.                tNormalizeError("this operator does not have an infix form", var3);
  804.             } else if (insureAreInfixOperatorSiblings(var5, var3, var6)) {
  805.                var3.setSemanticForm(1);
  806.                var3.setSemanticPrecedence(var7.precedence);
  807.             }
  808.          }
  809.  
  810.          setChildFormAndPrecedences(var3);
  811.       }
  812.  
  813.    }
  814.  
  815.    private static void setChildTypes(Box var0) throws TNormalizationException {
  816.       int var1 = var0.getNumChildren();
  817.  
  818.       for(int var2 = 0; var2 < var1; ++var2) {
  819.          Box var3 = var0.getChild(var2);
  820.          String var4 = var3.opLookupString();
  821.          OperatorFormInfo var5 = OperatorDictionary.formLookUp(var4);
  822.          if ((!(var3 instanceof MI) || var5 == null) && !(var3 instanceof MO) && !var3.embellished_op) {
  823.             if (var3.is_spacelike) {
  824.                var3.setSemanticType(4);
  825.             } else {
  826.                var3.setSemanticType(5);
  827.             }
  828.          } else if (var5 == null) {
  829.             tNormalizeError("Unknown operator", var3);
  830.          } else if (var5.nforms == 1) {
  831.             if (var5.op.isLFence() && var5.op.isRFence()) {
  832.                var3.setSemanticType(6);
  833.                var3.setSemanticFenceType(var5.op.fencetype);
  834.             } else if (var5.op.isLFence()) {
  835.                var3.setSemanticType(2);
  836.                var3.setSemanticFenceType(var5.op.fencetype);
  837.             } else if (var5.op.isRFence()) {
  838.                var3.setSemanticType(3);
  839.                var3.setSemanticFenceType(var5.op.fencetype);
  840.                if (var3.embellished_op) {
  841.                   Box var6 = var3.getParent();
  842.                   if (var6 instanceof MSubsup) {
  843.                      var6.setSemanticType(3);
  844.                      var6.setSemanticFenceType(var3.semanticFenceType());
  845.                   }
  846.                }
  847.             } else {
  848.                var3.setSemanticType(1);
  849.             }
  850.  
  851.             var3.setSemanticForm(var5.form);
  852.             var3.setSemanticPrecedence(var5.op.precedence);
  853.          } else {
  854.             var3.setSemanticType(1);
  855.             var3.setSemanticForm(0);
  856.          }
  857.  
  858.          switch (var3.semanticType()) {
  859.             case 1:
  860.                var3.setSyntaxInfo(new SyntaxInfo(1));
  861.                break;
  862.             case 2:
  863.             case 3:
  864.             case 6:
  865.                var3.setSyntaxInfo(new SyntaxInfo(5));
  866.                break;
  867.             case 4:
  868.             default:
  869.                var3.setSyntaxInfo(new SyntaxInfo(4));
  870.                break;
  871.             case 5:
  872.                var3.setSyntaxInfo(new SyntaxInfo(2));
  873.          }
  874.  
  875.          setChildTypes(var3);
  876.       }
  877.  
  878.    }
  879.  
  880.    private static int identifyTrailingArgsAndBvars(Box var0, int var1) {
  881.       Box var2 = var0.getChild(var1);
  882.       if (var2.semanticForm() == 1) {
  883.          return 1;
  884.       } else {
  885.          char var3;
  886.          if (var2.children.size() != 0) {
  887.             var3 = var2.getChild(0).udata.charAt(0);
  888.          } else {
  889.             var3 = var2.udata.charAt(0);
  890.          }
  891.  
  892.          if (var3 != 8747) {
  893.             return 1;
  894.          } else if (var1 + 2 >= var0.getNumChildren()) {
  895.             return 1;
  896.          } else {
  897.             Box var4 = var0.getChild(var1 + 2);
  898.             if (var4.semanticType() != 5) {
  899.                return 1;
  900.             } else {
  901.                var4.semantic_type = 7;
  902.                return 2;
  903.             }
  904.          }
  905.       }
  906.    }
  907.  
  908.    public static void tNormalizeError(String var0, Box var1) throws TNormalizationException {
  909.       throw new TNormalizationException(var0, var1);
  910.    }
  911. }
  912.