home *** CD-ROM | disk | FTP | other *** search
/ CD Actual Thematic 7: Programming / CDAT7.iso / Share / Java / JDesignerPro / Jdp3_0.exe / data1.cab / Program_Files / JDPMain.jar / JDPHtmlParser.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-08-26  |  6.4 KB  |  526 lines
  1. import java.io.InputStream;
  2. import java.net.URL;
  3. import java.util.EmptyStackException;
  4. import java.util.Hashtable;
  5. import java.util.Stack;
  6.  
  7. public class JDPHtmlParser {
  8.    final boolean debug;
  9.    static Hashtable ampChars = new Hashtable();
  10.    byte[] output;
  11.    byte[] input;
  12.    int inputLength;
  13.    int inputSeek;
  14.    int lineCount = 1;
  15.    JDPHtmlDoc html;
  16.    private String delim = "> =";
  17.    Stack tagStack = new Stack();
  18.    boolean preFormatted;
  19.    private static JDPHtmlTag FORMtag;
  20.    private static JDPHtmlTag INPUTtag;
  21.    private static JDPHtmlTag HRtag;
  22.  
  23.    final int nextChar() {
  24.       if (this.inputSeek >= this.inputLength) {
  25.          return -1;
  26.       } else {
  27.          byte var1 = this.input[this.inputSeek++];
  28.          switch (var1) {
  29.             case 10:
  30.                ++this.lineCount;
  31.             case 11:
  32.             case 12:
  33.             default:
  34.                break;
  35.             case 13:
  36.                if (this.inputSeek >= this.inputLength) {
  37.                   ++this.lineCount;
  38.                   return 10;
  39.                }
  40.  
  41.                var1 = this.input[this.inputSeek++];
  42.                if (var1 != 10) {
  43.                   this.inputSeek += -1;
  44.                   var1 = 10;
  45.                }
  46.  
  47.                if (var1 == 10) {
  48.                   ++this.lineCount;
  49.                }
  50.          }
  51.  
  52.          return var1;
  53.       }
  54.    }
  55.  
  56.    void parseAttributes(JDPHtmlTagRef var1) {
  57.       while(true) {
  58.          this.skipWhiteSpace();
  59.          int var2 = this.inputSeek;
  60.  
  61.          int var3;
  62.          while((var3 = this.nextChar()) != -1 && var3 != 62 && var3 != 32 && var3 != 61 && var3 != 10 && var3 != 9) {
  63.          }
  64.  
  65.          this.pushBack();
  66.          String var4;
  67.          if (var2 == this.inputSeek) {
  68.             var4 = null;
  69.          } else {
  70.             var4 = this.makeLowerCaseString(this.input, var2, this.inputSeek - var2);
  71.          }
  72.  
  73.          this.skipWhiteSpace();
  74.          if (var4 == null) {
  75.             return;
  76.          }
  77.  
  78.          String var5;
  79.          if (this.peekChar() == 61) {
  80.             this.nextChar();
  81.             this.skipWhiteSpace();
  82.             var3 = this.nextChar();
  83.             if (var3 != 39 && var3 != 34) {
  84.                this.pushBack();
  85.                var2 = this.inputSeek;
  86.                boolean var11 = false;
  87.  
  88.                while((var3 = this.nextChar()) != -1 && var3 != 32 && var3 != 9 && var3 != 10 && var3 != 62) {
  89.                }
  90.             } else {
  91.                int var6 = var3;
  92.                var2 = this.inputSeek;
  93.                boolean var7 = false;
  94.  
  95.                while((var3 = this.nextChar()) != -1 && var3 != var6 && var3 != 62) {
  96.                }
  97.             }
  98.  
  99.             if (var3 == -1) {
  100.                this.warning("unexpected EOF");
  101.                return;
  102.             }
  103.  
  104.             var5 = new String(this.input, 0, var2, this.inputSeek - var2 - 1);
  105.             if (var3 == 62) {
  106.                this.pushBack();
  107.             }
  108.          } else {
  109.             var5 = new String("true");
  110.          }
  111.  
  112.          if (var1 != null) {
  113.             var1.addAttribute(var4, var5);
  114.          }
  115.       }
  116.    }
  117.  
  118.    void parse() {
  119.       int var1 = 0;
  120.       JDPHtmlTag var3 = null;
  121.       boolean var4 = false;
  122.       boolean var5 = false;
  123.  
  124.       int var2;
  125.       label141:
  126.       while((var2 = this.nextChar()) != -1) {
  127.          switch (var2) {
  128.             case 9:
  129.             case 10:
  130.                if (!this.preFormatted) {
  131.                   var2 = 32;
  132.                }
  133.             case 32:
  134.                if (!this.preFormatted && (!var5 || var4)) {
  135.                   continue;
  136.                }
  137.  
  138.                var4 = true;
  139.                break;
  140.             case 38:
  141.                if (this.peekChar() == 35) {
  142.                   var2 = this.parseCharacter();
  143.                } else if ((var2 = this.parseEntity()) == -1) {
  144.                   continue;
  145.                }
  146.  
  147.                if (var2 == 145) {
  148.                   var2 = 39;
  149.                }
  150.  
  151.                if (var2 == 146) {
  152.                   var2 = 39;
  153.                }
  154.  
  155.                if (var2 == 133) {
  156.                   this.input[var1++] = 46;
  157.                   this.input[var1++] = 46;
  158.                   var2 = 46;
  159.                }
  160.  
  161.                var4 = false;
  162.                break;
  163.             case 60:
  164.                boolean var6;
  165.                if (this.peekChar() == 47) {
  166.                   this.nextChar();
  167.                   var6 = true;
  168.                } else {
  169.                   var6 = false;
  170.                }
  171.  
  172.                String var7 = this.parseTagName();
  173.                if (var7 != null) {
  174.                   JDPHtmlTag var9 = JDPHtmlTag.lookup(var7);
  175.                   JDPHtmlTagRef var8 = null;
  176.                   if (this.handleTag(var9, var6, var1)) {
  177.                      if (!var6) {
  178.                         var8 = this.html.startTag(var9, var1);
  179.                      } else {
  180.                         var8 = this.html.endTag(var9, var1);
  181.                      }
  182.  
  183.                      var3 = var9;
  184.                      if (var9.breaks) {
  185.                         var5 = false;
  186.                      }
  187.                   }
  188.  
  189.                   if (!var6) {
  190.                      this.parseAttributes(var8);
  191.                   } else {
  192.                      this.skipUntil(62);
  193.                   }
  194.  
  195.                   if (this.nextChar() != 62) {
  196.                      this.warning("Malformed tag: " + var3);
  197.                   }
  198.  
  199.                   if (var8 != null && var8.tag.id == 26) {
  200.                      String var10 = var8.getAttribute("prompt");
  201.                      int var11 = var1;
  202.                      JDPHtmlTagRef var12 = this.html.startTag(FORMtag, var1);
  203.                      String var13 = var8.getAttribute("action");
  204.                      if (var13 != null) {
  205.                         var12.addAttribute("action", var13);
  206.                      }
  207.  
  208.                      this.html.startTag(HRtag, var1);
  209.                      if (var10 != null) {
  210.                         for(int var24 = 0; var24 < var10.length(); ++var24) {
  211.                            this.input[var1++] = (byte)var10.charAt(var24);
  212.                         }
  213.                      } else {
  214.                         var10 = "This is a searchable index.  Enter search keywords: ";
  215.                         this.output = new byte[this.input.length + var10.length() + 1];
  216.                         this.inputLength += var10.length() + 1;
  217.                         System.arraycopy(this.input, 0, this.output, 0, var1);
  218.  
  219.                         for(int var14 = 0; var14 < var10.length(); ++var14) {
  220.                            this.output[var1++] = (byte)var10.charAt(var14);
  221.                         }
  222.  
  223.                         System.arraycopy(this.input, var11 - 1, this.output, var1, this.input.length - var11);
  224.                         this.inputSeek += var10.length() + 1;
  225.                         this.input = this.output;
  226.                      }
  227.  
  228.                      var12 = this.html.startTag(INPUTtag, var1);
  229.                      var12.addAttribute("name", "isindex");
  230.                      this.html.endTag(HRtag, var1);
  231.                      this.html.endTag(FORMtag, var1);
  232.                   }
  233.  
  234.                   if (!var6 && var9.hasEndTag && var9.breaks && this.peekChar() == 10) {
  235.                      this.nextChar();
  236.                   }
  237.  
  238.                   if (var3 != null && var3.id == 43) {
  239.                      var1 = this.inputLength - this.inputSeek;
  240.                      System.arraycopy(this.input, this.inputSeek, this.input, 0, var1);
  241.                      break label141;
  242.                   }
  243.  
  244.                   var4 = false;
  245.                   continue;
  246.                }
  247.  
  248.                var2 = 60;
  249.                break;
  250.             default:
  251.                var4 = false;
  252.          }
  253.  
  254.          var3 = null;
  255.          var5 = true;
  256.          this.input[var1++] = (byte)var2;
  257.       }
  258.  
  259.       if (this.tagStack.size() != 0) {
  260.          String var16 = "Missing ";
  261.          int var19 = this.tagStack.size();
  262.  
  263.          while(true) {
  264.             --var19;
  265.             if (var19 <= 1) {
  266.                JDPHtmlTag var21 = (JDPHtmlTag)this.tagStack.pop();
  267.                this.html.endTag(var21, var1);
  268.                var16 = var16 + "</" + var21.name + ">";
  269.                this.warning(var16 + " at end of document.\n");
  270.                break;
  271.             }
  272.  
  273.             JDPHtmlTag var20 = (JDPHtmlTag)this.tagStack.pop();
  274.             this.html.endTag(var20, var1);
  275.             var16 = var16 + "</" + var20.name + ">, ";
  276.          }
  277.       }
  278.  
  279.       this.tagStack = null;
  280.       if (this.input.length != var1) {
  281.          byte[] var18 = new byte[var1];
  282.          System.arraycopy(this.input, 0, var18, 0, var1);
  283.          this.input = var18;
  284.       }
  285.  
  286.       this.html.setText(this.input);
  287.    }
  288.  
  289.    String makeLowerCaseString(byte[] var1, int var2, int var3) {
  290.       return (new String(var1, 0, var2, var3)).toLowerCase();
  291.    }
  292.  
  293.    final boolean isDigit(int var1) {
  294.       return var1 >= 48 && var1 <= 57;
  295.    }
  296.  
  297.    final void warning(String var1) {
  298.    }
  299.  
  300.    boolean handleTag(JDPHtmlTag var1, boolean var2, int var3) {
  301.       if (var2) {
  302.          try {
  303.             JDPHtmlTag var4 = (JDPHtmlTag)this.tagStack.peek();
  304.             if (var4 != var1) {
  305.                if (this.tagStack.search(var1) == -1) {
  306.                   this.warning("Ignoring tag: </" + var1.name + ">");
  307.                   return false;
  308.                }
  309.  
  310.                while(true) {
  311.                   JDPHtmlTag var5 = (JDPHtmlTag)this.tagStack.pop();
  312.                   if (var5 == var1) {
  313.                      break;
  314.                   }
  315.  
  316.                   this.warning("Missing </" + var5.name + "> just noticed by </" + var1.name + ">");
  317.                   this.html.endTag(var5, var3);
  318.                }
  319.             } else {
  320.                if (var1.id == 33) {
  321.                   this.preFormatted = false;
  322.                }
  323.  
  324.                this.tagStack.pop();
  325.             }
  326.          } catch (EmptyStackException var6) {
  327.             this.warning("Ignoring tag: </" + var1.name + ">");
  328.             return false;
  329.          }
  330.       } else if (var1.hasEndTag) {
  331.          if (var1.id == 33) {
  332.             this.preFormatted = true;
  333.          }
  334.  
  335.          this.tagStack.push(var1);
  336.       }
  337.  
  338.       return true;
  339.    }
  340.  
  341.    final int peekChar() {
  342.       return this.inputSeek >= this.inputLength ? -1 : this.input[this.inputSeek];
  343.    }
  344.  
  345.    final boolean isLetter(int var1) {
  346.       return var1 >= 65 && var1 <= 90 || var1 >= 97 && var1 <= 122;
  347.    }
  348.  
  349.    public JDPHtmlParser(InputStream var1, JDPHtmlDoc var2) {
  350.       this.readInput(var1);
  351.       this.html = var2;
  352.  
  353.       try {
  354.          this.parse();
  355.       } catch (Exception var5) {
  356.          this.warning("Caught exception while parsing\n");
  357.          ((Throwable)var5).printStackTrace();
  358.       }
  359.    }
  360.  
  361.    final void skipWhiteSpace() {
  362.       int var1;
  363.       while((var1 = this.nextChar()) == 32 || var1 == 10 || var1 == 9) {
  364.       }
  365.  
  366.       this.pushBack();
  367.    }
  368.  
  369.    final boolean isWhiteSpace(int var1) {
  370.       return var1 == 32 || var1 == 9 || var1 == 10;
  371.    }
  372.  
  373.    private void readInput(InputStream var1) {
  374.       this.input = new byte[16384];
  375.       this.output = this.input;
  376.       this.inputLength = 0;
  377.  
  378.       try {
  379.          int var2;
  380.          while((var2 = var1.read(this.input, this.inputLength, this.input.length - this.inputLength)) >= 0) {
  381.             this.inputLength += var2;
  382.             if (this.inputLength == this.input.length) {
  383.                byte[] var3 = new byte[this.inputLength * 2];
  384.                System.arraycopy(this.input, 0, var3, 0, this.inputLength);
  385.                this.input = var3;
  386.             }
  387.          }
  388.  
  389.       } catch (Exception var4) {
  390.       }
  391.    }
  392.  
  393.    void insistThat(boolean var1) {
  394.       if (!var1) {
  395.       }
  396.  
  397.    }
  398.  
  399.    public static void main(String[] var0) {
  400.       try {
  401.          URL var1 = new URL((URL)null, var0[0]);
  402.          new JDPHtmlParser(var1.openStream(), new JDPHtmlDoc());
  403.       } catch (Exception var3) {
  404.          ((Throwable)var3).printStackTrace();
  405.       }
  406.    }
  407.  
  408.    void skipUntil(int var1) {
  409.       int var2;
  410.       while((var2 = this.nextChar()) != var1 && var2 != -1) {
  411.       }
  412.  
  413.       this.pushBack();
  414.    }
  415.  
  416.    static {
  417.       ampChars.put("lt", new Character('<'));
  418.       ampChars.put("gt", new Character('>'));
  419.       ampChars.put("amp", new Character('&'));
  420.       ampChars.put("quot", new Character('"'));
  421.       ampChars.put("nbsp", new Character(' '));
  422.       ampChars.put("shy", new Character('-'));
  423.       FORMtag = JDPHtmlTag.lookup("form");
  424.       INPUTtag = JDPHtmlTag.lookup("input");
  425.       HRtag = JDPHtmlTag.lookup("hr");
  426.    }
  427.  
  428.    final boolean isTagChar(int var1) {
  429.       return this.isLetter(var1) || this.isDigit(var1) || var1 == 46 || var1 == 45;
  430.    }
  431.  
  432.    int parseCharacter() {
  433.       int var1 = 0;
  434.       this.insistThat(this.nextChar() == 35);
  435.  
  436.       int var2;
  437.       while(this.isDigit(var2 = this.nextChar())) {
  438.          var1 = var1 * 10 + var2 - 48;
  439.       }
  440.  
  441.       if (var2 != 59) {
  442.          this.pushBack();
  443.       }
  444.  
  445.       return var1;
  446.    }
  447.  
  448.    final void pushBack() {
  449.       if (this.input[this.inputSeek += -1] == 10) {
  450.          this.lineCount += -1;
  451.       }
  452.  
  453.    }
  454.  
  455.    int parseEntity() {
  456.       int var3 = this.inputSeek;
  457.       if (!this.isLetter(this.peekChar())) {
  458.          return 38;
  459.       } else {
  460.          int var4;
  461.          while((var4 = this.nextChar()) != -1 && this.isLetter(var4)) {
  462.          }
  463.  
  464.          int var5 = var4;
  465.          String var2 = new String(this.input, 0, var3, this.inputSeek - var3 - 1);
  466.          Character var1;
  467.          if ((var1 = (Character)ampChars.get(var2)) != null) {
  468.             var4 = var1;
  469.          } else {
  470.             var2 = var2.toLowerCase();
  471.             if ((var1 = (Character)ampChars.get(var2)) != null) {
  472.                var4 = var1;
  473.             } else {
  474.                this.warning("Warning: failed to find: &" + var2);
  475.                var4 = -1;
  476.             }
  477.          }
  478.  
  479.          if (var5 != 59) {
  480.             this.pushBack();
  481.          }
  482.  
  483.          return var4;
  484.       }
  485.    }
  486.  
  487.    String parseTagName() {
  488.       int var2 = this.inputSeek;
  489.       int var1;
  490.       if ((var1 = this.nextChar()) == 33) {
  491.          if (this.nextChar() == 45) {
  492.             while(this.nextChar() != 45) {
  493.             }
  494.  
  495.             while(this.nextChar() != 45) {
  496.             }
  497.  
  498.             while(this.nextChar() != 45) {
  499.             }
  500.          } else {
  501.             while(this.nextChar() != 62) {
  502.             }
  503.          }
  504.  
  505.          return "<comment>";
  506.       } else if (!this.isTagChar(var1)) {
  507.          this.pushBack();
  508.          return null;
  509.       } else {
  510.          while((var1 = this.nextChar()) != -1 && this.isTagChar(var1)) {
  511.          }
  512.  
  513.          this.pushBack();
  514.          if (this.inputSeek - var2 == 0) {
  515.             return null;
  516.          } else {
  517.             if (this.input[this.inputSeek] == 10) {
  518.                this.inputSeek += -1;
  519.             }
  520.  
  521.             return this.makeLowerCaseString(this.input, var2, this.inputSeek - var2);
  522.          }
  523.       }
  524.    }
  525. }
  526.