0001: /*
0002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
0003: *
0004: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
0005: *
0006: * The contents of this file are subject to the terms of either the GNU
0007: * General Public License Version 2 only ("GPL") or the Common
0008: * Development and Distribution License("CDDL") (collectively, the
0009: * "License"). You may not use this file except in compliance with the
0010: * License. You can obtain a copy of the License at
0011: * http://www.netbeans.org/cddl-gplv2.html
0012: * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
0013: * specific language governing permissions and limitations under the
0014: * License. When distributing the software, include this License Header
0015: * Notice in each file and include the License file at
0016: * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
0017: * particular file as subject to the "Classpath" exception as provided
0018: * by Sun in the GPL Version 2 section of the License file that
0019: * accompanied this code. If applicable, add the following below the
0020: * License Header, with the fields enclosed by brackets [] replaced by
0021: * your own identifying information:
0022: * "Portions Copyrighted [year] [name of copyright owner]"
0023: *
0024: * Contributor(s):
0025: *
0026: * The Original Software is NetBeans. The Initial Developer of the Original
0027: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
0028: * Microsystems, Inc. All Rights Reserved.
0029: *
0030: * If you wish your version of this file to be governed by only the CDDL
0031: * or only the GPL Version 2, indicate your decision by adding
0032: * "[Contributor] elects to include this software in this distribution
0033: * under the [CDDL or GPL Version 2] license." If you do not indicate a
0034: * single choice of license, a recipient has the option to distribute
0035: * your version of this file under either the CDDL, the GPL Version 2 or
0036: * to extend the choice of license to its licensees as provided above.
0037: * However, if you add GPL Version 2 code and therefore, elected the GPL
0038: * Version 2 license, then the option applies only if the new code is
0039: * made subject to such option by the copyright holder.
0040: */
0041:
0042: package org.netbeans.modules.web.core.syntax.deprecated;
0043:
0044: import java.util.logging.Level;
0045: import java.util.logging.Logger;
0046: import org.netbeans.modules.web.core.syntax.deprecated.JspTagSyntax;
0047: import org.netbeans.modules.web.core.syntax.*;
0048: import org.netbeans.modules.web.core.syntax.deprecated.ELSyntax;
0049: import org.netbeans.editor.TokenContextPath;
0050: import org.netbeans.editor.Syntax;
0051: import org.netbeans.editor.TokenID;
0052: import org.netbeans.editor.ext.html.HTMLTokenContext;
0053:
0054: /**
0055: * Syntax for JSP files. This is a MultiSyntax consisting of three slave syntaxes:
0056: * content language syntax (for example HTMLSyntax), JspTagSyntax and scripting
0057: * language syntax (for example JavaSyntax). The content language and scripting language
0058: * syntaxes are completely pluggable, moreover, they can be changed dynamically by
0059: * setContentSyntax() and setScriptingSyntax() methods. The caller of these methods should
0060: * make sure that the whole document is recolored after calling these methods.
0061: *
0062: * @author Petr Jiricka
0063: * @version 1.00
0064: * @deprecated Use JSP Lexer instead
0065: */
0066:
0067: public class JspMultiSyntax extends Syntax {
0068:
0069: //<editor-fold defaultstate="collapsed" desc="class & instance members">
0070:
0071: // modes of nesting of languages
0072: public static final int MODE_HOST = 1;
0073: public static final int MODE_HOST_JSPTAG = 2;
0074: public static final int MODE_HOST_EL = 5;
0075: public static final int MODE_HOST_JSPTAG_EL = 6;
0076: public static final int MODE_HOST_JSPTAG_JAVA = 3;
0077: public static final int MODE_HOST_JAVA = 4;
0078:
0079: // constants for result of operation of checking delimiters
0080: protected static final int DELIMCHECK_NO = -1;
0081: protected static final int DELIMCHECK_PART = -2;
0082:
0083: // states of this multisyntax
0084: private static final int ISI_LANGUAGE = 1; // one syntax is active and working
0085: // states for switching from the host language to JSP tag or Java or EL
0086: private static final int ISI_HOST_JSPTAG = 2; // just before <jsptag or similar (recognized by JspTagSyntax)
0087: private static final int ISI_HOST_JAVA = 3; // just before <% or similar, after such a delimiter Java block starts, host language
0088: private static final int ISI_HOST_JAVA_LT = 4; // as ISI_HOST_JAVA after <
0089: private static final int ISI_HOST_JAVA_LT_PC = 5; // as ISI_HOST_JAVA after <%
0090: private static final int ISI_HOST_JAVA_JUMP = 6; // after a Java delimiter in host language, now really switch
0091: private static final int ISI_HOST_EL = 17; // just before ${ , after such a delimiter EL block starts, host language
0092: private static final int ISI_HOST_EL_D = 18; // as ISI_HOST_EL after $
0093: private static final int ISI_HOST_EL_JUMP = 20; // after a EL delimiter ${ in host language, now really switch
0094: // states for switching from a JSP tag to Java or EL
0095: private static final int ISI_JSPTAG_JAVA = 7; // just before <% or similar, after such a delimiter Java block starts, JSPTAG language
0096: private static final int ISI_JSPTAG_JAVA_LT = 8; // as ISI_JSPTAG_JAVA after <
0097: private static final int ISI_JSPTAG_JAVA_LT_PC = 9; // as ISI_JSPTAG_JAVA after <%
0098: private static final int ISI_JSPTAG_JAVA_JUMP = 10; // after a Java delimiter in JSPTAG language, now really switch
0099: private static final int ISI_JSPTAG_EL = 21; // just before ${ , after such a delimiter EL block starts, JSPTAG language
0100: private static final int ISI_JSPTAG_EL_D = 22; // as ISI_JSPTAG_EL after $
0101: private static final int ISI_JSPTAG_EL_JUMP = 24; // after a EL delimiter ${ in JSPTAG language, now really switch
0102: // states for switching from Java to a JSP tag
0103: private static final int ISI_JAVA1_SWITCH = 11; // just before %> in Java (go to JSPTAG)
0104: private static final int ISI_JAVA1_PC = 12; // as ISI_JAVA1_SWITCH after %
0105: private static final int ISI_JAVA1_JUMP = 13; // after %> in Java, now really switch to JSPTAG
0106: // states for switching from Java to host
0107: private static final int ISI_JAVA2_SWITCH = 14; // just before %> in Java (go to host)
0108: private static final int ISI_JAVA2_PC = 15; // as ISI_JAVA2_SWITCH after %
0109: private static final int ISI_JAVA2_JUMP = 16; // after %> in Java, now really switch to host
0110: // states for switching from EL to a JSP tag
0111: private static final int ISI_EL1_SWITCH = 25; // just before } in EL (go to JSPTAG)
0112: private static final int ISI_EL1_JUMP = 26; // after } in EL, now really switch to JSPTAG
0113: // states for switching from EL to host
0114: private static final int ISI_EL2_SWITCH = 27; // just before } in EL (go to host)
0115: private static final int ISI_EL2_JUMP = 28; // after } in EL, now really switch to host
0116:
0117: // states of the automaton which looks for delimiters in the host language
0118: private static final int HOST_INIT = 1; // initial state - host language
0119: private static final int HOST_LT = 2; // after < - host language
0120: private static final int HOST_LT_PC = 3; // after <% - host language
0121: private static final int HOST_LT_BLANK = 4; // after < or </ and several blanks or \t - host language
0122: private static final int HOST_TAG = 5; // inside a tag, don't know whether html or JSP - host language
0123: private static final int HOST_LT_SLASH = 6; // after </ - host lanaguage
0124: private static final int HOST_BS = 7; // after \ (escapes $) - host language
0125: private static final int HOST_D = 8; // after $ - host language
0126:
0127: // states of the automaton which looks for delimiters in the JSP tag
0128: private static final int JSPTAG_INIT = 1; // initial state - JSP tag
0129: private static final int JSPTAG_LT = 2; // after < - JSP tag
0130: private static final int JSPTAG_LT_PC = 3; // after <% - JSP tag
0131: private static final int JSPTAG_BS = 7; // after \ (escapes $) - JSPTAG language
0132: private static final int JSPTAG_D = 8; // after $ - JSPTAG language
0133:
0134: // states of the automaton which looks for delimiters in Java
0135: private static final int JAVA_INIT = 1; // initial state - Java block
0136: private static final int JAVA_PC = 2; // after % - Java block
0137:
0138: // states of the automaton which looks for delimiters in EL
0139: private static final int EL_INIT = 1; // initial state - EL block
0140:
0141: //States of java scripting element type
0142: private static final int JAVA_SCRIPTLET = 1;
0143: private static final int JAVA_DECLARATION = 2;
0144: private static final int JAVA_EXPRESSION = 3;
0145:
0146: //state info defining contexts of java tokens (declaration/scriptlet/expression)
0147: private static int javaNestMode;
0148:
0149: protected int nestMode;
0150:
0151: protected Syntax hostSyntax;
0152: protected Syntax jspTagSyntax;
0153: protected Syntax elSyntax;
0154: protected Syntax javaSyntax;
0155:
0156: /** When returning from parseToken(), contains the state of the 'host' slave syntax at 'offset'.
0157: * Always a part of the StateInfo. */
0158: protected StateInfo hostStateInfo;
0159: /** When returning from parseToken(), contains the state of the 'jspTag' slave syntax at 'offset'.
0160: * Always a part of the StateInfo. */
0161: protected StateInfo jspTagStateInfo;
0162: /** When returning from parseToken(), contains the state of the 'el' slave syntax at 'offset'.
0163: * Always a part of the StateInfo. */
0164: protected StateInfo elStateInfo;
0165: /** When returning from parseToken(), contains the state of the 'java' slave syntax at 'offset'.
0166: * Always a part of the StateInfo. */
0167: protected StateInfo javaStateInfo;
0168:
0169: // Contains the tokenLength returned by the first call of nextToken() on the slave syntax. May need to be
0170: // stored in the stateinfo if tokenOffset != offset.
0171: // If the first call of slave's nextToken() returned null, this variable will not be valid, and
0172: // the next call must update this variable with the correct value
0173: private int firstTokenLength;
0174:
0175: // Contains the tokenID returned by the first call of nextToken() on the slave syntax. May need to be
0176: // stored in the stateinfo if tokenOffset != offset.
0177: // If the first call of slave's nextToken() returned null, it will be reflected in this variable, and
0178: // the next call must update this variable with the correct value
0179: private TokenID firstTokenID;
0180:
0181: // One of the following stateInfos will be a part of the stateInfo, if we are returning null.
0182: // In such a case it will contain the state of the scanning syntax at 'tokenOffset'.
0183: private StateInfo helpHostStateInfo;
0184: private StateInfo helpJspTagStateInfo;
0185: private StateInfo helpELStateInfo;
0186: private StateInfo helpJavaStateInfo;
0187:
0188: // These stateinfos hold the stateinfo after the first token returned by the scanning stave syntax.
0189: // Only when tokenOffset == offset, in the other case need to rescan the first token before returning.
0190: private StateInfo firstHostStateInfo;
0191: private StateInfo firstJspTagStateInfo;
0192: private StateInfo firstELStateInfo;
0193: private StateInfo firstJavaStateInfo;
0194:
0195: //</editor-fold>
0196:
0197: public JspMultiSyntax() {
0198: // create the JSP tag syntax
0199: jspTagSyntax = new JspTagSyntax();
0200: firstJspTagStateInfo = jspTagSyntax.createStateInfo();
0201: helpJspTagStateInfo = jspTagSyntax.createStateInfo();
0202: // create the EL syntax
0203: elSyntax = new ELSyntax();
0204: firstELStateInfo = elSyntax.createStateInfo();
0205: helpELStateInfo = elSyntax.createStateInfo();
0206:
0207: }
0208:
0209: public JspMultiSyntax(Syntax contentSyntax, Syntax scriptingSyntax) {
0210: this ();
0211: setContentSyntax(contentSyntax);
0212: setScriptingSyntax(scriptingSyntax);
0213: }
0214:
0215: public void setContentSyntax(Syntax contentSyntax) {
0216: hostSyntax = contentSyntax;
0217: firstHostStateInfo = hostSyntax.createStateInfo();
0218: helpHostStateInfo = hostSyntax.createStateInfo();
0219: }
0220:
0221: public Syntax getContentSyntax() {
0222: return hostSyntax;
0223: }
0224:
0225: public void setScriptingSyntax(Syntax scriptingSyntax) {
0226: javaSyntax = scriptingSyntax;
0227: firstJavaStateInfo = javaSyntax.createStateInfo();
0228: helpJavaStateInfo = javaSyntax.createStateInfo();
0229: }
0230:
0231: public Syntax getScriptingSyntax() {
0232: return javaSyntax;
0233: }
0234:
0235: /** Parses the next token. Before entering this method the following assumptions hold:
0236: * <ul>
0237: * <li>'Regular' stateinfos contain the state of all active languages at 'offset'. For inactive
0238: * languages they are <code>null</code>.</li>
0239: * <li>If <code>tokenOffset != offset</code>, the scanning 'help' stateinfo contains the state of the scanning
0240: * language at 'tokenOffset'.</li>
0241: * <li>If <code>tokenOffset != offset</code>, firstTokenID contains the token returned by the first call of
0242: * slave's nextToken() in the current token, may be null !</li>
0243: * </ul>
0244: */
0245: protected TokenID parseToken() {
0246: //debug = (tokenOffset != offset);
0247: //debug = !((tokenOffset == offset) || (firstTokenID == null)); // !firstTokenNotRead
0248:
0249: //if (debug)
0250: //System.out.println("parseToken tokenOffset=" + tokenOffset + ", offset=" + offset + ", state=" + state +
0251: //", nestMode=" + nestMode + ", stopOffset=" + stopOffset + ", lastBuffer=" + lastBuffer);
0252:
0253: //<editor-fold defaultstate="collapsed" desc="setting states">
0254: if (state != ISI_LANGUAGE) {
0255: char actChar;
0256: while (offset < stopOffset) {
0257: actChar = buffer[offset];
0258: // System.out.println("JspMultiSyntax: parseToken tokenOffset=" + tokenOffset + ", actChar='" + actChar + ", offset=" + offset + ", state=" + getStateName(state) +
0259: // ", nestMode=" + getNestModeName( nestMode) + ", stopOffset=" + stopOffset + ", lastBuffer=" + lastBuffer);
0260: switch (state) {
0261: case ISI_HOST_JSPTAG: // switch to JspTagSyntax
0262: //if (debug)
0263: //System.out.println("switching from HOST to JSPTAG, hostState " + ((BaseStateInfo)hostStateInfo).toString(this));
0264: nestMode = MODE_HOST_JSPTAG;
0265: state = ISI_LANGUAGE;
0266: transferMasterToSlave(jspTagSyntax, null);
0267: //jspTagSyntax.load(null, buffer, offset, stopOffset - offset, lastBuffer);
0268: if (jspTagStateInfo == null) {
0269: jspTagStateInfo = jspTagSyntax
0270: .createStateInfo();
0271: }
0272: jspTagSyntax.storeState(jspTagStateInfo);
0273: break;
0274:
0275: case ISI_HOST_JAVA: // switch from hostSyntax to JavaSyntax
0276: switch (actChar) {
0277: case '<':
0278: state = ISI_HOST_JAVA_LT;
0279: break;
0280: default:
0281: Logger
0282: .getLogger("global")
0283: .log(
0284: Level.INFO,
0285: null,
0286: new Exception(
0287: "bad hostsyntax analyzer")); // NOI18N
0288: } // switch (actChar)
0289: break;
0290:
0291: case ISI_HOST_JAVA_LT:
0292: switch (actChar) {
0293: case '%':
0294: state = ISI_HOST_JAVA_LT_PC;
0295: break;
0296: default:
0297: Logger
0298: .getLogger("global")
0299: .log(
0300: Level.INFO,
0301: null,
0302: new Exception(
0303: "bad hostsyntax analyzer")); // NOI18N
0304: } // switch (actChar)
0305: break;
0306:
0307: case ISI_HOST_JAVA_LT_PC:
0308: switch (actChar) {
0309: case '!': // declaration
0310: javaNestMode = JAVA_DECLARATION;
0311: state = ISI_HOST_JAVA_JUMP;
0312: offset++;
0313: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
0314: return JspTagTokenContext.SYMBOL2;
0315: case '=': // expression
0316: javaNestMode = JAVA_EXPRESSION;
0317: state = ISI_HOST_JAVA_JUMP;
0318: offset++;
0319: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
0320: return JspTagTokenContext.SYMBOL2;
0321: default: // assume this is a scriptlet
0322: javaNestMode = JAVA_SCRIPTLET;
0323: state = ISI_HOST_JAVA_JUMP;
0324: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
0325: return JspTagTokenContext.SYMBOL2;
0326: } // switch (actChar)
0327: // break; - not reached
0328:
0329: case ISI_HOST_JAVA_JUMP:
0330: nestMode = MODE_HOST_JAVA;
0331: state = ISI_LANGUAGE;
0332: transferMasterToSlave(javaSyntax, null);
0333: //javaSyntax.load(null, buffer, offset, stopOffset - offset, lastBuffer);
0334: if (javaStateInfo == null) {
0335: javaStateInfo = javaSyntax.createStateInfo();
0336: }
0337: javaSyntax.storeState(javaStateInfo);
0338: break;
0339:
0340: case ISI_HOST_EL: // switch from hostSyntax to ELSyntax
0341: switch (actChar) {
0342: case '$':
0343: case '#':
0344: state = ISI_HOST_EL_D;
0345: break;
0346: default:
0347: Logger
0348: .getLogger("global")
0349: .log(
0350: Level.INFO,
0351: null,
0352: new Exception(
0353: "bad hostsyntax analyzer")); // NOI18N
0354: } // switch (actChar)
0355: break;
0356:
0357: case ISI_HOST_EL_D:
0358: switch (actChar) {
0359: case '{': // EL expression
0360: state = ISI_HOST_EL_JUMP;
0361: offset++;
0362: tokenContextPath = JspMultiTokenContext.elContextPath;
0363: return ELTokenContext.EL_DELIM;
0364: default:
0365: Logger
0366: .getLogger("global")
0367: .log(
0368: Level.INFO,
0369: null,
0370: new Exception(
0371: "bad hostsyntax analyzer")); // NOI18N
0372: } // switch (actChar)
0373: break;
0374:
0375: case ISI_HOST_EL_JUMP:
0376: nestMode = MODE_HOST_EL;
0377: state = ISI_LANGUAGE;
0378: transferMasterToSlave(elSyntax, null);
0379: //elSyntax.load(null, buffer, offset, stopOffset - offset, lastBuffer);
0380: if (elStateInfo == null) {
0381: elStateInfo = elSyntax.createStateInfo();
0382: }
0383: elSyntax.storeState(elStateInfo);
0384: break;
0385:
0386: case ISI_JSPTAG_JAVA: // switch from JSP tag to JavaSyntax
0387: switch (actChar) {
0388: case '<':
0389: state = ISI_JSPTAG_JAVA_LT;
0390: break;
0391: default:
0392: Logger
0393: .getLogger("global")
0394: .log(
0395: Level.INFO,
0396: null,
0397: new Exception(
0398: "bad hostsyntax analyzer")); // NOI18N
0399: } // switch (actChar)
0400: break;
0401:
0402: case ISI_JSPTAG_JAVA_LT:
0403: switch (actChar) {
0404: case '%':
0405: state = ISI_JSPTAG_JAVA_LT_PC;
0406: break;
0407: default:
0408: Logger
0409: .getLogger("global")
0410: .log(
0411: Level.INFO,
0412: null,
0413: new Exception(
0414: "bad hostsyntax analyzer")); // NOI18N
0415: } // switch (actChar)
0416: break;
0417:
0418: case ISI_JSPTAG_JAVA_LT_PC:
0419: switch (actChar) {
0420: case '!': // declaration
0421: javaNestMode = JAVA_DECLARATION;
0422: state = ISI_JSPTAG_JAVA_JUMP;
0423: offset++;
0424: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
0425: return JspTagTokenContext.SYMBOL2;
0426: case '=': // expression
0427: javaNestMode = JAVA_EXPRESSION;
0428: state = ISI_JSPTAG_JAVA_JUMP;
0429: offset++;
0430: //if (debug)
0431: //System.out.println("returning (1x) pos " + offset + " symbol " + getTokenName(JspTagSyntax.JSP_SYMBOL2 + jspTagSyntaxInfo.tokenIDShift));
0432: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
0433: return JspTagTokenContext.SYMBOL2;
0434: default: // assume this is a scriptlet
0435: javaNestMode = JAVA_SCRIPTLET;
0436: state = ISI_JSPTAG_JAVA_JUMP;
0437: //if (debug)
0438: //System.out.println("returning (2x) pos " + offset + " symbol " + getTokenName(JspTagSyntax.JSP_SYMBOL2 + jspTagSyntaxInfo.tokenIDShift));
0439: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
0440: return JspTagTokenContext.SYMBOL2;
0441: } // switch (actChar)
0442: // break; - not reached
0443:
0444: case ISI_JSPTAG_JAVA_JUMP:
0445: nestMode = MODE_HOST_JSPTAG_JAVA;
0446: state = ISI_LANGUAGE;
0447: transferMasterToSlave(javaSyntax, null);
0448: //javaSyntax.load(null, buffer, offset, stopOffset - offset, lastBuffer);
0449: if (javaStateInfo == null) {
0450: javaStateInfo = javaSyntax.createStateInfo();
0451: }
0452: javaSyntax.storeState(javaStateInfo);
0453: break;
0454:
0455: case ISI_JSPTAG_EL: // switch from JspTagSyntax to ELSyntax
0456: switch (actChar) {
0457: case '$':
0458: case '#':
0459: state = ISI_JSPTAG_EL_D;
0460: break;
0461: default:
0462: Logger
0463: .getLogger("global")
0464: .log(
0465: Level.INFO,
0466: null,
0467: new Exception(
0468: "bad hostsyntax analyzer")); // NOI18N
0469: } // switch (actChar)
0470: break;
0471:
0472: case ISI_JSPTAG_EL_D:
0473: switch (actChar) {
0474: case '{': // EL expression
0475: state = ISI_JSPTAG_EL_JUMP;
0476: offset++;
0477: tokenContextPath = JspMultiTokenContext.elContextPath;
0478: return ELTokenContext.EL_DELIM;
0479: default:
0480: Logger
0481: .getLogger("global")
0482: .log(
0483: Level.INFO,
0484: null,
0485: new Exception(
0486: "bad hostsyntax analyzer")); // NOI18N
0487: } // switch (actChar)
0488: break;
0489:
0490: case ISI_JSPTAG_EL_JUMP:
0491: nestMode = MODE_HOST_JSPTAG_EL;
0492: state = ISI_LANGUAGE;
0493: transferMasterToSlave(elSyntax, null);
0494: //elSyntax.load(null, buffer, offset, stopOffset - offset, lastBuffer);
0495: if (elStateInfo == null) {
0496: elStateInfo = elSyntax.createStateInfo();
0497: }
0498: elSyntax.storeState(elStateInfo);
0499: break;
0500:
0501: // switching from Java back to JSPTAG
0502: case ISI_JAVA1_SWITCH:
0503: switch (actChar) {
0504: case '%':
0505: state = ISI_JAVA1_PC;
0506: break;
0507: default:
0508: Logger
0509: .getLogger("global")
0510: .log(
0511: Level.INFO,
0512: null,
0513: new Exception(
0514: "bad hostsyntax analyzer")); // NOI18N
0515: } // switch (actChar)
0516: break;
0517:
0518: case ISI_JAVA1_PC:
0519: switch (actChar) {
0520: case '>':
0521: state = ISI_JAVA1_JUMP;
0522: offset++;
0523: //if (debug)
0524: //System.out.println("returning (1xx) pos " + offset + " symbol " + getTokenName(JspTagSyntax.JSP_SYMBOL2 + jspTagSyntaxInfo.tokenIDShift));
0525: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
0526: return JspTagTokenContext.SYMBOL2;
0527: default:
0528: Logger
0529: .getLogger("global")
0530: .log(
0531: Level.INFO,
0532: null,
0533: new Exception(
0534: "bad hostsyntax analyzer")); // NOI18N
0535: }
0536:
0537: case ISI_JAVA1_JUMP:
0538: nestMode = MODE_HOST_JSPTAG;
0539: jspTagStateInfo.setPreScan(0);
0540: state = ISI_LANGUAGE;
0541: javaStateInfo = null;
0542: break;
0543:
0544: // switching from Java back to host
0545: case ISI_JAVA2_SWITCH:
0546: switch (actChar) {
0547: case '%':
0548: state = ISI_JAVA2_PC;
0549: break;
0550: default:
0551: Logger
0552: .getLogger("global")
0553: .log(
0554: Level.INFO,
0555: null,
0556: new Exception(
0557: "bad hostsyntax analyzer")); // NOI18N
0558: } // switch (actChar)
0559: break;
0560:
0561: case ISI_JAVA2_PC:
0562:
0563: switch (actChar) {
0564: case '>':
0565: state = ISI_JAVA2_JUMP;
0566: offset++;
0567: //if (debug)
0568: //System.out.println("returning (2xx) pos " + offset + " symbol " + getTokenName(JspTagSyntax.JSP_SYMBOL2 + jspTagSyntaxInfo.tokenIDShift));
0569: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
0570: return JspTagTokenContext.SYMBOL2;
0571: default:
0572: Logger
0573: .getLogger("global")
0574: .log(
0575: Level.INFO,
0576: null,
0577: new Exception(
0578: "bad hostsyntax analyzer")); // NOI18N
0579: }
0580:
0581: case ISI_JAVA2_JUMP:
0582: nestMode = MODE_HOST;
0583: hostStateInfo.setPreScan(0);
0584: state = ISI_LANGUAGE;
0585: javaStateInfo = null;
0586: break;
0587:
0588: // switching from EL back to JSPTAG
0589: case ISI_EL1_SWITCH:
0590: switch (actChar) {
0591: case '}':
0592: state = ISI_EL1_JUMP;
0593: offset++;
0594: //if (debug)
0595: //System.out.println("returning (1xx) pos " + offset + " symbol " + getTokenName(ELSyntax.ED_DELIM + elSyntaxInfo.tokenIDShift));
0596: tokenContextPath = JspMultiTokenContext.elContextPath;
0597: return ELTokenContext.EL_DELIM;
0598: default:
0599: Logger
0600: .getLogger("global")
0601: .log(
0602: Level.INFO,
0603: null,
0604: new Exception(
0605: "bad hostsyntax analyzer")); // NOI18N
0606: } // switch (actChar)
0607: break;
0608:
0609: case ISI_EL1_JUMP:
0610: nestMode = MODE_HOST_JSPTAG;
0611: jspTagStateInfo.setPreScan(0);
0612: state = ISI_LANGUAGE;
0613: elStateInfo = null;
0614: break;
0615:
0616: // switching from EL back to host
0617: case ISI_EL2_SWITCH:
0618: switch (actChar) {
0619: case '}':
0620: state = ISI_EL2_JUMP;
0621: offset++;
0622: //if (debug)
0623: //System.out.println("returning (1xx) pos " + offset + " symbol " + getTokenName(ELSyntax.ED_DELIM + elSyntaxInfo.tokenIDShift));
0624: tokenContextPath = JspMultiTokenContext.elContextPath;
0625: return ELTokenContext.EL_DELIM;
0626: default:
0627: Logger
0628: .getLogger("global")
0629: .log(
0630: Level.INFO,
0631: null,
0632: new Exception(
0633: "bad hostsyntax analyzer")); // NOI18N
0634: } // switch (actChar)
0635: break;
0636:
0637: case ISI_EL2_JUMP:
0638: nestMode = MODE_HOST;
0639: hostStateInfo.setPreScan(0);
0640: state = ISI_LANGUAGE;
0641: elStateInfo = null;
0642: break;
0643:
0644: }
0645:
0646: if (state == ISI_LANGUAGE)
0647: break;
0648:
0649: offset = ++offset;
0650: } // end of while(offset...)
0651:
0652: if (state != ISI_LANGUAGE) {
0653: /** At this stage there's no more text in the scanned buffer.
0654: * Scanner first checks whether this is completely the last
0655: * available buffer.
0656: */
0657: if (lastBuffer) {
0658: switch (state) {
0659: case ISI_HOST_JSPTAG:
0660: case ISI_HOST_JAVA:
0661: case ISI_HOST_JAVA_LT:
0662: case ISI_HOST_JAVA_LT_PC:
0663: case ISI_HOST_JAVA_JUMP:
0664: case ISI_JSPTAG_JAVA:
0665: case ISI_JSPTAG_JAVA_LT:
0666: case ISI_JSPTAG_JAVA_LT_PC:
0667: case ISI_JSPTAG_JAVA_JUMP:
0668: case ISI_JAVA1_SWITCH:
0669: case ISI_JAVA1_PC:
0670: case ISI_JAVA1_JUMP:
0671: case ISI_JAVA2_SWITCH:
0672: case ISI_JAVA2_PC:
0673: case ISI_JAVA2_JUMP:
0674: //if (debug)
0675: //System.out.println("returning (3) pos " + offset + " symbol " + getTokenName(JspTagSyntax.JSP_SYMBOL2 + jspTagSyntaxInfo.tokenIDShift));
0676: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
0677: return JspTagTokenContext.SYMBOL2;
0678:
0679: case ISI_HOST_EL:
0680: case ISI_HOST_EL_D:
0681: case ISI_HOST_EL_JUMP:
0682: case ISI_JSPTAG_EL:
0683: case ISI_JSPTAG_EL_D:
0684: case ISI_JSPTAG_EL_JUMP:
0685: case ISI_EL1_SWITCH:
0686: case ISI_EL1_JUMP:
0687: case ISI_EL2_SWITCH:
0688: case ISI_EL2_JUMP:
0689: //if (debug)
0690: //System.out.println("returning (3.5) pos " + offset + " symbol " + getTokenName(JspELSyntax.EL_DELIM + elSyntaxInfo.tokenIDShift));
0691: tokenContextPath = JspMultiTokenContext.elContextPath;
0692: return ELTokenContext.EL_DELIM;
0693: } // switch (state)
0694: } // if lastBuffer
0695: //if (debug)
0696: //System.out.println("returning (4) pos " + offset + " symbol " + getTokenName(null));
0697: return null;
0698: } // if state != ISI_LANGUAGE - inner
0699: } // if state != ISI_LANGUAGE - outer
0700:
0701: //</editor-fold>
0702:
0703: // now state is ISI_LANGUAGE
0704: //if (state != ISI_LANGUAGE) new Exception("state should be ISI_LANGUAGE").printStackTrace();
0705: TokenID slaveTokenID = null;
0706: TokenID returnedTokenID;
0707:
0708: int slaveOffset;
0709: int canBe;
0710: boolean firstTokenNotRead = ((tokenOffset == offset) || (firstTokenID == null));
0711: boolean equalPositions = (tokenOffset == offset);
0712:
0713: switch (nestMode) {
0714: // BIG BRANCH - we are in the HOST mode
0715: //<editor-fold defaultstate="collapsed" desc="MODE_HOST & MODE_JSPTAG">
0716: case MODE_HOST:
0717: if (hostStateInfo == null) {
0718: hostStateInfo = hostSyntax.createStateInfo();
0719: hostSyntax.reset();
0720: hostSyntax.storeState(hostStateInfo);
0721: }
0722:
0723: /*if (debug) {
0724: System.out.print("NOT EQUAL tokenOffset=" + tokenOffset + ", offset=" + offset + ", tokenPart='");
0725: for (int i = tokenOffset; i<offset;i++) System.out.print(buffer[i]);
0726: System.out.println("', firstTokenID=" + firstTokenID + ", firstTokenLength=" + firstTokenLength);
0727: System.out.println("hoststate " + hostStateInfo.getState() + ", prescan=" + hostStateInfo.getPreScan());
0728: System.out.println("helpstate " + helpHostStateInfo.getState() + ", prescan=" + helpHostStateInfo.getPreScan());
0729: } */
0730:
0731: //if (equalPositions && (hostStateInfo.getPreScan() != 0))
0732: //new Exception("prescan should be 0 !!").printStackTrace();
0733: //if (debug)
0734: //System.out.println("html state at offset " + ((BaseStateInfo)hostStateInfo).toString(this));
0735: if (firstTokenNotRead) {
0736: // the first step - parse the first token of the slave
0737: transferMasterToSlave(hostSyntax, hostStateInfo);
0738: returnedTokenID = hostSyntax.nextToken();
0739: slaveTokenID = returnedTokenID;
0740: tokenContextPath = JspMultiTokenContext.context
0741: .getContextPath(hostSyntax
0742: .getTokenContextPath());
0743: slaveOffset = hostSyntax.getOffset();
0744: firstTokenID = slaveTokenID;
0745: firstTokenLength = hostSyntax.getTokenLength();
0746: if (slaveTokenID == null) {
0747: offset = slaveOffset;
0748: firstTokenLength = -1;
0749: // need to property transfer states
0750: if (equalPositions) {
0751: helpHostStateInfo = hostStateInfo;
0752: hostStateInfo = hostSyntax.createStateInfo();
0753: hostSyntax.storeState(hostStateInfo);
0754: } else {
0755: if (hostStateInfo == null) {
0756: hostStateInfo = hostSyntax
0757: .createStateInfo();
0758: }
0759: hostSyntax.storeState(hostStateInfo);
0760: }
0761: //if (debug)
0762: //System.out.println("returnuju (1) " + null + " at " + offset);
0763: return null;
0764: }
0765: if (returnedTokenID.getNumericID() == HTMLTokenContext.BLOCK_COMMENT_ID
0766: && isXMLSyntax())
0767: canBe = DELIMCHECK_NO;
0768: else {
0769: // find out if the token could contain a starting symbol for JspTag or Java
0770: canBe = canBeHostDelimiter(tokenOffset,
0771: slaveOffset, slaveOffset, false);
0772: }
0773: if (canBe == DELIMCHECK_NO) { // do not switch
0774: offset = slaveOffset;
0775: if (hostStateInfo == null) {
0776: hostStateInfo = hostSyntax.createStateInfo();
0777: }
0778: hostSyntax.storeState(hostStateInfo);
0779: //if (debug)
0780: //System.out.println("returnuju (2) " + slaveTokenID + " at " + offset);
0781: return slaveTokenID;
0782: }
0783: // store the state
0784: hostSyntax.storeState(firstHostStateInfo);
0785: //if (firstHostStateInfo == hostStateInfo)
0786: //new Exception("stateinfo instance conflict").printStackTrace();
0787: } else { // first position read - offsets different and firstTokenID is a valid token
0788: transferMasterToSlave(hostSyntax, hostStateInfo);
0789: canBe = DELIMCHECK_PART;
0790: }
0791:
0792: // we have successfully read the first token, the following statements hold:
0793: // - canBe is not DELIMCHECK_NO
0794: // - firstTokenID and firstTokenLength are meaningful
0795: // - if (equalPositions) then firstHostStateInfo is meaningful
0796: //if (firstTokenID == null) {
0797: //new Exception("invalid firstTokenID !!!!!!!").printStackTrace();
0798: //}
0799: while (canBe == DELIMCHECK_PART) { // need another token
0800: // now get the new token
0801: returnedTokenID = hostSyntax.nextToken();
0802: slaveTokenID = returnedTokenID;
0803: tokenContextPath = JspMultiTokenContext.context
0804: .getContextPath(hostSyntax
0805: .getTokenContextPath());
0806: slaveOffset = hostSyntax.getOffset();
0807:
0808: if ((slaveTokenID == null) && lastBuffer) {
0809: // ask about the delimiter, but with lastPart=true
0810: canBe = canBeHostDelimiter(tokenOffset,
0811: slaveOffset,
0812: tokenOffset + firstTokenLength, true);
0813: if (canBe != DELIMCHECK_PART)
0814: break;
0815: }
0816:
0817: if (slaveTokenID == null) {
0818: if (lastBuffer) {
0819: canBe = DELIMCHECK_NO;
0820: break;
0821: }
0822: offset = slaveOffset;
0823: if (equalPositions) {
0824: helpHostStateInfo = hostStateInfo;
0825: hostStateInfo = hostSyntax.createStateInfo();
0826: hostSyntax.storeState(hostStateInfo);
0827: } else {
0828: if (hostStateInfo == null) {
0829: hostStateInfo = hostSyntax
0830: .createStateInfo();
0831: }
0832: hostSyntax.storeState(hostStateInfo);
0833: }
0834: //if (debug)
0835: //System.out.println("returnuju (3) " + null + " at " + offset);
0836: return null;
0837: }
0838: canBe = canBeHostDelimiter(tokenOffset, slaveOffset,
0839: tokenOffset + firstTokenLength, false);
0840: }
0841:
0842: // now canBe is not DELIMCHECK_PART
0843: // now we have read possibly more tokens and know whether to switch or not
0844: if (canBe == DELIMCHECK_NO) { // do not switch
0845: offset = tokenOffset + firstTokenLength;
0846: if (equalPositions) {
0847: hostStateInfo = firstHostStateInfo;
0848: firstHostStateInfo = hostSyntax.createStateInfo();
0849: } else {
0850: //if (debug)
0851: //System.out.println("= imagine - rescan called !!");
0852: //if (helpHostStateInfo.getPreScan() != 0)
0853: //new Exception("help prescan should be 0 !!").printStackTrace();
0854: // we need to rescan the first token to find out the state
0855: // now helpHostStateInfo is useful
0856: hostSyntax.load(helpHostStateInfo, buffer,
0857: tokenOffset, stopOffset - tokenOffset,
0858: lastBuffer, -1);
0859: returnedTokenID = hostSyntax.nextToken();
0860: //if (tokenOffset != hostSyntax.getTokenOffset())
0861: //new Exception("starts of tokens do not match").printStackTrace();
0862: slaveTokenID = returnedTokenID;
0863: tokenContextPath = JspMultiTokenContext.context
0864: .getContextPath(hostSyntax
0865: .getTokenContextPath());
0866: if (hostStateInfo == null) {
0867: hostStateInfo = hostSyntax.createStateInfo();
0868: }
0869: hostSyntax.storeState(hostStateInfo);
0870:
0871: }
0872: //if (debug)
0873: //System.out.println("returnuju (4) " + firstTokenID + " at " + offset);
0874:
0875: return firstTokenID;
0876: } else { // we found a delimiter
0877: //if (canBe >= tokenOffset + firstTokenLength)
0878: //new Exception("value of canBe is invalid !!!!!!!").printStackTrace();
0879: // now use the saved state
0880: if (equalPositions) {
0881: hostSyntax.load(hostStateInfo, buffer, tokenOffset,
0882: canBe - tokenOffset, true, -1);
0883: } else {
0884: hostSyntax.load(helpHostStateInfo, buffer,
0885: tokenOffset, canBe - tokenOffset, true, -1);
0886: }
0887: returnedTokenID = hostSyntax.nextToken();
0888: tokenContextPath = JspMultiTokenContext.context
0889: .getContextPath(hostSyntax
0890: .getTokenContextPath());
0891: // we got the StateInfo, which is why we did all this
0892: if (hostStateInfo == null) {
0893: hostStateInfo = hostSyntax.createStateInfo();
0894: }
0895: //if (debug)
0896: //System.out.println("html state before saving back " + ((BaseStateInfo)hostStateInfo).toString(this));
0897: hostSyntax.storeState(hostStateInfo);
0898: hostStateInfo.setPreScan(0);
0899: //if (hostSyntax.getOffset() != canBe)
0900: //new Exception("bad number of characters parsed !!!").printStackTrace();
0901: offset = canBe;
0902: /*if (debug) {
0903: System.out.println("switching from HOST to JSPTAG at offset " + offset + ", hostState " + ((BaseStateInfo)hostStateInfo).toString(this));
0904: System.out.println("offset of the returned (a)" + hostSyntax.getOffset());
0905: System.out.println("found delimiter at " + offset);
0906: System.out.println("returnuju (5) " + firstTokenID + " at " + offset);
0907: }*/
0908: return firstTokenID;
0909: }
0910: //break; //- not reached
0911:
0912: // BIG BRANCH - we are in the HOST_JSPTAG mode
0913: case MODE_HOST_JSPTAG:
0914: // check if the JSP tag hasn't finished on its own will
0915: if ((jspTagStateInfo != null)
0916: && (jspTagStateInfo.getState() == JspTagSyntax.ISA_END_JSP)) {
0917: // give up control
0918: jspTagStateInfo = null;
0919: nestMode = MODE_HOST;
0920: //if (debug) {
0921: //System.out.println("switching back to HOST from JSPTAG at offset " + offset + ", hostState " + ((BaseStateInfo)hostStateInfo).toString(this));
0922: //System.out.println("returnuju (6) " /*+ JspTagSyntax.TEXT + jspTagSyntaxInfo.tokenIDShift */+ " at " + offset);
0923: //}
0924: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
0925: return JspTagTokenContext.TEXT;
0926: }
0927:
0928: if (jspTagStateInfo == null) {
0929: jspTagStateInfo = jspTagSyntax.createStateInfo();
0930: jspTagSyntax.reset();
0931: jspTagSyntax.storeState(jspTagStateInfo);
0932: }
0933: if (firstTokenNotRead) {
0934: // the first step - parse the first token of the slave
0935: transferMasterToSlave(jspTagSyntax, jspTagStateInfo);
0936: returnedTokenID = jspTagSyntax.nextToken();
0937: if (returnedTokenID == JspTagTokenContext.AFTER_UNEXPECTED_LT) {
0938: // give up control
0939: jspTagStateInfo = null;
0940: nestMode = MODE_HOST;
0941: hostStateInfo.setPreScan(0);
0942: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
0943: //System.out.println("switch to host " + returnedTokenID + " at " + offset);
0944: return returnedTokenID;
0945: }
0946: slaveTokenID = returnedTokenID;
0947: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
0948: //if (debug)
0949: //System.out.println("first JSPtoken returned '" + getToken(jspTagSyntax) + "' id " + slaveTokenID);
0950: slaveOffset = jspTagSyntax.getOffset();
0951: firstTokenID = slaveTokenID;
0952: firstTokenLength = jspTagSyntax.getTokenLength();
0953: if (slaveTokenID == null) {
0954: offset = slaveOffset;
0955: firstTokenLength = -1;
0956: // need to properly transfer states
0957: if (equalPositions) {
0958: helpJspTagStateInfo = jspTagStateInfo;
0959: jspTagStateInfo = jspTagSyntax
0960: .createStateInfo();
0961: jspTagSyntax.storeState(jspTagStateInfo);
0962: } else {
0963: if (jspTagStateInfo == null) {
0964: jspTagStateInfo = jspTagSyntax
0965: .createStateInfo();
0966: }
0967: jspTagSyntax.storeState(jspTagStateInfo);
0968: }
0969: //if (debug)
0970: //System.out.println("returnuju (7) " + null + " at " + offset);
0971: return null;
0972: }
0973: // find out if the token could contain a starting symbol for Java
0974: canBe = canBeJspTagDelimiter(tokenOffset, slaveOffset,
0975: slaveOffset, false,
0976: returnedTokenID == JspTagTokenContext.COMMENT);
0977: if (canBe == DELIMCHECK_NO) { // do not switch
0978: offset = slaveOffset;
0979: if (jspTagStateInfo == null) {
0980: jspTagStateInfo = jspTagSyntax
0981: .createStateInfo();
0982: }
0983: jspTagSyntax.storeState(jspTagStateInfo);
0984: //if (debug)
0985: //System.out.println("returnuju (8) " + slaveTokenID + " at " + offset);
0986: return slaveTokenID;
0987: }
0988: // store the state
0989: jspTagSyntax.storeState(firstJspTagStateInfo);
0990: } else { // first position read - offsets different and firstTokenID is a valid token
0991: transferMasterToSlave(jspTagSyntax, jspTagStateInfo);
0992: canBe = DELIMCHECK_PART;
0993: }
0994:
0995: // we have successfully read the first token, the following statements hold:
0996: // - canBe is not DELIMCHECK_NO
0997: // - firstTokenID and firstTokenLength are meaningful
0998: // - if (equalPositions) then firstJspTagStateInfo is meaningful
0999: //if (firstTokenID == null) {
1000: //new Exception("invalid firstTokenID !!!!!!!").printStackTrace();
1001: //}
1002: while (canBe == DELIMCHECK_PART) { // need another token
1003: // now get the new token
1004: returnedTokenID = jspTagSyntax.nextToken();
1005: slaveTokenID = returnedTokenID;
1006: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
1007: slaveOffset = jspTagSyntax.getOffset();
1008:
1009: if ((slaveTokenID == null) && lastBuffer) {
1010: // ask about the delimiter, but with lastPart=true
1011: canBe = canBeJspTagDelimiter(
1012: tokenOffset,
1013: slaveOffset,
1014: tokenOffset + firstTokenLength,
1015: true,
1016: returnedTokenID == JspTagTokenContext.COMMENT);
1017: if (canBe != DELIMCHECK_PART)
1018: break;
1019: }
1020:
1021: if (slaveTokenID == null) {
1022: if (lastBuffer) {
1023: canBe = DELIMCHECK_NO;
1024: break;
1025: }
1026: offset = slaveOffset;
1027: if (equalPositions) {
1028: helpJspTagStateInfo = jspTagStateInfo;
1029: jspTagStateInfo = jspTagSyntax
1030: .createStateInfo();
1031: jspTagSyntax.storeState(jspTagStateInfo);
1032: } else {
1033: if (jspTagStateInfo == null) {
1034: jspTagStateInfo = jspTagSyntax
1035: .createStateInfo();
1036: }
1037: jspTagSyntax.storeState(jspTagStateInfo);
1038: }
1039: //if (debug)
1040: //System.out.println("returnuju (9) " + null + " at " + offset);
1041: return null;
1042: }
1043: canBe = canBeJspTagDelimiter(tokenOffset, slaveOffset,
1044: tokenOffset + firstTokenLength, false,
1045: returnedTokenID == JspTagTokenContext.COMMENT);
1046: }
1047:
1048: // now canBe is not DELIMCHECK_PART
1049: // now we have read possibly more tokens and know whether to switch or not
1050: if (canBe == DELIMCHECK_NO) { // do not switch
1051: offset = tokenOffset + firstTokenLength;
1052: if (equalPositions) {
1053: jspTagStateInfo = firstJspTagStateInfo;
1054: firstJspTagStateInfo = jspTagSyntax
1055: .createStateInfo();
1056: } else {
1057: //if (debug)
1058: //System.out.println("= imagine - rescan called !!");
1059: // we need to rescan the first token to find out the state
1060: // now helpJspTagStateInfo is useful
1061: jspTagSyntax.load(helpJspTagStateInfo, buffer,
1062: tokenOffset, stopOffset - tokenOffset,
1063: lastBuffer, -1);
1064: returnedTokenID = jspTagSyntax.nextToken();
1065: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
1066: slaveTokenID = returnedTokenID;
1067: if (jspTagStateInfo == null) {
1068: jspTagStateInfo = jspTagSyntax
1069: .createStateInfo();
1070: }
1071: jspTagSyntax.storeState(jspTagStateInfo);
1072: //if (slaveTokenID != firstTokenID)
1073: //new Exception("token ID does not match !!!!!!!").printStackTrace();
1074: //if (offset != jspTagSyntax.getOffset())
1075: //new Exception("offset does not match !!!!!!!").printStackTrace();
1076: }
1077: //if (debug)
1078: //System.out.println("returnuju (10) " + firstTokenID + " at " + offset);
1079: return firstTokenID;
1080: } else { // we found a delimiter
1081: //if (canBe >= tokenOffset + firstTokenLength)
1082: //new Exception("value of canBe is invalid !!!!!!!").printStackTrace();
1083: // now use the saved state
1084: if (equalPositions) {
1085: jspTagSyntax.load(jspTagStateInfo, buffer,
1086: tokenOffset, canBe - tokenOffset, true, -1);
1087: } else {
1088: jspTagSyntax.load(helpJspTagStateInfo, buffer,
1089: tokenOffset, canBe - tokenOffset, true, -1);
1090: }
1091: returnedTokenID = jspTagSyntax.nextToken();
1092: tokenContextPath = JspMultiTokenContext.jspTagContextPath;
1093: // we got the StateInfo, which is why we did all this
1094: if (jspTagStateInfo == null) {
1095: jspTagStateInfo = jspTagSyntax.createStateInfo();
1096: }
1097: jspTagSyntax.storeState(jspTagStateInfo);
1098: jspTagStateInfo.setPreScan(0);
1099: //if (jspTagSyntax.getOffset() != canBe)
1100: //new Exception("bad number of characters parsed !!!").printStackTrace();
1101: offset = canBe;
1102: //if (debug) {
1103: //System.out.println("offset of the returned (a)" + jspTagSyntax.getOffset());
1104: //System.out.println("found delimiter at " + offset);
1105: //System.out.println("returnuju (11) " + firstTokenID + " at " + offset);
1106: //}
1107: return firstTokenID;
1108: }
1109: //break; //- not reached
1110:
1111: //</editor-fold>
1112: case MODE_HOST_JSPTAG_JAVA:
1113: case MODE_HOST_JAVA:
1114: if (javaStateInfo == null) {
1115: javaStateInfo = javaSyntax.createStateInfo();
1116: javaSyntax.reset();
1117: javaSyntax.storeState(javaStateInfo);
1118: }
1119: if (firstTokenNotRead) {
1120: // the first step - parse the first token of the slave
1121: transferMasterToSlave(javaSyntax, javaStateInfo);
1122: returnedTokenID = javaSyntax.nextToken();
1123: tokenContextPath = getJavaTokenContextPath();
1124: slaveTokenID = returnedTokenID;
1125: slaveOffset = javaSyntax.getOffset();
1126: firstTokenID = slaveTokenID;
1127: firstTokenLength = javaSyntax.getTokenLength();
1128: if (slaveTokenID == null) {
1129: offset = slaveOffset;
1130: firstTokenLength = -1;
1131: // need to property transfer states
1132: if (equalPositions) {
1133: helpJavaStateInfo = javaStateInfo;
1134: javaStateInfo = javaSyntax.createStateInfo();
1135: javaSyntax.storeState(javaStateInfo);
1136: } else {
1137: if (javaStateInfo == null) {
1138: javaStateInfo = javaSyntax
1139: .createStateInfo();
1140: }
1141: javaSyntax.storeState(javaStateInfo);
1142: }
1143: //if (debug)
1144: //System.out.println("returnuju (12) " + null + " at " + offset);
1145: return null;
1146: }
1147: // find out if the token could contain an ending symbol for a Java block
1148: canBe = canBeJavaDelimiter(tokenOffset, slaveOffset,
1149: slaveOffset, false, nestMode);
1150: if (canBe == DELIMCHECK_NO) { // do not switch
1151: offset = slaveOffset;
1152: if (javaStateInfo == null) {
1153: javaStateInfo = javaSyntax.createStateInfo();
1154: }
1155: javaSyntax.storeState(javaStateInfo);
1156: //if (debug)
1157: //System.out.println("returnuju (13) " + slaveTokenID + " at " + offset);
1158: return slaveTokenID;
1159: }
1160: // store the state
1161: javaSyntax.storeState(firstJavaStateInfo);
1162: } else { // first position read - offsets different and firstTokenID is a valid token
1163: transferMasterToSlave(javaSyntax, javaStateInfo);
1164: canBe = DELIMCHECK_PART;
1165: }
1166:
1167: // we have successfully read the first token, the following statements hold:
1168: // - canBe is not DELIMCHECK_NO
1169: // - firstTokenID and firstTokenLength are meaningful
1170: // - if (equalPositions) then firstJavaStateInfo is meaningful
1171: //if (firstTokenID == null) {
1172: //new Exception("invalid firstTokenID !!!!!!!").printStackTrace();
1173: //}
1174: while (canBe == DELIMCHECK_PART) { // need another token
1175: // now get the new token
1176: returnedTokenID = javaSyntax.nextToken();
1177: slaveTokenID = returnedTokenID;
1178: tokenContextPath = getJavaTokenContextPath();
1179: slaveOffset = javaSyntax.getOffset();
1180:
1181: if ((slaveTokenID == null) && lastBuffer) {
1182: // ask about the delimiter, but with lastPart=true
1183: canBe = canBeJavaDelimiter(tokenOffset,
1184: slaveOffset,
1185: tokenOffset + firstTokenLength, true,
1186: nestMode);
1187: if (canBe != DELIMCHECK_PART)
1188: break;
1189: }
1190:
1191: if (slaveTokenID == null) {
1192: if (lastBuffer) {
1193: canBe = DELIMCHECK_NO;
1194: break;
1195: }
1196: offset = slaveOffset;
1197: if (equalPositions) {
1198: helpJavaStateInfo = javaStateInfo;
1199: javaStateInfo = javaSyntax.createStateInfo();
1200: javaSyntax.storeState(javaStateInfo);
1201: } else {
1202: if (javaStateInfo == null) {
1203: javaStateInfo = javaSyntax
1204: .createStateInfo();
1205: }
1206: javaSyntax.storeState(javaStateInfo);
1207: }
1208: //if (debug)
1209: //System.out.println("returnuju (14) " + null + " at " + offset);
1210: return null;
1211: }
1212: canBe = canBeJavaDelimiter(tokenOffset, slaveOffset,
1213: tokenOffset + firstTokenLength, false, nestMode);
1214: }
1215:
1216: // now canBe is not DELIMCHECK_PART
1217: // now we have read possibly more tokens and know whether to switch or not
1218: if (canBe == DELIMCHECK_NO) { // do not switch
1219: offset = tokenOffset + firstTokenLength;
1220: if (equalPositions) {
1221: javaStateInfo = firstJavaStateInfo;
1222: firstJavaStateInfo = javaSyntax.createStateInfo();
1223: } else {
1224: //if (debug)
1225: //System.out.println("= imagine - rescan called !!");
1226: // we need to rescan the first token to find out the state
1227: // now helpJavaStateInfo is useful
1228: javaSyntax.load(helpJavaStateInfo, buffer,
1229: tokenOffset, stopOffset - tokenOffset,
1230: lastBuffer, -1);
1231: returnedTokenID = javaSyntax.nextToken();
1232: slaveTokenID = returnedTokenID;
1233: tokenContextPath = getJavaTokenContextPath();
1234: if (javaStateInfo == null) {
1235: javaStateInfo = javaSyntax.createStateInfo();
1236: }
1237: javaSyntax.storeState(javaStateInfo);
1238: //if (slaveTokenID != firstTokenID)
1239: //new Exception("token ID does not match !!!!!!!").printStackTrace();
1240: //if (offset != javaSyntax.getOffset())
1241: //new Exception("offset does not match !!!!!!!").printStackTrace();
1242: }
1243: //if (debug)
1244: //System.out.println("returnuju (15) " + firstTokenID + " at " + offset);
1245: return firstTokenID;
1246: } else { // we found a delimiter
1247: //if (canBe >= tokenOffset + firstTokenLength)
1248: //new Exception("value of canBe is invalid !!!!!!!").printStackTrace();
1249: // now use the saved state
1250: if (equalPositions) {
1251: javaSyntax.load(javaStateInfo, buffer, tokenOffset,
1252: canBe - tokenOffset, true, -1);
1253: } else {
1254: javaSyntax.load(helpJavaStateInfo, buffer,
1255: tokenOffset, canBe - tokenOffset, true, -1);
1256: }
1257: returnedTokenID = javaSyntax.nextToken();
1258: tokenContextPath = getJavaTokenContextPath();
1259: // we got the StateInfo, which is why we did all this
1260: if (javaStateInfo == null) {
1261: javaStateInfo = javaSyntax.createStateInfo();
1262: }
1263: javaSyntax.storeState(javaStateInfo);
1264: javaStateInfo.setPreScan(0);
1265: //if (javaSyntax.getOffset() != canBe)
1266: //new Exception("bad number of characters parsed !!!").printStackTrace();
1267: offset = canBe;
1268: /*if (debug) {
1269: System.out.println("offset of the returned (a)" + javaSyntax.getOffset());
1270: System.out.println("found delimiter at " + offset);
1271: System.out.println("returnuju (16) " + firstTokenID + " at " + offset);
1272: }*/
1273:
1274: return firstTokenID;
1275: }
1276: // break; //- not reached
1277:
1278: //<editor-fold defaultstate="collapsed" desc="MODE_HOST_EL">
1279: case MODE_HOST_JSPTAG_EL:
1280: case MODE_HOST_EL:
1281: if (elStateInfo == null) {
1282: elStateInfo = elSyntax.createStateInfo();
1283: elSyntax.reset();
1284: elSyntax.storeState(elStateInfo);
1285: }
1286: if (firstTokenNotRead) {
1287: // the first step - parse the first token of the slave
1288: transferMasterToSlave(elSyntax, elStateInfo);
1289: returnedTokenID = elSyntax.nextToken();
1290: tokenContextPath = JspMultiTokenContext.elContextPath;
1291: slaveTokenID = returnedTokenID;
1292: slaveOffset = elSyntax.getOffset();
1293: firstTokenID = slaveTokenID;
1294: firstTokenLength = elSyntax.getTokenLength();
1295: if (slaveTokenID == null) {
1296: offset = slaveOffset;
1297: firstTokenLength = -1;
1298: // need to property transfer states
1299: if (equalPositions) {
1300: helpELStateInfo = elStateInfo;
1301: elStateInfo = elSyntax.createStateInfo();
1302: elSyntax.storeState(elStateInfo);
1303: } else {
1304: if (elStateInfo == null) {
1305: elStateInfo = elSyntax.createStateInfo();
1306: }
1307: elSyntax.storeState(elStateInfo);
1308: }
1309: //if (debug)
1310: //System.out.println("returnuju (12.5) " + null + " at " + offset);
1311: return null;
1312: }
1313: // find out if the token could contain an ending symbol for a EL block
1314: canBe = canBeELDelimiter(tokenOffset, slaveOffset,
1315: slaveOffset, false, nestMode);
1316: if (canBe == DELIMCHECK_NO) { // do not switch
1317: offset = slaveOffset;
1318: if (elStateInfo == null) {
1319: elStateInfo = elSyntax.createStateInfo();
1320: }
1321: elSyntax.storeState(elStateInfo);
1322: //if (debug)
1323: //System.out.println("returnuju (13.5) " + slaveTokenID + " at " + offset);
1324: return slaveTokenID;
1325: }
1326: // store the state
1327: elSyntax.storeState(firstELStateInfo);
1328: } else { // first position read - offsets different and firstTokenID is a valid token
1329: transferMasterToSlave(elSyntax, elStateInfo);
1330: canBe = DELIMCHECK_PART;
1331: }
1332:
1333: // we have successfully read the first token, the following statements hold:
1334: // - canBe is not DELIMCHECK_NO
1335: // - firstTokenID and firstTokenLength are meaningful
1336: // - if (equalPositions) then firstELStateInfo is meaningful
1337: //if (firstTokenID == null) {
1338: //new Exception("invalid firstTokenID !!!!!!!").printStackTrace();
1339: //}
1340: while (canBe == DELIMCHECK_PART) { // need another token
1341: // now get the new token
1342: returnedTokenID = elSyntax.nextToken();
1343: slaveTokenID = returnedTokenID;
1344: tokenContextPath = JspMultiTokenContext.elContextPath;
1345: slaveOffset = elSyntax.getOffset();
1346:
1347: if ((slaveTokenID == null) && lastBuffer) {
1348: // ask about the delimiter, but with lastPart=true
1349: canBe = canBeELDelimiter(tokenOffset, slaveOffset,
1350: tokenOffset + firstTokenLength, true,
1351: nestMode);
1352: if (canBe != DELIMCHECK_PART)
1353: break;
1354: }
1355:
1356: if (slaveTokenID == null) {
1357: if (lastBuffer) {
1358: canBe = DELIMCHECK_NO;
1359: break;
1360: }
1361: offset = slaveOffset;
1362: if (equalPositions) {
1363: helpELStateInfo = elStateInfo;
1364: elStateInfo = elSyntax.createStateInfo();
1365: elSyntax.storeState(elStateInfo);
1366: } else {
1367: if (elStateInfo == null) {
1368: elStateInfo = elSyntax.createStateInfo();
1369: }
1370: elSyntax.storeState(elStateInfo);
1371: }
1372: //if (debug)
1373: //System.out.println("returnuju (14) " + null + " at " + offset);
1374: return null;
1375: }
1376: canBe = canBeELDelimiter(tokenOffset, slaveOffset,
1377: tokenOffset + firstTokenLength, false, nestMode);
1378: }
1379:
1380: // now canBe is not DELIMCHECK_PART
1381: // now we have read possibly more tokens and know whether to switch or not
1382: if (canBe == DELIMCHECK_NO) { // do not switch
1383: offset = tokenOffset + firstTokenLength;
1384: if (equalPositions) {
1385: elStateInfo = firstELStateInfo;
1386: firstELStateInfo = elSyntax.createStateInfo();
1387: } else {
1388: //if (debug)
1389: //System.out.println("= imagine - rescan called !!");
1390: // we need to rescan the first token to find out the state
1391: // now helpELStateInfo is useful
1392: elSyntax.load(helpELStateInfo, buffer, tokenOffset,
1393: stopOffset - tokenOffset, lastBuffer, -1);
1394: returnedTokenID = elSyntax.nextToken();
1395: slaveTokenID = returnedTokenID;
1396: tokenContextPath = JspMultiTokenContext.elContextPath;
1397: if (elStateInfo == null) {
1398: elStateInfo = elSyntax.createStateInfo();
1399: }
1400: elSyntax.storeState(elStateInfo);
1401: //if (slaveTokenID != firstTokenID)
1402: //new Exception("token ID does not match !!!!!!!").printStackTrace();
1403: //if (offset != elSyntax.getOffset())
1404: //new Exception("offset does not match !!!!!!!").printStackTrace();
1405: }
1406: //if (debug)
1407: //System.out.println("returnuju (15.5) " + firstTokenID + " at " + offset);
1408: return firstTokenID;
1409: } else { // we found a delimiter
1410: //if (canBe >= tokenOffset + firstTokenLength)
1411: //new Exception("value of canBe is invalid !!!!!!!").printStackTrace();
1412: // now use the saved state
1413: if (equalPositions) {
1414: elSyntax.load(elStateInfo, buffer, tokenOffset,
1415: canBe - tokenOffset, true, -1);
1416: } else {
1417: elSyntax.load(helpELStateInfo, buffer, tokenOffset,
1418: canBe - tokenOffset, true, -1);
1419: }
1420: returnedTokenID = elSyntax.nextToken();
1421: tokenContextPath = JspMultiTokenContext.elContextPath;
1422: // we got the StateInfo, which is why we did all this
1423: if (elStateInfo == null) {
1424: elStateInfo = elSyntax.createStateInfo();
1425: }
1426: elSyntax.storeState(elStateInfo);
1427: elStateInfo.setPreScan(0);
1428: //if (elSyntax.getOffset() != canBe)
1429: //new Exception("bad number of characters parsed !!!").printStackTrace();
1430: offset = canBe;
1431: /*if (debug) {
1432: System.out.println("offset of the returned (a)" + elSyntax.getOffset());
1433: System.out.println("found delimiter at " + offset);
1434: System.out.println("returnuju (16.5) " + firstTokenID + " at " + offset);
1435: }*/
1436: return firstTokenID;
1437: }
1438: // break; //- not reached
1439:
1440: //</editor-fold>
1441: default:
1442: Logger.getLogger("global").log(Level.INFO, null,
1443: new Exception("bad nestmode")); // NOI18N
1444: tokenContextPath = JspMultiTokenContext.contextPath;
1445: return JspMultiTokenContext.ERROR; // !!! don't know what to return
1446: }
1447: }
1448:
1449: //<editor-fold defaultstate="collapsed" desc="help methods">
1450:
1451: private TokenContextPath getJavaTokenContextPath() {
1452: switch (javaNestMode) {
1453: case JAVA_DECLARATION:
1454: return JspMultiTokenContext.javaDeclarationContextPath;
1455: case JAVA_EXPRESSION:
1456: return JspMultiTokenContext.javaExpressionContextPath;
1457: case JAVA_SCRIPTLET:
1458: default:
1459: return JspMultiTokenContext.javaScriptletContextPath;
1460: }
1461: }
1462:
1463: /** Method for debugging purposes * /
1464: private String getToken(Syntax syntax) {
1465: StringBuffer token = new StringBuffer();
1466: for (int i=syntax.getOffset()-syntax.getTokenLength();i<syntax.getOffset();i++)
1467: token.append(buffer[i]);
1468: return token.toString();
1469: }
1470: */
1471:
1472: /** Checks if the part of the buffer starting at tokenOffset and ending just before endOffset
1473: * contains a "delimiter" or could contain a starting part of a "delimiter", where
1474: * "delimiter" is a lexical structure which could start a JSP tag of a Java block in
1475: * the host language, i.e. <code><jsp:useBean</code> or <code><%=</code>.
1476: * @return <ul>
1477: * <li><code>DELIMCHECK_NO</code> if the part of the buffer does not contain a delimiter or its part</li>
1478: * <li><code>DELIMCHECK_PART</code> if the part of the buffer contains part of the delimiter</li>
1479: * <li>index of the starting symbol of the delimiter if the part of the buffer contains the delimiter.
1480: * In such a case variable <code>state</code> is set properly.</li>
1481: * </ul>
1482: */
1483: protected int canBeHostDelimiter(int tokenOffset, int endOffset,
1484: int firstTokenEnd, boolean lastPart) {
1485: int offset = tokenOffset;
1486: char actChar;
1487:
1488: int possibleBeginning = DELIMCHECK_NO;
1489: StringBuffer tagString = null;
1490: int delimState = HOST_INIT;
1491:
1492: while (offset < endOffset) {
1493: actChar = buffer[offset];
1494:
1495: switch (delimState) {
1496: case HOST_INIT:
1497: switch (actChar) {
1498: case '<':
1499: if (offset >= firstTokenEnd)
1500: return DELIMCHECK_NO;
1501: delimState = HOST_LT;
1502: possibleBeginning = offset;
1503: break;
1504: case '$':
1505: case '#':
1506: if (offset >= firstTokenEnd)
1507: return DELIMCHECK_NO;
1508: if (!isELIgnored(false)) {
1509: delimState = HOST_D;
1510: possibleBeginning = offset;
1511: }
1512: break;
1513: case '\\':
1514: if (offset >= firstTokenEnd)
1515: return DELIMCHECK_NO;
1516: delimState = HOST_BS;
1517: possibleBeginning = offset; // not really true, the delimiter can't start here
1518: break;
1519: default:
1520: if (offset >= firstTokenEnd)
1521: return DELIMCHECK_NO;
1522: break;
1523: }
1524: break;
1525:
1526: case HOST_LT:
1527: if (Character.isLetter(actChar) || (actChar == '_')) { // possible tag begining
1528: delimState = HOST_TAG;
1529: tagString = new StringBuffer();
1530: tagString.append(actChar);
1531: break; // the switch statement
1532: }
1533:
1534: switch (actChar) {
1535: case '\n':
1536: delimState = HOST_INIT;
1537: break;
1538: case '%':
1539: delimState = HOST_LT_PC;
1540: break;
1541: case '/':
1542: delimState = HOST_LT_SLASH;
1543: break;
1544: case ' ':
1545: case '\t':
1546: delimState = HOST_LT_BLANK;
1547: break;
1548: default:
1549: delimState = HOST_INIT;
1550: offset--;
1551: break;
1552: }
1553: break;
1554:
1555: case HOST_LT_SLASH:
1556: if (Character.isLetter(actChar) || (actChar == '_')) { // possible tag begining
1557: delimState = HOST_TAG;
1558: tagString = new StringBuffer();
1559: tagString.append(actChar);
1560: break; // the switch statement
1561: }
1562:
1563: switch (actChar) {
1564: case '\n':
1565: delimState = HOST_INIT;
1566: break;
1567: case ' ':
1568: case '\t':
1569: delimState = HOST_LT_BLANK;
1570: break;
1571: default:
1572: delimState = HOST_INIT;
1573: offset--;
1574: break;
1575: }
1576: break;
1577:
1578: case HOST_LT_BLANK:
1579: if (Character.isLetter(actChar) || (actChar == '_')
1580: || (actChar == '/')) { // possible tag begining
1581: delimState = HOST_TAG;
1582: // we are checking whether this is a JSP tag, however even if it is,
1583: // JspTagSyntax will report any spaces between < and tagname as errors
1584: tagString = new StringBuffer();
1585: //if there is a space after </ let the text be parsed by JSP parser - it will report an error
1586: if (actChar != '/')
1587: tagString.append(actChar);
1588: break; // the switch statement
1589: }
1590:
1591: switch (actChar) {
1592: case '\n':
1593: delimState = HOST_INIT;
1594: break;
1595: case ' ':
1596: case '\t':
1597: break;
1598: default:
1599: delimState = HOST_INIT;
1600: offset--;
1601: break;
1602: }
1603: break;
1604:
1605: case HOST_TAG:
1606: if (Character.isLetter(actChar)
1607: || Character.isDigit(actChar)
1608: || (actChar == ':') || (actChar == '-')
1609: || (actChar == '_')) { // the tag continues
1610: tagString.append(actChar);
1611: break; // the switch statement
1612: }
1613:
1614: switch (actChar) {
1615: default:
1616: if (isJspTag(tagString.toString())) {
1617: state = ISI_HOST_JSPTAG;
1618: //if (debug)
1619: //System.out.println("found beginning of JspTag at " + possibleBeginning);
1620: return possibleBeginning;
1621: } else {
1622: delimState = HOST_INIT;
1623: offset--;
1624: break;
1625: }
1626: }
1627: break;
1628:
1629: case HOST_LT_PC:
1630: switch (actChar) {
1631: case '@': // directive
1632: case '-': // JSP comment
1633: state = ISI_HOST_JSPTAG;
1634: //if (debug)
1635: //System.out.println("found beginning of directive/comment at " + possibleBeginning);
1636: return possibleBeginning;
1637: case '!': // declaration
1638: javaNestMode = JAVA_DECLARATION;
1639: state = ISI_HOST_JAVA;
1640: //if (debug)
1641: //System.out.println("found beginning of declaration/expression at " + possibleBeginning);
1642: return possibleBeginning;
1643:
1644: case '=': // expression
1645: javaNestMode = JAVA_EXPRESSION;
1646: state = ISI_HOST_JAVA;
1647: //if (debug)
1648: //System.out.println("found beginning of declaration/expression at " + possibleBeginning);
1649: return possibleBeginning;
1650: default: // scriptlet
1651: javaNestMode = JAVA_SCRIPTLET;
1652: state = ISI_HOST_JAVA;
1653: //if (debug)
1654: //System.out.println("found beginning of scriptlet at " + possibleBeginning);
1655: return possibleBeginning;
1656: }
1657: //break;
1658:
1659: case HOST_D:
1660: switch (actChar) {
1661: case '\n':
1662: delimState = HOST_INIT;
1663: break;
1664: case '{':
1665: state = ISI_HOST_EL;
1666: return possibleBeginning;
1667: default:
1668: delimState = HOST_INIT;
1669: offset--;
1670: break;
1671: }
1672: break;
1673:
1674: case HOST_BS:
1675: switch (actChar) {
1676: case '<':
1677: if (offset >= firstTokenEnd)
1678: return DELIMCHECK_NO;
1679: delimState = HOST_LT;
1680: possibleBeginning = offset;
1681: break;
1682: case '\\':
1683: if (offset >= firstTokenEnd)
1684: return DELIMCHECK_NO;
1685: possibleBeginning = offset; // not really true, the delimiter can't start here
1686: break;
1687: default:
1688: delimState = HOST_INIT;
1689: break;
1690: }
1691: break;
1692: }
1693:
1694: offset++;
1695: }
1696:
1697: if (lastPart) {
1698: switch (delimState) {
1699: case HOST_LT_PC:
1700: state = ISI_HOST_JAVA;
1701: return possibleBeginning;
1702: case HOST_TAG:
1703: if (isJspTag(tagString.toString())) {
1704: state = ISI_HOST_JSPTAG;
1705: //if (debug)
1706: //System.out.println("found beginning of JspTag at " + possibleBeginning);
1707: return possibleBeginning;
1708: }
1709: }
1710: }
1711:
1712: // we have reached the end of the scanned area
1713: switch (delimState) {
1714: case HOST_INIT:
1715: return DELIMCHECK_NO;
1716: case HOST_LT:
1717: case HOST_LT_SLASH:
1718: case HOST_LT_PC:
1719: case HOST_LT_BLANK:
1720: case HOST_TAG:
1721: case HOST_D:
1722: case HOST_BS:
1723: return DELIMCHECK_PART;
1724: default:
1725: Logger.getLogger("global").log(Level.INFO, null,
1726: new Exception("invalid state")); // NOI18N
1727: return DELIMCHECK_NO;
1728: }
1729: }
1730:
1731: /** Checks if the part of the buffer starting at tokenOffset and ending just before endOffset
1732: * contains a "delimiter" or could contain a starting part of a "delimiter", where
1733: * "delimiter" is a lexical structure which could start a Java block inside a JSP tag,
1734: * i.e. <code><%=</code>.
1735: * @return <ul>
1736: * <li><code>DELIMCHECK_NO</code> if the part of the buffer does not contain a delimiter or its part</li>
1737: * <li><code>DELIMCHECK_PART</code> if the part of the buffer contains part of the delimiter</li>
1738: * <li>index of the starting symbol of the delimiter if the part of the buffer contains the delimiter.
1739: * In such a case variable <code>state</code> is set properly.</li>
1740: * </ul>
1741: */
1742: protected int canBeJspTagDelimiter(int tokenOffset, int endOffset,
1743: int firstTokenEnd, boolean lastPart, boolean isComment) {
1744: if (isComment)
1745: return DELIMCHECK_NO;
1746:
1747: int offset = tokenOffset;
1748: char actChar;
1749:
1750: int possibleBeginning = DELIMCHECK_NO;
1751: int delimState = JSPTAG_INIT;
1752:
1753: while (offset < endOffset) {
1754: actChar = buffer[offset];
1755:
1756: switch (delimState) {
1757: case JSPTAG_INIT:
1758: switch (actChar) {
1759: case '<':
1760: if (offset >= firstTokenEnd)
1761: return DELIMCHECK_NO;
1762: delimState = JSPTAG_LT;
1763: possibleBeginning = offset;
1764: break;
1765: case '$':
1766: case '#':
1767: if (offset >= firstTokenEnd)
1768: return DELIMCHECK_NO;
1769: if (!isELIgnored(true)) {
1770: delimState = JSPTAG_D;
1771: possibleBeginning = offset;
1772: }
1773: break;
1774: case '\\':
1775: if (offset >= firstTokenEnd)
1776: return DELIMCHECK_NO;
1777: delimState = JSPTAG_BS;
1778: possibleBeginning = offset; // not really true, the delimiter can't start here
1779: break;
1780: default:
1781: if (offset >= firstTokenEnd)
1782: return DELIMCHECK_NO;
1783: break;
1784: }
1785: break;
1786:
1787: case JSPTAG_LT:
1788: switch (actChar) {
1789: case '\n':
1790: delimState = JSPTAG_INIT;
1791: break;
1792: case '%':
1793: delimState = JSPTAG_LT_PC;
1794: break;
1795: default:
1796: delimState = JSPTAG_INIT;
1797: offset--;
1798: break;
1799: }
1800: break;
1801:
1802: case JSPTAG_LT_PC:
1803: switch (actChar) {
1804: case '!': // declaration
1805: javaNestMode = JAVA_DECLARATION;
1806: state = ISI_JSPTAG_JAVA;
1807: //if (debug)
1808: //System.out.println("found beginning of declaration/expression at " + possibleBeginning);
1809: return possibleBeginning;
1810:
1811: case '=': // expression
1812: javaNestMode = JAVA_EXPRESSION;
1813: state = ISI_JSPTAG_JAVA;
1814: //if (debug)
1815: //System.out.println("found beginning of declaration/expression at " + possibleBeginning);
1816: return possibleBeginning;
1817: case '@': // declaration
1818: case '-': // comment
1819: delimState = JSPTAG_INIT;
1820: break;
1821: default: // scriptlet
1822: javaNestMode = JAVA_SCRIPTLET;
1823: state = ISI_JSPTAG_JAVA;
1824: //if (debug)
1825: //System.out.println("found beginning of scriptlet at " + possibleBeginning);
1826: return possibleBeginning;
1827: }
1828: //break;
1829:
1830: case JSPTAG_D:
1831: switch (actChar) {
1832: case '\n':
1833: delimState = JSPTAG_INIT;
1834: break;
1835: case '{':
1836: state = ISI_JSPTAG_EL;
1837: return possibleBeginning;
1838: default:
1839: delimState = JSPTAG_INIT;
1840: offset--;
1841: break;
1842: }
1843: break;
1844:
1845: case JSPTAG_BS:
1846: switch (actChar) {
1847: case '<':
1848: if (offset >= firstTokenEnd)
1849: return DELIMCHECK_NO;
1850: delimState = JSPTAG_LT;
1851: possibleBeginning = offset;
1852: break;
1853: case '\\':
1854: if (offset >= firstTokenEnd)
1855: return DELIMCHECK_NO;
1856: possibleBeginning = offset; // not really true, the delimiter can't start here
1857: break;
1858: default:
1859: delimState = JSPTAG_INIT;
1860: break;
1861: }
1862: break;
1863: }
1864:
1865: offset++;
1866: }
1867:
1868: if (lastPart) {
1869: switch (delimState) {
1870: case JSPTAG_LT_PC:
1871: state = ISI_JSPTAG_JAVA;
1872: //if (debug)
1873: //System.out.println("found beginning of scriptlet at " + possibleBeginning);
1874: return possibleBeginning;
1875: }
1876: }
1877:
1878: // we have reached the end of the scanned area
1879: switch (delimState) {
1880: case JSPTAG_INIT:
1881: return DELIMCHECK_NO;
1882: case JSPTAG_LT:
1883: return DELIMCHECK_PART;
1884: case JSPTAG_LT_PC:
1885: return DELIMCHECK_PART;
1886: case JSPTAG_D:
1887: return DELIMCHECK_PART;
1888: case JSPTAG_BS:
1889: //this state (error???) happens when only one character '\'
1890: //is scanned by this method (tokenOffset = endOffset - 1)
1891: return DELIMCHECK_NO;
1892: default:
1893: Logger.getLogger("global").log(Level.INFO, null,
1894: new Exception("invalid state " + delimState)); // NOI18N
1895: return DELIMCHECK_NO;
1896: }
1897: }
1898:
1899: /** Checks if the part of the buffer starting at tokenOffset and ending just before endOffset
1900: * contains a "delimiter" or could contain a starting part of a "delimiter", where
1901: * "delimiter" is a lexical structure which could end a Java block,
1902: * i.e. <code>%></code>.
1903: * @return <ul>
1904: * <li><code>DELIMCHECK_NO</code> if the part of the buffer does not contain a delimiter or its part</li>
1905: * <li><code>DELIMCHECK_PART</code> if the part of the buffer contains part of the delimiter</li>
1906: * <li>index of the starting symbol of the delimiter if the part of the buffer contains the delimiter.
1907: * In such a case variable <code>state</code> is set properly.</li>
1908: * </ul>
1909: */
1910: protected int canBeJavaDelimiter(int tokenOffset, int endOffset,
1911: int firstTokenEnd, boolean lastPart, int myNestMode) {
1912: int offset = tokenOffset;
1913: char actChar;
1914:
1915: int possibleBeginning = DELIMCHECK_NO;
1916: int delimState = JAVA_INIT;
1917:
1918: while (offset < endOffset) {
1919: actChar = buffer[offset];
1920:
1921: switch (delimState) {
1922: case JAVA_INIT:
1923: switch (actChar) {
1924: case '%':
1925: if (offset >= firstTokenEnd)
1926: return DELIMCHECK_NO;
1927: delimState = JAVA_PC;
1928: possibleBeginning = offset;
1929: break;
1930: default:
1931: if (offset >= firstTokenEnd)
1932: return DELIMCHECK_NO;
1933: break;
1934: }
1935: break;
1936:
1937: case JAVA_PC:
1938: switch (actChar) {
1939: case '>':
1940: switch (myNestMode) {
1941: case MODE_HOST_JSPTAG_JAVA:
1942: state = ISI_JAVA1_SWITCH;
1943: //if (debug)
1944: //System.out.println("found end of Java at " + possibleBeginning);
1945: return possibleBeginning;
1946: case MODE_HOST_JAVA:
1947: state = ISI_JAVA2_SWITCH;
1948: //if (debug)
1949: //System.out.println("found end of Java at " + possibleBeginning);
1950: return possibleBeginning;
1951: }
1952: Logger.getLogger("global").log(Level.INFO, null,
1953: new Exception("bad nestMode")); // NOI18N
1954: //break; - not reached
1955: case '%':
1956: if (offset >= firstTokenEnd)
1957: return DELIMCHECK_NO;
1958: delimState = JAVA_PC;
1959: possibleBeginning = offset;
1960: break;
1961: default:
1962: delimState = JAVA_INIT;
1963: break;
1964: }
1965: break;
1966: }
1967:
1968: offset++;
1969: }
1970:
1971: // we have reached the end of the scanned area
1972: switch (delimState) {
1973: case JAVA_INIT:
1974: return DELIMCHECK_NO;
1975: case JAVA_PC:
1976: return DELIMCHECK_PART;
1977: default:
1978: Logger.getLogger("global").log(Level.INFO, null,
1979: new Exception("invalid state")); // NOI18N
1980: return DELIMCHECK_NO;
1981: }
1982: }
1983:
1984: /** Checks if the part of the buffer starting at tokenOffset and ending just before endOffset
1985: * contains a "delimiter" or could contain a starting part of a "delimiter", where
1986: * "delimiter" is a lexical structure which could end a EL block,
1987: * i.e. <code>}</code>.
1988: * @return <ul>
1989: * <li><code>DELIMCHECK_NO</code> if the part of the buffer does not contain a delimiter or its part</li>
1990: * <li><code>DELIMCHECK_PART</code> if the part of the buffer contains part of the delimiter</li>
1991: * <li>index of the starting symbol of the delimiter if the part of the buffer contains the delimiter.
1992: * In such a case variable <code>state</code> is set properly.</li>
1993: * </ul>
1994: */
1995: protected int canBeELDelimiter(int tokenOffset, int endOffset,
1996: int firstTokenEnd, boolean lastPart, int myNestMode) {
1997: int offset = tokenOffset;
1998: char actChar;
1999:
2000: int possibleBeginning = DELIMCHECK_NO;
2001: int delimState = EL_INIT;
2002:
2003: while (offset < endOffset) {
2004: actChar = buffer[offset];
2005:
2006: switch (delimState) {
2007: case EL_INIT: // the only state for now
2008: switch (actChar) {
2009: case '}':
2010: if (offset >= firstTokenEnd)
2011: return DELIMCHECK_NO;
2012: possibleBeginning = offset;
2013: switch (myNestMode) {
2014: case MODE_HOST_JSPTAG_EL:
2015: state = ISI_EL1_SWITCH;
2016: //if (debug)
2017: //System.out.println("found end of EL at " + possibleBeginning);
2018: return possibleBeginning;
2019: case MODE_HOST_EL:
2020: state = ISI_EL2_SWITCH;
2021: //if (debug)
2022: //System.out.println("found end of EL at " + possibleBeginning);
2023: return possibleBeginning;
2024: }
2025: Logger.getLogger("global").log(Level.INFO, null,
2026: new Exception("bad nestMode")); // NOI18N
2027: break;
2028: default:
2029: if (offset >= firstTokenEnd)
2030: return DELIMCHECK_NO;
2031: break;
2032: }
2033: break;
2034: }
2035:
2036: offset++;
2037: }
2038:
2039: // we have reached the end of the scanned area
2040: switch (delimState) {
2041: case EL_INIT:
2042: return DELIMCHECK_NO;
2043: default:
2044: Logger.getLogger("global").log(Level.INFO, null,
2045: new Exception("invalid state")); // NOI18N
2046: return DELIMCHECK_NO;
2047: }
2048: }
2049:
2050: /** Determines whether a given string is a JSP tag. */
2051: protected boolean isJspTag(String tagName) {
2052: boolean canBeJsp = tagName.startsWith("jsp:"); // NOI18N
2053: return canBeJsp;
2054: }
2055:
2056: /** Determines whether any EL expressions should be colored as expressions,
2057: * or ignored. This class does not have all the context necessary to decide this,
2058: * so it just returns false (meaning that EL should be colored). Subclasses
2059: * should override this to return the correct value per section JSP.3.3.2
2060: * of the specification.
2061: * @param whether this expression is inside the JSP tag value, or just in template text
2062: * @return true if the expression should be ignored, false if it should be treated as an expression
2063: */
2064: protected boolean isELIgnored(boolean inJspTag) {
2065: return false;
2066: }
2067:
2068: /** Determines whether the page is in xml syntax or not.
2069: * This class does not have all the context necessary to decide this,
2070: * so it just returns false. Subclasses
2071: * should override this to return the correct value.
2072: * @return true if the page is JSP Document, false if the page is in standart syntax
2073: */
2074: protected boolean isXMLSyntax() {
2075: return false;
2076: }
2077:
2078: private void transferMasterToSlave(Syntax slave, StateInfo stateInfo) {
2079: slave.load(stateInfo, buffer, offset, stopOffset - offset,
2080: lastBuffer, -1);
2081: //slave.setLastBuffer(lastBuffer); // PENDING - maybe not necessary
2082: //slave.setStopOffset(stopOffset); // PENDING - maybe not necessary
2083: }
2084:
2085: /** Store state of this analyzer into given mark state. */
2086: public void storeState(StateInfo stateInfo) {
2087: super .storeState(stateInfo);
2088: JspStateInfo jspsi = (JspStateInfo) stateInfo;
2089: // nest mode
2090: jspsi.nestMode = nestMode;
2091: jspsi.javaNestMode = javaNestMode;
2092:
2093: // regular stateinfos
2094: if (hostStateInfo == null) {
2095: jspsi.hostStateInfo = null;
2096: } else {
2097: jspsi.hostStateInfo = hostSyntax.createStateInfo();
2098: hostSyntax
2099: .load(hostStateInfo, buffer, offset, 0, false, -1);
2100: hostSyntax.storeState(jspsi.hostStateInfo);
2101: }
2102: if (jspTagStateInfo == null) {
2103: jspsi.jspTagStateInfo = null;
2104: } else {
2105: jspsi.jspTagStateInfo = jspTagSyntax.createStateInfo();
2106: jspTagSyntax.load(jspTagStateInfo, buffer, offset, 0,
2107: false, -1);
2108: jspTagSyntax.storeState(jspsi.jspTagStateInfo);
2109: }
2110: if (elStateInfo == null) {
2111: jspsi.elStateInfo = null;
2112: } else {
2113: jspsi.elStateInfo = elSyntax.createStateInfo();
2114: elSyntax.load(elStateInfo, buffer, offset, 0, false, -1);
2115: elSyntax.storeState(jspsi.elStateInfo);
2116: }
2117: if (javaStateInfo == null) {
2118: jspsi.javaStateInfo = null;
2119: } else {
2120: jspsi.javaStateInfo = javaSyntax.createStateInfo();
2121: javaSyntax
2122: .load(javaStateInfo, buffer, offset, 0, false, -1);
2123: javaSyntax.storeState(jspsi.javaStateInfo);
2124: }
2125: // stateOfScanningAtInit, firstTokenID, firstTokenLength
2126: if (jspsi.isFirstTokenValid()) {
2127: jspsi.firstTokenID = firstTokenID;
2128: jspsi.firstTokenLength = firstTokenLength;
2129: switch (nestMode) {
2130: case MODE_HOST:
2131: jspsi.stateOfScanningAtInit = hostSyntax
2132: .createStateInfo();
2133: hostSyntax.load(helpHostStateInfo, buffer, offset, 0,
2134: false, -1);
2135: hostSyntax.storeState(jspsi.stateOfScanningAtInit);
2136: break;
2137: case MODE_HOST_JSPTAG:
2138: jspsi.stateOfScanningAtInit = jspTagSyntax
2139: .createStateInfo();
2140: jspTagSyntax.load(helpJspTagStateInfo, buffer, offset,
2141: 0, false, -1);
2142: jspTagSyntax.storeState(jspsi.stateOfScanningAtInit);
2143: break;
2144: case MODE_HOST_JSPTAG_EL:
2145: case MODE_HOST_EL:
2146: jspsi.stateOfScanningAtInit = elSyntax
2147: .createStateInfo();
2148: elSyntax.load(helpELStateInfo, buffer, offset, 0,
2149: false, -1);
2150: elSyntax.storeState(jspsi.stateOfScanningAtInit);
2151: break;
2152: case MODE_HOST_JSPTAG_JAVA:
2153: case MODE_HOST_JAVA:
2154: jspsi.stateOfScanningAtInit = javaSyntax
2155: .createStateInfo();
2156: javaSyntax.load(helpJavaStateInfo, buffer, offset, 0,
2157: false, -1);
2158: javaSyntax.storeState(jspsi.stateOfScanningAtInit);
2159: break;
2160: }
2161: } else {
2162: jspsi.stateOfScanningAtInit = null;
2163: jspsi.firstTokenID = null;
2164: jspsi.firstTokenLength = -1;
2165: }
2166: /*System.out.print("storing state at offset=" + offset + ", tokenOffset=" + tokenOffset + ", token=");
2167: for(int i=tokenOffset;i<offset;i++)
2168: System.out.print(buffer[i]);
2169: System.out.println();
2170: System.out.println(((JspStateInfo)stateInfo).toString(this));*/
2171: }
2172:
2173: public void loadState(StateInfo stateInfo) {
2174: /*System.out.println("loading state");
2175: System.out.println(((JspStateInfo)stateInfo).toString(this)); */
2176: super .loadState(stateInfo);
2177: JspStateInfo jspsi = (JspStateInfo) stateInfo;
2178: nestMode = jspsi.nestMode;
2179: javaNestMode = jspsi.javaNestMode;
2180:
2181: // now all the slave states
2182: if (jspsi.hostStateInfo == null) {
2183: hostStateInfo = null;
2184: } else {
2185: hostSyntax.load(jspsi.hostStateInfo, buffer, offset, 0,
2186: false, -1);
2187: hostStateInfo = hostSyntax.createStateInfo();
2188: hostSyntax.storeState(hostStateInfo);
2189: }
2190: if (jspsi.jspTagStateInfo == null) {
2191: jspTagStateInfo = null;
2192: } else {
2193: jspTagSyntax.load(jspsi.jspTagStateInfo, buffer, offset, 0,
2194: false, -1);
2195: jspTagStateInfo = jspTagSyntax.createStateInfo();
2196: jspTagSyntax.storeState(jspTagStateInfo);
2197: }
2198: if (jspsi.elStateInfo == null) {
2199: elStateInfo = null;
2200: } else {
2201: elSyntax.load(jspsi.elStateInfo, buffer, offset, 0, false,
2202: -1);
2203: elStateInfo = elSyntax.createStateInfo();
2204: elSyntax.storeState(elStateInfo);
2205: }
2206: if (jspsi.javaStateInfo == null) {
2207: javaStateInfo = null;
2208: } else {
2209: javaSyntax.load(jspsi.javaStateInfo, buffer, offset, 0,
2210: false, -1);
2211: javaStateInfo = javaSyntax.createStateInfo();
2212: javaSyntax.storeState(javaStateInfo);
2213: }
2214: // stateOfScanningAtInit, firstTokenID, firstTokenLength
2215: if (jspsi.isFirstTokenValid()) {
2216: firstTokenID = jspsi.firstTokenID;
2217: firstTokenLength = jspsi.firstTokenLength;
2218: switch (jspsi.nestMode) {
2219: case MODE_HOST:
2220: hostSyntax.load(jspsi.stateOfScanningAtInit, buffer,
2221: offset, 0, false, -1);
2222: hostSyntax.storeState(helpHostStateInfo);
2223: break;
2224: case MODE_HOST_JSPTAG:
2225: jspTagSyntax.load(jspsi.stateOfScanningAtInit, buffer,
2226: offset, 0, false, -1);
2227: jspTagSyntax.storeState(helpJspTagStateInfo);
2228: break;
2229: case MODE_HOST_JSPTAG_EL:
2230: case MODE_HOST_EL:
2231: elSyntax.load(jspsi.stateOfScanningAtInit, buffer,
2232: offset, 0, false, -1);
2233: elSyntax.storeState(helpELStateInfo);
2234: break;
2235: case MODE_HOST_JSPTAG_JAVA:
2236: case MODE_HOST_JAVA:
2237: javaSyntax.load(jspsi.stateOfScanningAtInit, buffer,
2238: offset, 0, false, -1);
2239: javaSyntax.storeState(helpJavaStateInfo);
2240: break;
2241: }
2242: } else {
2243: firstTokenID = null;
2244: firstTokenLength = -1;
2245: }
2246: }
2247:
2248: public void loadInitState() {
2249: super .loadInitState();
2250: nestMode = MODE_HOST;
2251: state = ISI_LANGUAGE;
2252: hostStateInfo = null;
2253: jspTagStateInfo = null;
2254: elStateInfo = null;
2255: javaStateInfo = null;
2256: firstTokenID = null;
2257: firstTokenLength = -1;
2258: }
2259:
2260: public void load(StateInfo stateInfo, char buffer[], int offset,
2261: int len, boolean lastBuffer) {
2262: JspStateInfo jspsi = (JspStateInfo) stateInfo;
2263: if (jspsi == null) {
2264: hostStateInfo = null;
2265: jspTagStateInfo = null;
2266: elStateInfo = null;
2267: javaStateInfo = null;
2268: firstTokenID = null;
2269: firstTokenLength = -1;
2270: }
2271: super .load(stateInfo, buffer, offset, len, lastBuffer, -1);
2272: }
2273:
2274: public StateInfo createStateInfo() {
2275: return new JspStateInfo();
2276: }
2277:
2278: public int compareState(StateInfo stateInfo) {
2279: if (super .compareState(stateInfo) == DIFFERENT_STATE)
2280: return DIFFERENT_STATE;
2281: JspStateInfo jspsi = (JspStateInfo) stateInfo;
2282: if (jspsi.nestMode != nestMode)
2283: return DIFFERENT_STATE;
2284: if (jspsi.isFirstTokenValid()) {
2285: if (jspsi.firstTokenID != firstTokenID)
2286: return DIFFERENT_STATE;
2287: if (jspsi.firstTokenLength != firstTokenLength)
2288: return DIFFERENT_STATE;
2289: }
2290: if (jspsi.javaNestMode != javaNestMode)
2291: return DIFFERENT_STATE;
2292: int ret;
2293: switch (nestMode) {
2294: case MODE_HOST:
2295: // host
2296: transferMasterToSlave(hostSyntax, hostStateInfo);
2297: ret = hostSyntax.compareState(jspsi.hostStateInfo);
2298: if (ret == DIFFERENT_STATE)
2299: return ret;
2300: if (jspsi.isFirstTokenValid()) {
2301: transferMasterToSlave(hostSyntax, helpHostStateInfo);
2302: ret = hostSyntax
2303: .compareState(jspsi.stateOfScanningAtInit);
2304: if (ret == DIFFERENT_STATE)
2305: return ret;
2306: }
2307: break;
2308: case MODE_HOST_JSPTAG:
2309: // host
2310: transferMasterToSlave(hostSyntax, hostStateInfo);
2311: ret = hostSyntax.compareState(jspsi.hostStateInfo);
2312: if (ret == Syntax.DIFFERENT_STATE)
2313: return ret;
2314: // jspTag
2315: transferMasterToSlave(jspTagSyntax, jspTagStateInfo);
2316: ret = jspTagSyntax.compareState(jspsi.jspTagStateInfo);
2317: if (ret == DIFFERENT_STATE)
2318: return ret;
2319: if (jspsi.isFirstTokenValid()) {
2320: transferMasterToSlave(jspTagSyntax, helpJspTagStateInfo);
2321: ret = jspTagSyntax
2322: .compareState(jspsi.stateOfScanningAtInit);
2323: if (ret == DIFFERENT_STATE)
2324: return ret;
2325: }
2326: break;
2327: case MODE_HOST_JSPTAG_EL:
2328: // host
2329: transferMasterToSlave(hostSyntax, hostStateInfo);
2330: ret = hostSyntax.compareState(jspsi.hostStateInfo);
2331: if (ret == DIFFERENT_STATE)
2332: return ret;
2333: // jspTag
2334: transferMasterToSlave(jspTagSyntax, jspTagStateInfo);
2335: ret = jspTagSyntax.compareState(jspsi.jspTagStateInfo);
2336: if (ret == DIFFERENT_STATE)
2337: return ret;
2338: // el
2339: transferMasterToSlave(elSyntax, elStateInfo);
2340: ret = elSyntax.compareState(jspsi.elStateInfo);
2341: if (ret == DIFFERENT_STATE)
2342: return ret;
2343: if (jspsi.isFirstTokenValid()) {
2344: transferMasterToSlave(elSyntax, helpELStateInfo);
2345: ret = elSyntax
2346: .compareState(jspsi.stateOfScanningAtInit);
2347: if (ret == DIFFERENT_STATE)
2348: return ret;
2349: }
2350: break;
2351: case MODE_HOST_EL:
2352: // host
2353: transferMasterToSlave(hostSyntax, hostStateInfo);
2354: ret = hostSyntax.compareState(jspsi.hostStateInfo);
2355: if (ret == DIFFERENT_STATE)
2356: return ret;
2357: // el
2358: transferMasterToSlave(elSyntax, elStateInfo);
2359: ret = elSyntax.compareState(jspsi.elStateInfo);
2360: if (ret == DIFFERENT_STATE)
2361: return ret;
2362: if (jspsi.isFirstTokenValid()) {
2363: transferMasterToSlave(elSyntax, helpELStateInfo);
2364: ret = elSyntax
2365: .compareState(jspsi.stateOfScanningAtInit);
2366: if (ret == DIFFERENT_STATE)
2367: return ret;
2368: }
2369: break;
2370: case MODE_HOST_JSPTAG_JAVA:
2371: // host
2372: transferMasterToSlave(hostSyntax, hostStateInfo);
2373: ret = hostSyntax.compareState(jspsi.hostStateInfo);
2374: if (ret == DIFFERENT_STATE)
2375: return ret;
2376: // jspTag
2377: transferMasterToSlave(jspTagSyntax, jspTagStateInfo);
2378: ret = jspTagSyntax.compareState(jspsi.jspTagStateInfo);
2379: if (ret == DIFFERENT_STATE)
2380: return ret;
2381: // java
2382: transferMasterToSlave(javaSyntax, javaStateInfo);
2383: ret = javaSyntax.compareState(jspsi.javaStateInfo);
2384: if (ret == DIFFERENT_STATE)
2385: return ret;
2386: if (jspsi.isFirstTokenValid()) {
2387: transferMasterToSlave(javaSyntax, helpJavaStateInfo);
2388: ret = javaSyntax
2389: .compareState(jspsi.stateOfScanningAtInit);
2390: if (ret == DIFFERENT_STATE)
2391: return ret;
2392: }
2393: break;
2394: case MODE_HOST_JAVA:
2395: // host
2396: transferMasterToSlave(hostSyntax, hostStateInfo);
2397: ret = hostSyntax.compareState(jspsi.hostStateInfo);
2398: if (ret == DIFFERENT_STATE)
2399: return ret;
2400: // java
2401: transferMasterToSlave(javaSyntax, javaStateInfo);
2402: ret = javaSyntax.compareState(jspsi.javaStateInfo);
2403: if (ret == DIFFERENT_STATE)
2404: return ret;
2405: if (jspsi.isFirstTokenValid()) {
2406: transferMasterToSlave(javaSyntax, helpJavaStateInfo);
2407: ret = javaSyntax
2408: .compareState(jspsi.stateOfScanningAtInit);
2409: if (ret == DIFFERENT_STATE)
2410: return ret;
2411: }
2412: break;
2413: }
2414: return EQUAL_STATE;
2415: }
2416:
2417: public String getNestModeName(int nestMode) {
2418: switch (nestMode) {
2419: case MODE_HOST:
2420: return "MODE_HOST"; // NOI18N
2421: case MODE_HOST_JSPTAG:
2422: return "MODE_HOST_JSPTAG"; // NOI18N
2423: case MODE_HOST_EL:
2424: return "MODE_HOST_EL"; // NOI18N
2425: case MODE_HOST_JSPTAG_EL:
2426: return "MODE_HOST_JSPTAG_EL"; // NOI18N
2427: case MODE_HOST_JSPTAG_JAVA:
2428: return "MODE_HOST_JSPTAG_JAVA"; // NOI18N
2429: case MODE_HOST_JAVA:
2430: return "MODE_HOST_JAVA"; // NOI18N
2431: default:
2432: return "unknown nestMode " + nestMode; // NOI18N
2433: }
2434: }
2435:
2436: public String getStateName(int stateNumber) {
2437: switch (stateNumber) {
2438: case ISI_LANGUAGE:
2439: return "ISI_LANGUAGE"; // NOI18N
2440: case ISI_HOST_JSPTAG:
2441: return "ISI_HOST_JSPTAG"; // NOI18N
2442: case ISI_HOST_JAVA:
2443: return "ISI_HOST_JAVA"; // NOI18N
2444: case ISI_HOST_JAVA_LT:
2445: return "ISI_HOST_JAVA_LT"; // NOI18N
2446: case ISI_HOST_JAVA_LT_PC:
2447: return "ISI_HOST_JAVA_LT_PC"; // NOI18N
2448: case ISI_HOST_JAVA_JUMP:
2449: return "ISI_HOST_JAVA_JUMP"; // NOI18N
2450: case ISI_HOST_EL:
2451: return "ISI_HOST_EL"; // NOI18N
2452: case ISI_HOST_EL_D:
2453: return "ISI_HOST_EL_D"; // NOI18N
2454: case ISI_HOST_EL_JUMP:
2455: return "ISI_HOST_EL_JUMP"; // NOI18N
2456: case ISI_JSPTAG_JAVA:
2457: return "ISI_JSPTAG_JAVA"; // NOI18N
2458: case ISI_JSPTAG_JAVA_LT:
2459: return "ISI_JSPTAG_JAVA_LT"; // NOI18N
2460: case ISI_JSPTAG_JAVA_LT_PC:
2461: return "ISI_JSPTAG_JAVA_LT_PC"; // NOI18N
2462: case ISI_JSPTAG_JAVA_JUMP:
2463: return "ISI_JSPTAG_JAVA_JUMP"; // NOI18N
2464: case ISI_JSPTAG_EL:
2465: return "ISI_JSPTAG_EL"; // NOI18N
2466: case ISI_JSPTAG_EL_D:
2467: return "ISI_JSPTAG_EL_D"; // NOI18N
2468: case ISI_JSPTAG_EL_JUMP:
2469: return "ISI_JSPTAG_EL_JUMP"; // NOI18N
2470: case ISI_JAVA1_SWITCH:
2471: return "ISI_JAVA1_SWITCH"; // NOI18N
2472: case ISI_JAVA1_PC:
2473: return "ISI_JAVA1_PC"; // NOI18N
2474: case ISI_JAVA1_JUMP:
2475: return "ISI_JAVA1_JUMP"; // NOI18N
2476: case ISI_JAVA2_SWITCH:
2477: return "ISI_JAVA2_SWITCH"; // NOI18N
2478: case ISI_JAVA2_PC:
2479: return "ISI_JAVA2_PC"; // NOI18N
2480: case ISI_JAVA2_JUMP:
2481: return "ISI_JAVA2_JUMP"; // NOI18N
2482: case ISI_EL1_SWITCH:
2483: return "ISI_EL1_SWITCH"; // NOI18N
2484: case ISI_EL1_JUMP:
2485: return "ISI_EL1_JUMP"; // NOI18N
2486: case ISI_EL2_SWITCH:
2487: return "ISI_EL2_SWITCH"; // NOI18N
2488: case ISI_EL2_JUMP:
2489: return "ISI_EL2_JUMP"; // NOI18N
2490: default:
2491: return super .getStateName(stateNumber); // NOI18N
2492: }
2493:
2494: //</editor-fold>
2495:
2496: }
2497:
2498: public static class JspStateInfo extends BaseStateInfo {
2499:
2500: int nestMode;
2501: StateInfo hostStateInfo;
2502: StateInfo jspTagStateInfo;
2503: StateInfo elStateInfo;
2504: StateInfo javaStateInfo;
2505:
2506: /** State info for the scanning syntax at 'tokenOffset', if tokenOffset != offset (i.e. null was returned). */
2507: StateInfo stateOfScanningAtInit;
2508:
2509: //state info defining contexts of java tokens (declaration/scriptlet/expression)
2510: int javaNestMode;
2511:
2512: /** Token ID returned by the first call of the scanning slave's nextToken(), possibly null. */
2513: TokenID firstTokenID;
2514:
2515: /** Token length of the token returned by the first call of the scanning slave's nextToken(), possibly invalid. */
2516: int firstTokenLength;
2517:
2518: public boolean isFirstTokenValid() {
2519: return (JspStateInfo.this .getPreScan() != 0);
2520: }
2521:
2522: public String toString(Syntax s) {
2523: //if ((getPreScan() != 0) && (stateOfScanningAtInit != null) && (stateOfScanningAtInit.getPreScan() != 0))
2524: //new Exception("scanning prescan should be 0").printStackTrace();
2525: return "JspStateInfo state="
2526: + getState()
2527: + ", prescan="
2528: + JspStateInfo.this .getPreScan()
2529: + ", nestMode="
2530: + nestMode
2531: + // NOI18N
2532: ((JspStateInfo.this .getPreScan() == 0) ? ""
2533: : "\n firstTokenID=" + firstTokenID
2534: + ", firstTokenLength="
2535: + firstTokenLength)
2536: + // NOI18N
2537: "\n hostStateInfo="
2538: + (hostStateInfo == null ? "null"
2539: : ((BaseStateInfo) hostStateInfo)
2540: .toString(s))
2541: + // NOI18N
2542: "\n jspTagStateInfo="
2543: + (jspTagStateInfo == null ? "null"
2544: : ((BaseStateInfo) jspTagStateInfo)
2545: .toString(s))
2546: + // NOI18N
2547: "\n elStateInfo="
2548: + (elStateInfo == null ? "null"
2549: : ((BaseStateInfo) elStateInfo).toString(s))
2550: + // NOI18N
2551: "\n javaStateInfo="
2552: + (javaStateInfo == null ? "null"
2553: : ((BaseStateInfo) javaStateInfo)
2554: .toString(s))
2555: + // NOI18N
2556: "\n scanning Info="
2557: + (stateOfScanningAtInit == null ? "null"
2558: : ((BaseStateInfo) stateOfScanningAtInit)
2559: .toString(s)); // NOI18N
2560: }
2561: }
2562:
2563: }
|