java/org/apache/jasper/compiler/SmapStratum.java - tomcat - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.jasper.compiler;

 import java.util.ArrayList;
 import java.util.List;

 /**
  * Represents the line and file mappings associated with a JSR-045
  * "stratum".
  *
  * @author Jayson Falkner
  * @author Shawn Bayern
  */
 public class SmapStratum {

     //*********************************************************************
     // Class for storing LineInfo data

     /**
      * Represents a single LineSection in an SMAP, associated with
      * a particular stratum.
      */
     static class LineInfo {
         private int inputStartLine = -1;
         private int outputStartLine = -1;
         private int lineFileID = 0;
         private int inputLineCount = 1;
         private int outputLineIncrement = 1;
         private boolean lineFileIDSet = false;

         public void setInputStartLine(int inputStartLine) {
             if (inputStartLine < 0) {
                 throw new IllegalArgumentException(Localizer.getMessage(
                         "jsp.error.negativeParameter", Integer.valueOf(inputStartLine)));
             }
             this.inputStartLine = inputStartLine;
         }

         public void setOutputStartLine(int outputStartLine) {
             if (outputStartLine < 0) {
                 throw new IllegalArgumentException(Localizer.getMessage(
                         "jsp.error.negativeParameter", Integer.valueOf(outputStartLine)));
             }
             this.outputStartLine = outputStartLine;
         }

         /**
          * Sets lineFileID.  Should be called only when different from
          * that of prior LineInfo object (in any given context) or 0
          * if the current LineInfo has no (logical) predecessor.
          * <code>LineInfo</code> will print this file number no matter what.
          *
          * @param lineFileID The new line file ID
          */
         public void setLineFileID(int lineFileID) {
             if (lineFileID < 0) {
                 throw new IllegalArgumentException(Localizer.getMessage(
                         "jsp.error.negativeParameter", Integer.valueOf(lineFileID)));
             }
             this.lineFileID = lineFileID;
             this.lineFileIDSet = true;
         }

         public void setInputLineCount(int inputLineCount) {
             if (inputLineCount < 0) {
                 throw new IllegalArgumentException(Localizer.getMessage(
                         "jsp.error.negativeParameter", Integer.valueOf(inputLineCount)));
             }
             this.inputLineCount = inputLineCount;
         }

         public void setOutputLineIncrement(int outputLineIncrement) {
             if (outputLineIncrement < 0) {
                 throw new IllegalArgumentException(Localizer.getMessage(
                         "jsp.error.negativeParameter", Integer.valueOf(outputLineIncrement)));
             }
             this.outputLineIncrement = outputLineIncrement;
         }

         public int getMaxOutputLineNumber() {
             return outputStartLine + inputLineCount * outputLineIncrement;
         }

         /**
          * @return the current LineInfo as a String, print all values only when
          *         appropriate (but LineInfoID if and only if it's been
          *         specified, as its necessity is sensitive to context).
          */
         public String getString() {
             if (inputStartLine == -1 || outputStartLine == -1) {
                 throw new IllegalStateException();
             }
             StringBuilder out = new StringBuilder();
             out.append(inputStartLine);
             if (lineFileIDSet) {
                 out.append("#" + lineFileID);
             }
             if (inputLineCount != 1) {
                 out.append("," + inputLineCount);
             }
             out.append(":" + outputStartLine);
             if (outputLineIncrement != 1) {
                 out.append("," + outputLineIncrement);
             }
             out.append('\n');
             return out.toString();
         }

         @Override
         public String toString() {
             return getString();
         }
     }

     //*********************************************************************
     // Private state

     private final List<String> fileNameList = new ArrayList<>();
     private final List<String> filePathList = new ArrayList<>();
     private final List<LineInfo> lineData = new ArrayList<>();
     private int lastFileID;
     // .java file
     private String outputFileName;
     // .class file
     private String classFileName;

     //*********************************************************************
     // Methods to add mapping information

     /**
      * Adds record of a new file, by filename.
      *
      * @param filename the filename to add, unqualified by path.
      */
     public void addFile(String filename) {
         addFile(filename, filename);
     }

     /**
      * Adds record of a new file, by filename and path.  The path
      * may be relative to a source compilation path.
      *
      * @param filename the filename to add, unqualified by path
      * @param filePath the path for the filename, potentially relative
      *                 to a source compilation path
      */
     public void addFile(String filename, String filePath) {
         int pathIndex = filePathList.indexOf(filePath);
         if (pathIndex == -1) {
             fileNameList.add(filename);
             filePathList.add(filePath);
         }
     }

     /**
      * Combines consecutive LineInfos wherever possible
      */
     public void optimizeLineSection() {

 /* Some debugging code
         for (int i = 0; i < lineData.size(); i++) {
             LineInfo li = (LineInfo)lineData.get(i);
             System.out.print(li.toString());
         }
  */
         //Incorporate each LineInfo into the previous LineInfo's
         //outputLineIncrement, if possible
         int i = 0;
         while (i < lineData.size() - 1) {
             LineInfo li = lineData.get(i);
             LineInfo liNext = lineData.get(i + 1);
             if (!liNext.lineFileIDSet
                 && liNext.inputStartLine == li.inputStartLine
                 && liNext.inputLineCount == 1
                 && li.inputLineCount == 1
                 && liNext.outputStartLine
                     == li.outputStartLine
                         + li.inputLineCount * li.outputLineIncrement) {
                 li.setOutputLineIncrement(
                     liNext.outputStartLine
                         - li.outputStartLine
                         + liNext.outputLineIncrement);
                 lineData.remove(i + 1);
             } else {
                 i++;
             }
         }

         //Incorporate each LineInfo into the previous LineInfo's
         //inputLineCount, if possible
         i = 0;
         while (i < lineData.size() - 1) {
             LineInfo li = lineData.get(i);
             LineInfo liNext = lineData.get(i + 1);
             if (!liNext.lineFileIDSet
                 && liNext.inputStartLine == li.inputStartLine + li.inputLineCount
                 && liNext.outputLineIncrement == li.outputLineIncrement
                 && liNext.outputStartLine
                     == li.outputStartLine
                         + li.inputLineCount * li.outputLineIncrement) {
                 li.setInputLineCount(li.inputLineCount + liNext.inputLineCount);
                 lineData.remove(i + 1);
             } else {
                 i++;
             }
         }
     }

     /**
      * Adds complete information about a simple line mapping.  Specify
      * all the fields in this method; the back-end machinery takes care
      * of printing only those that are necessary in the final SMAP.
      * (My view is that fields are optional primarily for spatial efficiency,
      * not for programmer convenience.  Could always add utility methods
      * later.)
      *
      * @param inputStartLine starting line in the source file
      *        (SMAP <code>InputStartLine</code>)
      * @param inputFileName the filepath (or name) from which the input comes
      *        (yields SMAP <code>LineFileID</code>)  Use unqualified names
      *        carefully, and only when they uniquely identify a file.
      * @param inputLineCount the number of lines in the input to map
      *        (SMAP <code>LineFileCount</code>)
      * @param outputStartLine starting line in the output file
      *        (SMAP <code>OutputStartLine</code>)
      * @param outputLineIncrement number of output lines to map to each
      *        input line (SMAP <code>OutputLineIncrement</code>).  <i>Given the
      *        fact that the name starts with "output", I continuously have
      *        the subconscious urge to call this field
      *        <code>OutputLineExcrement</code>.</i>
      */
     public void addLineData(
         int inputStartLine,
         String inputFileName,
         int inputLineCount,
         int outputStartLine,
         int outputLineIncrement) {
         // check the input - what are you doing here??
         int fileIndex = filePathList.indexOf(inputFileName);
         if (fileIndex == -1) {
             throw new IllegalArgumentException(
                 "inputFileName: " + inputFileName);
         }

         //Jasper incorrectly SMAPs certain Nodes, giving them an
         //outputStartLine of 0.  This can cause a fatal error in
         //optimizeLineSection, making it impossible for Jasper to
         //compile the JSP.  Until we can fix the underlying
         //SMAPping problem, we simply ignore the flawed SMAP entries.
         if (outputStartLine == 0) {
             return;
         }

         // build the LineInfo
         LineInfo li = new LineInfo();
         li.setInputStartLine(inputStartLine);
         li.setInputLineCount(inputLineCount);
         li.setOutputStartLine(outputStartLine);
         li.setOutputLineIncrement(outputLineIncrement);
         if (fileIndex != lastFileID) {
             li.setLineFileID(fileIndex);
         }
         lastFileID = fileIndex;

         // save it
         lineData.add(li);
     }


     public void addLineInfo(LineInfo li) {
         lineData.add(li);
     }


     public void setOutputFileName(String outputFileName) {
         this.outputFileName = outputFileName;
     }


     public void setClassFileName(String classFileName) {
         this.classFileName = classFileName;
     }


     public String getClassFileName() {
         return classFileName;
     }


     //*********************************************************************
     // Methods to retrieve information

     @Override
     public String toString() {
         return getSmapStringInternal();
     }


     public String getSmapString() {

         if (outputFileName == null) {
             throw new IllegalStateException();
         }

         return getSmapStringInternal();
     }


     private String getSmapStringInternal() {
         StringBuilder out = new StringBuilder();

         // start the SMAP
         out.append("SMAP\n");
         out.append(outputFileName + '\n');
         out.append("JSP\n");

         // print StratumSection
         out.append("*S JSP\n");

         // print FileSection
         out.append("*F\n");
         int bound = fileNameList.size();
         for (int i = 0; i < bound; i++) {
             if (filePathList.get(i) != null) {
                 out.append("+ " + i + " " + fileNameList.get(i) + "\n");
                 // Source paths must be relative, not absolute, so we
                 // remove the leading "/", if one exists.
                 String filePath = filePathList.get(i);
                 if (filePath.startsWith("/")) {
                     filePath = filePath.substring(1);
                 }
                 out.append(filePath + "\n");
             } else {
                 out.append(i + " " + fileNameList.get(i) + "\n");
             }
         }

         // print LineSection
         out.append("*L\n");
         bound = lineData.size();
         for (int i = 0; i < bound; i++) {
             LineInfo li = lineData.get(i);
             out.append(li.getString());
         }

         // end the SMAP
         out.append("*E\n");

         return out.toString();
     }


     public SmapInput getInputLineNumber(int outputLineNumber) {
         // For a given Java line number, provide the associated line number
         // in the JSP/tag source
         int inputLineNumber = -1;
         int fileId = 0;

         for (LineInfo lineInfo : lineData) {
             if (lineInfo.lineFileIDSet) {
                 fileId = lineInfo.lineFileID;
             }
             if (lineInfo.outputStartLine > outputLineNumber) {
                 // Didn't find match
                 break;
             }

             if (lineInfo.getMaxOutputLineNumber() < outputLineNumber) {
                 // Too early
                 continue;
             }

             // This is the match
             int inputOffset =
                     (outputLineNumber - lineInfo.outputStartLine) / lineInfo.outputLineIncrement;

             inputLineNumber = lineInfo.inputStartLine + inputOffset;
         }

         return new SmapInput(filePathList.get(fileId), inputLineNumber);
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.apache.jasper.compiler;

	import java.util.ArrayList;
	import java.util.List;

	/**
	* Represents the line and file mappings associated with a JSR-045
	* "stratum".
	*
	* @author Jayson Falkner
	* @author Shawn Bayern
	*/
	public class SmapStratum {

	//*********************************************************************
	// Class for storing LineInfo data

	/**
	* Represents a single LineSection in an SMAP, associated with
	* a particular stratum.
	*/
	static class LineInfo {
	private int inputStartLine = -1;
	private int outputStartLine = -1;
	private int lineFileID = 0;
	private int inputLineCount = 1;
	private int outputLineIncrement = 1;
	private boolean lineFileIDSet = false;

	public void setInputStartLine(int inputStartLine) {
	if (inputStartLine < 0) {
	throw new IllegalArgumentException(Localizer.getMessage(
	"jsp.error.negativeParameter", Integer.valueOf(inputStartLine)));
	}
	this.inputStartLine = inputStartLine;
	}

	public void setOutputStartLine(int outputStartLine) {
	if (outputStartLine < 0) {
	throw new IllegalArgumentException(Localizer.getMessage(
	"jsp.error.negativeParameter", Integer.valueOf(outputStartLine)));
	}
	this.outputStartLine = outputStartLine;
	}

	/**
	* Sets lineFileID. Should be called only when different from
	* that of prior LineInfo object (in any given context) or 0
	* if the current LineInfo has no (logical) predecessor.
	* <code>LineInfo</code> will print this file number no matter what.
	*
	* @param lineFileID The new line file ID
	*/
	public void setLineFileID(int lineFileID) {
	if (lineFileID < 0) {
	throw new IllegalArgumentException(Localizer.getMessage(
	"jsp.error.negativeParameter", Integer.valueOf(lineFileID)));
	}
	this.lineFileID = lineFileID;
	this.lineFileIDSet = true;
	}

	public void setInputLineCount(int inputLineCount) {
	if (inputLineCount < 0) {
	throw new IllegalArgumentException(Localizer.getMessage(
	"jsp.error.negativeParameter", Integer.valueOf(inputLineCount)));
	}
	this.inputLineCount = inputLineCount;
	}

	public void setOutputLineIncrement(int outputLineIncrement) {
	if (outputLineIncrement < 0) {
	throw new IllegalArgumentException(Localizer.getMessage(
	"jsp.error.negativeParameter", Integer.valueOf(outputLineIncrement)));
	}
	this.outputLineIncrement = outputLineIncrement;
	}

	public int getMaxOutputLineNumber() {
	return outputStartLine + inputLineCount * outputLineIncrement;
	}

	/**
	* @return the current LineInfo as a String, print all values only when
	* appropriate (but LineInfoID if and only if it's been
	* specified, as its necessity is sensitive to context).
	*/
	public String getString() {
	if (inputStartLine == -1 \|\| outputStartLine == -1) {
	throw new IllegalStateException();
	}
	StringBuilder out = new StringBuilder();
	out.append(inputStartLine);
	if (lineFileIDSet) {
	out.append("#" + lineFileID);
	}
	if (inputLineCount != 1) {
	out.append("," + inputLineCount);
	}
	out.append(":" + outputStartLine);
	if (outputLineIncrement != 1) {
	out.append("," + outputLineIncrement);
	}
	out.append('\n');
	return out.toString();
	}

	@Override
	public String toString() {
	return getString();
	}
	}

	//*********************************************************************
	// Private state

	private final List<String> fileNameList = new ArrayList<>();
	private final List<String> filePathList = new ArrayList<>();
	private final List<LineInfo> lineData = new ArrayList<>();
	private int lastFileID;
	// .java file
	private String outputFileName;
	// .class file
	private String classFileName;

	//*********************************************************************
	// Methods to add mapping information

	/**
	* Adds record of a new file, by filename.
	*
	* @param filename the filename to add, unqualified by path.
	*/
	public void addFile(String filename) {
	addFile(filename, filename);
	}

	/**
	* Adds record of a new file, by filename and path. The path
	* may be relative to a source compilation path.
	*
	* @param filename the filename to add, unqualified by path
	* @param filePath the path for the filename, potentially relative
	* to a source compilation path
	*/
	public void addFile(String filename, String filePath) {
	int pathIndex = filePathList.indexOf(filePath);
	if (pathIndex == -1) {
	fileNameList.add(filename);
	filePathList.add(filePath);
	}
	}

	/**
	* Combines consecutive LineInfos wherever possible
	*/
	public void optimizeLineSection() {

	/* Some debugging code
	for (int i = 0; i < lineData.size(); i++) {
	LineInfo li = (LineInfo)lineData.get(i);
	System.out.print(li.toString());
	}
	*/
	//Incorporate each LineInfo into the previous LineInfo's
	//outputLineIncrement, if possible
	int i = 0;
	while (i < lineData.size() - 1) {
	LineInfo li = lineData.get(i);
	LineInfo liNext = lineData.get(i + 1);
	if (!liNext.lineFileIDSet
	&& liNext.inputStartLine == li.inputStartLine
	&& liNext.inputLineCount == 1
	&& li.inputLineCount == 1
	&& liNext.outputStartLine
	== li.outputStartLine
	+ li.inputLineCount * li.outputLineIncrement) {
	li.setOutputLineIncrement(
	liNext.outputStartLine
	- li.outputStartLine
	+ liNext.outputLineIncrement);
	lineData.remove(i + 1);
	} else {
	i++;
	}
	}

	//Incorporate each LineInfo into the previous LineInfo's
	//inputLineCount, if possible
	i = 0;
	while (i < lineData.size() - 1) {
	LineInfo li = lineData.get(i);
	LineInfo liNext = lineData.get(i + 1);
	if (!liNext.lineFileIDSet
	&& liNext.inputStartLine == li.inputStartLine + li.inputLineCount
	&& liNext.outputLineIncrement == li.outputLineIncrement
	&& liNext.outputStartLine
	== li.outputStartLine
	+ li.inputLineCount * li.outputLineIncrement) {
	li.setInputLineCount(li.inputLineCount + liNext.inputLineCount);
	lineData.remove(i + 1);
	} else {
	i++;
	}
	}
	}

	/**
	* Adds complete information about a simple line mapping. Specify
	* all the fields in this method; the back-end machinery takes care
	* of printing only those that are necessary in the final SMAP.
	* (My view is that fields are optional primarily for spatial efficiency,
	* not for programmer convenience. Could always add utility methods
	* later.)
	*
	* @param inputStartLine starting line in the source file
	* (SMAP <code>InputStartLine</code>)
	* @param inputFileName the filepath (or name) from which the input comes
	* (yields SMAP <code>LineFileID</code>) Use unqualified names
	* carefully, and only when they uniquely identify a file.
	* @param inputLineCount the number of lines in the input to map
	* (SMAP <code>LineFileCount</code>)
	* @param outputStartLine starting line in the output file
	* (SMAP <code>OutputStartLine</code>)
	* @param outputLineIncrement number of output lines to map to each
	* input line (SMAP <code>OutputLineIncrement</code>). <i>Given the
	* fact that the name starts with "output", I continuously have
	* the subconscious urge to call this field
	* <code>OutputLineExcrement</code>.</i>
	*/
	public void addLineData(
	int inputStartLine,
	String inputFileName,
	int inputLineCount,
	int outputStartLine,
	int outputLineIncrement) {
	// check the input - what are you doing here??
	int fileIndex = filePathList.indexOf(inputFileName);
	if (fileIndex == -1) {
	throw new IllegalArgumentException(
	"inputFileName: " + inputFileName);
	}

	//Jasper incorrectly SMAPs certain Nodes, giving them an
	//outputStartLine of 0. This can cause a fatal error in
	//optimizeLineSection, making it impossible for Jasper to
	//compile the JSP. Until we can fix the underlying
	//SMAPping problem, we simply ignore the flawed SMAP entries.
	if (outputStartLine == 0) {
	return;
	}

	// build the LineInfo
	LineInfo li = new LineInfo();
	li.setInputStartLine(inputStartLine);
	li.setInputLineCount(inputLineCount);
	li.setOutputStartLine(outputStartLine);
	li.setOutputLineIncrement(outputLineIncrement);
	if (fileIndex != lastFileID) {
	li.setLineFileID(fileIndex);
	}
	lastFileID = fileIndex;

	// save it
	lineData.add(li);
	}


	public void addLineInfo(LineInfo li) {
	lineData.add(li);
	}


	public void setOutputFileName(String outputFileName) {
	this.outputFileName = outputFileName;
	}


	public void setClassFileName(String classFileName) {
	this.classFileName = classFileName;
	}


	public String getClassFileName() {
	return classFileName;
	}


	//*********************************************************************
	// Methods to retrieve information

	@Override
	public String toString() {
	return getSmapStringInternal();
	}


	public String getSmapString() {

	if (outputFileName == null) {
	throw new IllegalStateException();
	}

	return getSmapStringInternal();
	}


	private String getSmapStringInternal() {
	StringBuilder out = new StringBuilder();

	// start the SMAP
	out.append("SMAP\n");
	out.append(outputFileName + '\n');
	out.append("JSP\n");

	// print StratumSection
	out.append("*S JSP\n");

	// print FileSection
	out.append("*F\n");
	int bound = fileNameList.size();
	for (int i = 0; i < bound; i++) {
	if (filePathList.get(i) != null) {
	out.append("+ " + i + " " + fileNameList.get(i) + "\n");
	// Source paths must be relative, not absolute, so we
	// remove the leading "/", if one exists.
	String filePath = filePathList.get(i);
	if (filePath.startsWith("/")) {
	filePath = filePath.substring(1);
	}
	out.append(filePath + "\n");
	} else {
	out.append(i + " " + fileNameList.get(i) + "\n");
	}
	}

	// print LineSection
	out.append("*L\n");
	bound = lineData.size();
	for (int i = 0; i < bound; i++) {
	LineInfo li = lineData.get(i);
	out.append(li.getString());
	}

	// end the SMAP
	out.append("*E\n");

	return out.toString();
	}


	public SmapInput getInputLineNumber(int outputLineNumber) {
	// For a given Java line number, provide the associated line number
	// in the JSP/tag source
	int inputLineNumber = -1;
	int fileId = 0;

	for (LineInfo lineInfo : lineData) {
	if (lineInfo.lineFileIDSet) {
	fileId = lineInfo.lineFileID;
	}
	if (lineInfo.outputStartLine > outputLineNumber) {
	// Didn't find match
	break;
	}

	if (lineInfo.getMaxOutputLineNumber() < outputLineNumber) {
	// Too early
	continue;
	}

	// This is the match
	int inputOffset =
	(outputLineNumber - lineInfo.outputStartLine) / lineInfo.outputLineIncrement;

	inputLineNumber = lineInfo.inputStartLine + inputOffset;
	}

	return new SmapInput(filePathList.get(fileId), inputLineNumber);
	}
	}