开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > WEB邮件程序 > 查看源码
HTTPLexer.java
资源名称：webmail-0.7.0-source.tar.bz2　[点击查看]
上传用户：huihesys
上传日期：2007-01-04
资源大小：3877k
文件大小：22k
源码类别：

WEB邮件程序

开发平台：

C/C++

HTTPLexer.java：源码内容
  1. /* The following code was generated by JFlex 1.2 on 18.05.00 09:47 */
  3. package net.wastl.webmail.standalone;
  4. import java_cup.runtime.*;   /* this is convenience, but not necessary */
  5. import java.io.Reader;
  7. /*
  8.  * http.lex
  9.  *
  10.  * Created: April 1999
  11.  *
  12.  * Copyright (C) 1999-2000 Sebastian Schaffert
  13.  * 
  14.  * This program is free software; you can redistribute it and/or
  15.  * modify it under the terms of the GNU General Public License
  16.  * as published by the Free Software Foundation; either version 2
  17.  * of the License, or (at your option) any later version.
  18.  * 
  19.  * This program is distributed in the hope that it will be useful,
  20.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22.  * GNU General Public License for more details.
  23.  * 
  24.  * You should have received a copy of the GNU General Public License
  25.  * along with this program; if not, write to the Free Software
  26.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  27.  */
  30. /**
  31.  * This class is a scanner generated by 
  32.  * <a href="http://www.informatik.tu-muenchen.de/~kleing/jflex/">JFlex</a> 1.2
  33.  * on 18.05.00 09:47 from the specification file
  34.  * <tt>http.lex</tt>
  35.  */
  36. class HTTPLexer extends sym {
  38.   /** this character denotes the end of file */
  39.   final public static int YYEOF = -1;
  41.   /** lexical states */
  42.   final public static int HEADERDATA = 2;
  43.   final public static int CONTENT = 4;
  44.   final public static int YYINITIAL = 0;
  45.   final public static int HEADER = 1;
  46.   final public static int END = 3;
  48.   /** 
  49.    * Translates characters to character classes
  50.    */
  51.   final private static char [] yycmap = {
  52.     24, 24, 24, 24, 24, 24, 24, 24, 24, 14, 12, 24, 24, 11, 24, 24, 
  53.     24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 26, 25, 25, 25, 25, 25, 
  54.     13, 28, 26, 25, 28, 28, 28, 28, 27, 27, 28, 28, 27, 32, 22, 21, 
  55.      1,  1,  1,  1,  1,  1,  1,  1,  1,  1, 23, 31, 26, 29, 26, 27, 
  56.     27,  2,  3,  4,  5,  6,  7,  9, 18,  8, 28, 28, 34, 33, 20, 16, 
  57.     15, 28, 35, 17, 10, 19, 28, 30, 37, 36, 28, 26, 26, 26, 25, 28, 
  58.     25,  2,  3,  4,  5,  6,  7,  9, 18,  8, 28, 28, 34, 33, 20, 16, 
  59.     15, 28, 35, 17, 10, 19, 28, 38, 37, 36, 28, 26, 28, 26, 25, 25, 
  60.     25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 
  61.     25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 
  62.     25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,  0,  0, 
  63.      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
  64.      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
  65.      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
  66.      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 
  67.      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
  68.   };
  70.   /** 
  71.    * Translates a state to a row index in the transition table
  72.    */
  73.   final private static int yy_rowMap [] = { 
  74.         0,    39,    78,   117,   156,   195,   234,   273,   312,   351, 
  75.       390,   429,   468,   507,   312,   546,   585,   312,   624,   663, 
  76.       702,   741,   780,   819,   858,   312,   312,   195,   897,   936, 
  77.       975,  1014,  1053,  1092,   546,   312,  1131,   819,  1170,  1209, 
  78.       195,  1248,  1287,  1326,  1365,  1404,   507,  1443,  1482,  1521, 
  79.      1560,  1599,  1638,  1677,  1716,  1755,  1794,  1833,  1872,  1911, 
  80.      1950,  1872,  1989,  2028,  2067,  2106,  2145,  2184,  2223,  2262, 
  81.      2301,  2340,  2379,  2418,  2457,  2496,  2535,  2574,  2613,  2652, 
  82.      2691,  2730,  2769,  2808,  2847,  2886,  2925,  2964,  3003,  3042, 
  83.      3081,  3120,  3159,  3198,  3237,  3276,  3315,  3354,  3393,  3432, 
  84.      3471,  3510,  3549,  3588,  3627,  3666,  3705,  3744,  3783,  3822, 
  85.      3744,  3861
  86.   };
  88.   /** 
  89.    * The packed transition table of the DFA
  90.    */
  91.   final private static String yy_packed = 
  92.     "1161716110111212113114"+
  93.     "16115261161621716217"+
  94.     "16317761320121122223620"+
  95.     "117120124117120217120317"+
  96.     "7201171251261025127130125"+
  97.     "1171125117102513152547324733"+
  98.     "1334463411341351134"+
  99.     "2134315341364344634"+
  100.     "1134135113421343"+
  101.     "734141111162123013344"+
  102.     "1341372341361341134135"+
  103.     "11342134322344140"+
  104.     "534113413511342134"+
  105.     "3153414133414246341"+
  106.     "134135113421343734"+
  107.     "11216411163141613434"+
  108.     "643114314411432143"+
  109.     "3743141224722310124"+
  110.     "34224311225212511125"+
  111.     "116251122521251145"+
  112.     "1025116251413024645246"+
  113.     "31122521251425147425"+
  114.     "11625251502112341514"+
  115.     "634113413511342134"+
  116.     "3223442341363341134"+
  117.     "1351134213432134152"+
  118.     "4634113413511342"+
  119.     "13431134153103446341"+
  120.     "1341351134213432134"+
  121.     "154463411341351134"+
  122.     "21343734112252125"+
  123.     "1155102511625112252"+
  124.     "125111251112515642525"+
  125.     "15721103416023446341"+
  126.     "1341351134213431434"+
  127.     "151534463411341351"+
  128.     "1342134322344161534"+
  129.     "1134135113421343"+
  130.     "734112252125111251"+
  131.     "1125162425111251632125"+
  132.     "111251162513344134164"+
  133.     "434113413511342134"+
  134.     "3223446341651341351"+
  135.     "134213437341725166"+
  136.     "225212511125116251"+
  137.     "7251672252125111251"+
  138.     "1625133445341511134135"+
  139.     "1134213437341170"+
  140.     "46325171625212511125"+
  141.     "116251122521251172"+
  142.     "10251162511702417321"+
  143.     "12517410252125111251"+
  144.     "16251125175102521251"+
  145.     "1125116251176461125177"+
  146.     "2125111251162511225"+
  147.     "212511125112251100325"+
  148.     "17251101225212511125"+
  149.     "1162511125110221251"+
  150.     "1125116251122521251"+
  151.     "125110372511625112252"+
  152.     "12516251104225116251"+
  153.     "12252125152511053251"+
  154.     "16251625110632521251"+
  155.     "1125116251122521251"+
  156.     "625110722511625112252"+
  157.     "12511251110725116251"+
  158.     "1225212511125114251111"+
  159.     "125112252125111251"+
  160.     "122511123251122521251"+
  161.     "112517251113625112252"+
  162.     "125111251102511145251"+
  163.     "122521251112515251115"+
  164.     "725111511225212511125"+
  165.     "17251116625112252125"+
  166.     "111251525111772511171"+
  167.     "42511205252125111251"+
  168.     "1625112252125111251"+
  169.     "52511217251121112511221025"+
  170.     "2125111251162511225"+
  171.     "21251112517251123625"+
  172.     "1112511242125111251"+
  173.     "16251625112532521251"+
  174.     "1125116251125112610252"+
  175.     "1251112511625112252"+
  176.     "12511251127725116251"+
  177.     "122521251112516251130"+
  178.     "725112252125111251"+
  179.     "1225113132511225211321"+
  180.     "1125116251122521251"+
  181.     "112511025113352512251134"+
  182.     "725212511125116251"+
  183.     "122521251112517251135"+
  184.     "62511225212511251136"+
  185.     "725116251122521251"+
  186.     "425113742511625112252"+
  187.     "12514251140425116251"+
  188.     "1225212511125112251141"+
  189.     "32511225212515251142"+
  190.     "325116251122521251"+
  191.     "112511125114342514251144"+
  192.     "525212511125116251"+
  193.     "52511454252125111251"+
  194.     "162511251146102521251"+
  195.     "1125116251122521251"+
  196.     "525114732511625112252"+
  197.     "125111251122511503251"+
  198.     "32511516252125111251"+
  199.     "1625112252125111251"+
  200.     "132511522251122521251"+
  201.     "125115372511625112252"+
  202.     "125111251425115411251"+
  203.     "42511555252125111251"+
  204.     "1625115612157212516157125"+
  205.     "11571251115722511573257157"+
  206.     "15251160425212511125"+
  207.     "116251315646156111562"+
  208.     "1156211563715614251157"+
  209.     "52521251112511625";
  211.   /** 
  212.    * The transition table of the DFA
  213.    */
  214.   final private static int yytrans [] = yy_unpack(yy_packed);
  217.   /* error codes */
  218.   final private static int YY_UNKNOWN_ERROR = 0;
  219.   final private static int YY_ILLEGAL_STATE = 1;
  220.   final private static int YY_NO_MATCH = 2;
  221.   final private static int YY_PUSHBACK_2BIG = 3;
  223.   /* error messages for the codes above */
  224.   final private static String YY_ERROR_MSG[] = {
  225.     "Unkown internal scanner error",
  226.     "Internal error: unknown state",
  227.     "Error: could not match input",
  228.     "Error: pushback value was too large"
  229.   };
  231.   /**
  232.    * YY_ATTRIBUTE[aState] contains the attributes of state <code>aState</code>
  233.    */
  234.   private final static byte YY_ATTRIBUTE[] = {
  235.      0,  0,  0,  0,  0,  1,  1,  1,  9,  1,  1,  1,  1,  1,  9,  3, 
  236.      1,  9,  1,  1,  1,  1,  1,  1,  1,  9,  9,  0,  0,  0,  0,  0, 
  237.      0,  0,  2, 13,  1,  1,  1,  0,  1,  0,  0,  0,  1,  1,  0,  0, 
  238.      0,  1,  1,  0,  0,  1,  1,  0,  1,  1,  0,  1,  1,  1,  1,  1, 
  239.      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, 
  240.      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, 
  241.      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1
  242.   };
  244.   /** the input device */
  245.   private java.io.Reader yy_reader;
  247.   /** the current state of the DFA */
  248.   private int yy_state;
  250.   /** the current lexical state */
  251.   private int yy_lexical_state = YYINITIAL;
  253.   /** this buffer contains the current text to be matched and is
  254.       the source of the yytext() string */
  255.   private char yy_buffer[] = new char[16384];
  257.   /** the textposition at the last accepting state */
  258.   private int yy_markedPos;
  260.   /** the current text position in the buffer */
  261.   private int yy_currentPos;
  263.   /** startRead marks the beginning of the yytext() string in the buffer */
  264.   private int yy_startRead;
  266.   /** endRead marks the last character in the buffer, that has been read
  267.       from input */
  268.   private int yy_endRead;
  270.   /** number of newlines encountered up to the start of the matched text */
  271.   private int yyline;
  273.   /** the number of characters up to the start of the matched text */
  274.   private int yychar;
  276.   /**
  277.    * the number of characters from the last newline up to the start of the 
  278.    * matched text
  279.    */
  280.   private int yycolumn; 
  282.   /** 
  283.    * yy_atBOL == true <=> the scanner is currently at the beginning of a line
  284.    */
  285.   private boolean yy_atBOL;
  287.   /** yy_atEOF == true <=> the scanner has returned a value for EOF */
  288.   private boolean yy_atEOF;
  290.   /* user code: */
  292.     boolean has_content=false;
  294.     boolean versionset=false;
  296.     boolean set_contenttype=false;
  297.     boolean set_contentlength=false;
  299.     String content_type;
  301.     int contentlength=0;
  303.     int cur_contentlength;
  305.     StringBuffer string = new StringBuffer();
  307.     private Symbol symbol(int type) {
  308. return new Symbol(type, yyline, yycolumn);
  309.     }
  310.     private Symbol symbol(int type, Object value) {
  311. return new Symbol(type, yyline, yycolumn, value);
  312.     }
  313.   
  314.     public String getContentType() {
  315. return content_type;
  316.     }
  319.   /**
  320.    * Creates a new scanner
  321.    * There is also a java.io.InputStream version of this constructor.
  322.    *
  323.    * @param   in  the java.io.Reader to read input from.
  324.    */
  325.   HTTPLexer(java.io.Reader in) {
  326.     this.yy_reader = in;
  327.   }
  329.   /**
  330.    * Creates a new scanner.
  331.    * There is also java.io.Reader version of this constructor.
  332.    *
  333.    * @param   in  the java.io.Inputstream to read input from.
  334.    */
  335.   HTTPLexer(java.io.InputStream in) {
  336.     this(new java.io.InputStreamReader(in));
  337.   }
  339.   /** 
  340.    * Unpacks the compressed DFA transition table.
  341.    *
  342.    * @param packed   the packed transition table
  343.    * @return         the unpacked transition table
  344.    */
  345.   private static int [] yy_unpack(String packed) {
  346.     int [] trans = new int[3900];
  347.     int i = 0;  /* index in packed string  */
  348.     int j = 0;  /* index in unpacked array */
  349.     while (i < 1886) {
  350.       int count = packed.charAt(i++);
  351.       int value = packed.charAt(i++);
  352.       value--;
  353.       do trans[j++] = value; while (--count > 0);
  354.     }
  355.     return trans;
  356.   }
  359.   /**
  360.    * Gets the next input character.
  361.    *
  362.    * @return      the next character of the input stream, EOF if the
  363.    *              end of the stream is reached.
  364.    * @exception   IOException  if any I/O-Error occurs
  365.    */
  366.   private int yy_advance() throws java.io.IOException {
  368.     /* standard case */
  369.     if (yy_currentPos < yy_endRead) return yy_buffer[yy_currentPos++];
  371.     /* if the eof is reached, we don't need to work hard */ 
  372.     if (yy_atEOF) return YYEOF;
  374.     /* otherwise: need to refill the buffer */
  376.     /* first: make room (if you can) */
  377.     if (yy_startRead > 0) {
  378.       System.arraycopy(yy_buffer, yy_startRead, 
  379.                        yy_buffer, 0, 
  380.                        yy_endRead-yy_startRead);
  382.       /* translate stored positions */
  383.       yy_endRead-= yy_startRead;
  384.       yy_currentPos-= yy_startRead;
  385.       yy_markedPos-= yy_startRead;
  386.       yy_startRead = 0;
  387.     }
  389.     /* is the buffer big enough? */
  390.     if (yy_currentPos >= yy_buffer.length) {
  391.       /* if not: blow it up */
  392.       char newBuffer[] = new char[yy_currentPos*2];
  393.       System.arraycopy(yy_buffer, 0, newBuffer, 0, yy_buffer.length);
  394.       yy_buffer = newBuffer;
  395.     }
  397.     /* finally: fill the buffer with new input */
  398.     int numRead = yy_reader.read(yy_buffer, yy_endRead, 
  399.                                             yy_buffer.length-yy_endRead);
  401.     if ( numRead == -1 ) return YYEOF;
  403.     yy_endRead+= numRead;
  405.     return yy_buffer[yy_currentPos++];
  406.   }
  409.   /**
  410.    * Closes the input stream.
  411.    */
  412.   final public void yyclose() throws java.io.IOException {
  413.     yy_atEOF = true;            /* indicate end of file */
  414.     yy_endRead = yy_startRead;  /* invalidate buffer    */
  415.     yy_reader.close();
  416.   }
  419.   /**
  420.    * Returns the current lexical state.
  421.    */
  422.   final public int yystate() {
  423.     return yy_lexical_state;
  424.   }
  426.   /**
  427.    * Enters a new lexical state
  428.    *
  429.    * @param newState the new lexical state
  430.    */
  431.   final public void yybegin(int newState) {
  432.     yy_lexical_state = newState;
  433.   }
  436.   /**
  437.    * Returns the text matched by the current regular expression.
  438.    */
  439.   final public String yytext() {
  440.     return new String( yy_buffer, yy_startRead, yy_markedPos-yy_startRead );
  441.   }
  443.   /**
  444.    * Returns the length of the matched text region.
  445.    */
  446.   final public int yylength() {
  447.     return yy_markedPos-yy_startRead;
  448.   }
  451.   /**
  452.    * Reports an error that occured while scanning.
  453.    *
  454.    * @param   errorCode  the code of the errormessage to display
  455.    */
  456.   private void yy_ScanError(int errorCode) {
  457.     try {
  458.       System.out.println(YY_ERROR_MSG[errorCode]);
  459.     }
  460.     catch (ArrayIndexOutOfBoundsException e) {
  461.       System.out.println(YY_ERROR_MSG[YY_UNKNOWN_ERROR]);
  462.     }
  464.     System.exit(1);
  465.   } 
  468.   /**
  469.    * Pushes the specified amount of characters back into the input stream.
  470.    *
  471.    * They will be read again by then next call of the scanning method
  472.    *
  473.    * @param number  the number of characters to be read again.
  474.    *                This number must not be greater than yylength()!
  475.    */
  476.   private void yypushback(int number) {
  477.     if ( number > yylength() )
  478.       yy_ScanError(YY_PUSHBACK_2BIG);
  480.     yy_markedPos -= number;
  481.   }
  484.   /**
  485.    * Resumes scanning until the next regular expression is matched,
  486.    * the end of input is encountered or an I/O-Error occurs.
  487.    *
  488.    * @return      the next token
  489.    * @exception   IOException  if any I/O-Error occurs
  490.    */
  491.   public java_cup.runtime.Symbol yylex() throws java.io.IOException {
  492.     int yy_input;
  493.     int yy_action;
  495.     int yy_pushbackPos = -1;
  496.     boolean yy_was_pushback;
  498.     while (true) {
  500.       boolean yy_counted = false;
  501.       for (yy_currentPos = yy_startRead; yy_currentPos < yy_markedPos;
  502.                                                       yy_currentPos++) {
  503.         switch (yy_buffer[yy_currentPos]) {
  504.         case 'r':
  505.           yyline++;
  506.           yycolumn = 0;
  507.           yy_counted = true;
  508.           break;
  509.         case 'n':
  510.           if (yy_counted)
  511.             yy_counted = false;
  512.           else {
  513.             yyline++;
  514.             yycolumn = 0;
  515.           }
  516.           break;
  517.         default:
  518.           yy_counted = false;
  519.           yycolumn++;
  520.         }
  521.       }
  523.       if (yy_counted) {
  524.         if ( yy_advance() == 'n' ) yyline--;
  525.         if ( !yy_atEOF ) yy_currentPos--;
  526.       }
  528.       yy_action = -1;
  530.       yy_currentPos = yy_startRead = yy_markedPos;
  532.       yy_state = yy_lexical_state;
  534.       yy_was_pushback = false;
  536.       yy_forAction: {
  537.         while (true) {
  539.           yy_input = yy_advance();
  541.           if ( yy_input == YYEOF ) break yy_forAction;
  543.           int yy_next = yytrans[ yy_rowMap[yy_state] + yycmap[yy_input] ];
  544.           if (yy_next == -1) break yy_forAction;
  545.           yy_state = yy_next;
  547.           int yy_attributes = YY_ATTRIBUTE[yy_state];
  548.           if ( (yy_attributes & 2) > 0 )
  549.             yy_pushbackPos = yy_currentPos;
  551.           if ( (yy_attributes & 1) > 0 ) {
  552.             yy_was_pushback = (yy_attributes & 4) > 0;
  553.             yy_action = yy_state; 
  554.             yy_markedPos = yy_currentPos; 
  555.             if ( (yy_attributes & 8) > 0 ) break yy_forAction;
  556.           }
  558.         }
  559.       }
  561.       if (yy_was_pushback)
  562.         yy_markedPos = yy_pushbackPos;
  564.       switch (yy_action) {    
  566.         case 40: 
  567.           { versionset=true;
  568.                       return symbol(METHOD,yytext()); }
  569.         case 113: break;
  570.         case 37: 
  571.           { string.append(" "); }
  572.         case 114: break;
  573.         case 19: 
  574.           { string.setLength(0); 
  575.                      yybegin(HEADERDATA); 
  576.      return symbol(HEAD_SEP); }
  577.         case 115: break;
  578.         case 20: 
  579.         case 21: 
  580.         case 24: 
  581.         case 36: 
  582.         case 38: 
  583.         case 44: 
  584.         case 45: 
  585.         case 49: 
  586.         case 50: 
  587.         case 53: 
  588.         case 54: 
  589.         case 56: 
  590.         case 57: 
  591.         case 59: 
  592.         case 60: 
  593.         case 62: 
  594.         case 63: 
  595.         case 64: 
  596.         case 65: 
  597.         case 66: 
  598.         case 67: 
  599.         case 68: 
  600.         case 69: 
  601.         case 70: 
  602.         case 71: 
  603.         case 72: 
  604.         case 73: 
  605.         case 74: 
  606.         case 75: 
  607.         case 76: 
  608.         case 77: 
  609.         case 78: 
  610.         case 79: 
  611.         case 80: 
  612.         case 81: 
  613.         case 82: 
  614.         case 83: 
  615.         case 84: 
  616.         case 85: 
  617.         case 86: 
  618.         case 87: 
  619.         case 88: 
  620.         case 89: 
  621.         case 90: 
  622.         case 91: 
  623.         case 92: 
  624.         case 93: 
  625.         case 94: 
  626.         case 95: 
  627.         case 96: 
  628.         case 97: 
  629.         case 98: 
  630.         case 99: 
  631.         case 100: 
  632.         case 101: 
  633.         case 102: 
  634.         case 103: 
  635.         case 104: 
  636.         case 105: 
  637.         case 106: 
  638.         case 107: 
  639.         case 108: 
  640.         case 111: 
  641.           { string.append(yytext()); }
  642.         case 116: break;
  643.         case 61: 
  644.           { return symbol(VERSION,yytext().substring(5)); }
  645.         case 117: break;
  646.         case 25: 
  647.           { return symbol(EOF); }
  648.         case 118: break;
  649.         case 9: 
  650.         case 18: 
  651.           { return symbol(SP); }
  652.         case 119: break;
  653.         case 13: 
  654.           { return symbol(URI,yytext()); }
  655.         case 120: break;
  656.         case 26: 
  657.           { string.append(yytext());
  658.      cur_contentlength++;
  659.      if(contentlength>0 && cur_contentlength >= contentlength) {
  660.        yy_atEOF = true;            /* indicate end of file */
  661.        yy_endRead = yy_startRead;  /* invalidate buffer    */
  662.        yybegin(END);  
  663.                        return symbol(DATA,string.toString()); 
  664.      } }
  665.         case 121: break;
  666.         case 5: 
  667.         case 6: 
  668.         case 10: 
  669.         case 11: 
  670.         case 12: 
  671.         case 14: 
  672.         case 15: 
  673.           { System.err.println("Invalid input!"); }
  674.         case 122: break;
  675.         case 35: 
  676.           { if(yytext().toUpperCase().trim().equals("CONTENT-LENGTH")) {
  677.  set_contentlength=true;
  678.      } else if(yytext().toUpperCase().trim().equals("CONTENT-TYPE")) {
  679.  set_contenttype=true;
  680.      }
  681.                      return symbol(TOKEN,yytext()); }
  682.         case 123: break;
  683.         case 16: 
  684.         case 17: 
  685.           { if(has_content) {
  686.  cur_contentlength=0;
  687.  string.setLength(0); 
  688.  yybegin(CONTENT);
  689.                     } else {
  690. yy_atEOF = true;            /* indicate end of file */
  691. yy_endRead = yy_startRead;  /* invalidate buffer    */
  692. yybegin(END);
  693.     }
  694.      return symbol(CRLF); }
  695.         case 124: break;
  696.         case 22: 
  697.         case 23: 
  698.           { if(set_contentlength) {
  699.  try {
  700.      contentlength=Integer.parseInt(string.toString());
  701.  } catch(NumberFormatException e) {
  702.      e.printStackTrace();
  703.  }
  704.  set_contentlength=false;
  705.      } else if(set_contenttype) {
  706.  content_type=string.toString();
  707.  set_contenttype=false;
  708.      }
  709.      yybegin(HEADER);  
  710.                      return symbol(DATA,string.toString()); }
  711.         case 125: break;
  712.         case 109: 
  713.         case 110: 
  714.           { has_content=true;
  715.      string.append(yytext()); }
  716.         case 126: break;
  717.         case 7: 
  718.         case 8: 
  719.           { if(versionset) {
  720.                         yybegin(HEADER); 
  721.         return symbol(CRLF);
  722.                       } }
  723.         case 127: break;
  724.         default: 
  725.           if (yy_input == YYEOF && yy_startRead == yy_currentPos) {
  726.             yy_atEOF = true;
  727.               {     return new java_cup.runtime.Symbol(sym.EOF);
  728.  }
  729.           } 
  730.           else {
  731.             yy_ScanError(YY_NO_MATCH);
  732.           }
  733.       }
  734.     }
  735.   }    
  738. }