Coverage Report

Coverage Report - org.apache.torque.engine.sql.SQLScanner

Classes in this File

Line Coverage

Branch Coverage

Complexity

SQLScanner

0/78

0/60

5.143

 package org.apache.torque.engine.sql;
 
 /*
  * 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.
  */
 
 import java.io.IOException;
 import java.io.Reader;
 import java.util.List;
 import java.util.ArrayList;
 
 /**
  * A simple Scanner implementation that scans an
  * sql file into usable tokens.  Used by SQLToAppData.
  *
  * @author <a href="mailto:leon@opticode.co.za">Leon Messerschmidt</a>
  * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
  * @author <a href="mailto:andyhot@di.uoa.gr">Andreas Andreou</a>
  * @version $Id: SQLScanner.java,v 1.1 2007-10-21 07:57:27 abyrne Exp $
  */
 public class SQLScanner
 {
     /** white spaces */
     private static final String WHITE = "\f\r\t\n ";
     /** alphabetic characters */
     private static final String ALFA
             = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
     /** numbers */
     private static final String NUMER = "0123456789";
     /** alphanumeric */
     private static final String ALFANUM = ALFA + NUMER;
     /** special characters */
     private static final String SPECIAL = ";(),'";
     /** comment */
     private static final char COMMENT_POUND = '#';
     /** comment */
     private static final char COMMENT_SLASH = '/';
     /** comment */
     private static final char COMMENT_STAR = '*';
     /** comment */
     private static final char COMMENT_DASH = '-';
 
     /** the input reader */
     private Reader in;
     /** character */
     private int chr;
     /** token */
     private String token;
     /** list of tokens */
     private List tokens;
     /** line */
     private int line;
     /** column */
     private int col;
 
     /**
      * Creates a new scanner with no Reader
      */
     public SQLScanner()
     {
         this(null);
     }
 
     /**
      * Creates a new scanner with an Input Reader
      *
      * @param input the input reader
      */
     public SQLScanner(Reader input)
     {
         setInput(input);
     }
 
     /**
      * Set the Input
      *
      * @param input the input reader
      */
     public void setInput(Reader input)
     {
         in = input;
     }
 
 
     /**
      * Reads the next character and increments the line and column counters.
      *
      * @throws IOException If an I/O error occurs
      */
     private void readChar() throws IOException
     {
         boolean wasLine = (char) chr == '\r';
         chr = in.read();
         if ((char) chr == '\n' || (char) chr == '\r' || (char) chr == '\f')
         {
             col = 0;
             if (!wasLine || (char) chr != '\n')
             {
                 line++;
             }
         }
         else
         {
             col++;
         }
     }
 
     /**
      * Scans an identifier.
      *
      * @throws IOException If an I/O error occurs
      */
     private void scanIdentifier () throws IOException
     {
         token = "";
         char c = (char) chr;
         while (chr != -1 && WHITE.indexOf(c) == -1 && SPECIAL.indexOf(c) == -1)
         {
             token = token + (char) chr;
             readChar();
             c = (char) chr;
         }
         int start = col - token.length();
         tokens.add(new Token(token, line, start));
     }
 
     /**
      * Scans an identifier which had started with the negative sign.
      *
      * @throws IOException If an I/O error occurs
      */
     private void scanNegativeIdentifier () throws IOException
     {
         token = "-";
         char c = (char) chr;
         while (chr != -1 && WHITE.indexOf(c) == -1 && SPECIAL.indexOf(c) == -1)
         {
             token = token + (char) chr;
             readChar();
             c = (char) chr;
         }
         int start = col - token.length();
         tokens.add(new Token(token, line, start));
     }
 
     /**
      * Scan the input Reader and returns a list of tokens.
      *
      * @return a list of tokens
      * @throws IOException If an I/O error occurs
      */
     public List scan () throws IOException
     {
         line = 1;
         col = 0;
         boolean inComment = false;
         boolean inCommentSlashStar = false;
         boolean inCommentDash = false;
 
         boolean inNegative;
 
         tokens = new ArrayList();
         readChar();
         while (chr != -1)
         {
             char c = (char) chr;
             inNegative = false;
 
             if (c == COMMENT_DASH)
             {
                 readChar();
                 if ((char) chr == COMMENT_DASH)
                 {
                     inCommentDash = true;
                 }
                 else
                 {
                     inNegative = true;
                     c = (char) chr;
                 }
             }
 
             if (inCommentDash)
             {
                 if (c == '\n' || c == '\r')
                 {
                     inCommentDash = false;
                 }
                 readChar();
             }
             else if (c == COMMENT_POUND)
             {
                 inComment = true;
                 readChar();
             }
             else if (c == COMMENT_SLASH)
             {
                 readChar();
                 if ((char) chr == COMMENT_STAR)
                 {
                     inCommentSlashStar = true;
                 }
             }
             else if (inComment || inCommentSlashStar)
             {
                 if (c == '*')
                 {
                     readChar();
                     if ((char) chr == COMMENT_SLASH)
                     {
                         inCommentSlashStar = false;
                     }
                 }
                 else if (c == '\n' || c == '\r')
                 {
                     inComment = false;
                 }
                 readChar();
             }
             else if (ALFANUM.indexOf(c) >= 0)
             {
                 if (inNegative)
                 {
                     scanNegativeIdentifier();
                 }
                 else
                 {
                     scanIdentifier();
                 }
             }
             else if (SPECIAL.indexOf(c) >= 0)
             {
                 tokens.add(new Token("" + c, line, col));
                 readChar();
             }
             else
             {
                 readChar();
             }
         }
         return tokens;
     }
 }

1		package org.apache.torque.engine.sql;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		import java.io.IOException;
23		import java.io.Reader;
24		import java.util.List;
25		import java.util.ArrayList;
26
27		/**
28		* A simple Scanner implementation that scans an
29		* sql file into usable tokens. Used by SQLToAppData.
30		*
31		* @author <a href="mailto:leon@opticode.co.za">Leon Messerschmidt</a>
32		* @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
33		* @author <a href="mailto:andyhot@di.uoa.gr">Andreas Andreou</a>
34		* @version $Id: SQLScanner.java,v 1.1 2007-10-21 07:57:27 abyrne Exp $
35		*/
36		public class SQLScanner
37		{
38		/** white spaces */
39		private static final String WHITE = "\f\r\t\n ";
40		/** alphabetic characters */
41		private static final String ALFA
42		= "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
43		/** numbers */
44		private static final String NUMER = "0123456789";
45		/** alphanumeric */
46		private static final String ALFANUM = ALFA + NUMER;
47		/** special characters */
48		private static final String SPECIAL = ";(),'";
49		/** comment */
50		private static final char COMMENT_POUND = '#';
51		/** comment */
52		private static final char COMMENT_SLASH = '/';
53		/** comment */
54		private static final char COMMENT_STAR = '*';
55		/** comment */
56		private static final char COMMENT_DASH = '-';
57
58		/** the input reader */
59		private Reader in;
60		/** character */
61		private int chr;
62		/** token */
63		private String token;
64		/** list of tokens */
65		private List tokens;
66		/** line */
67		private int line;
68		/** column */
69		private int col;
70
71		/**
72		* Creates a new scanner with no Reader
73		*/
74		public SQLScanner()
75		{
76	0	this(null);
77	0	}
78
79		/**
80		* Creates a new scanner with an Input Reader
81		*
82		* @param input the input reader
83		*/
84		public SQLScanner(Reader input)
85	0	{
86	0	setInput(input);
87	0	}
88
89		/**
90		* Set the Input
91		*
92		* @param input the input reader
93		*/
94		public void setInput(Reader input)
95		{
96	0	in = input;
97	0	}
98
99
100		/**
101		* Reads the next character and increments the line and column counters.
102		*
103		* @throws IOException If an I/O error occurs
104		*/
105		private void readChar() throws IOException
106		{
107	0	boolean wasLine = (char) chr == '\r';
108	0	chr = in.read();
109	0	if ((char) chr == '\n' \|\| (char) chr == '\r' \|\| (char) chr == '\f')
110		{
111	0	col = 0;
112	0	if (!wasLine \|\| (char) chr != '\n')
113		{
114	0	line++;
115		}
116		}
117		else
118		{
119	0	col++;
120		}
121	0	}
122
123		/**
124		* Scans an identifier.
125		*
126		* @throws IOException If an I/O error occurs
127		*/
128		private void scanIdentifier () throws IOException
129		{
130	0	token = "";
131	0	char c = (char) chr;
132	0	while (chr != -1 && WHITE.indexOf(c) == -1 && SPECIAL.indexOf(c) == -1)
133		{
134	0	token = token + (char) chr;
135	0	readChar();
136	0	c = (char) chr;
137		}
138	0	int start = col - token.length();
139	0	tokens.add(new Token(token, line, start));
140	0	}
141
142		/**
143		* Scans an identifier which had started with the negative sign.
144		*
145		* @throws IOException If an I/O error occurs
146		*/
147		private void scanNegativeIdentifier () throws IOException
148		{
149	0	token = "-";
150	0	char c = (char) chr;
151	0	while (chr != -1 && WHITE.indexOf(c) == -1 && SPECIAL.indexOf(c) == -1)
152		{
153	0	token = token + (char) chr;
154	0	readChar();
155	0	c = (char) chr;
156		}
157	0	int start = col - token.length();
158	0	tokens.add(new Token(token, line, start));
159	0	}
160
161		/**
162		* Scan the input Reader and returns a list of tokens.
163		*
164		* @return a list of tokens
165		* @throws IOException If an I/O error occurs
166		*/
167		public List scan () throws IOException
168		{
169	0	line = 1;
170	0	col = 0;
171	0	boolean inComment = false;
172	0	boolean inCommentSlashStar = false;
173	0	boolean inCommentDash = false;
174
175		boolean inNegative;
176
177	0	tokens = new ArrayList();
178	0	readChar();
179	0	while (chr != -1)
180		{
181	0	char c = (char) chr;
182	0	inNegative = false;
183
184	0	if (c == COMMENT_DASH)
185		{
186	0	readChar();
187	0	if ((char) chr == COMMENT_DASH)
188		{
189	0	inCommentDash = true;
190		}
191		else
192		{
193	0	inNegative = true;
194	0	c = (char) chr;
195		}
196		}
197
198	0	if (inCommentDash)
199		{
200	0	if (c == '\n' \|\| c == '\r')
201		{
202	0	inCommentDash = false;
203		}
204	0	readChar();
205		}
206	0	else if (c == COMMENT_POUND)
207		{
208	0	inComment = true;
209	0	readChar();
210		}
211	0	else if (c == COMMENT_SLASH)
212		{
213	0	readChar();
214	0	if ((char) chr == COMMENT_STAR)
215		{
216	0	inCommentSlashStar = true;
217		}
218		}
219	0	else if (inComment \|\| inCommentSlashStar)
220		{
221	0	if (c == '*')
222		{
223	0	readChar();
224	0	if ((char) chr == COMMENT_SLASH)
225		{
226	0	inCommentSlashStar = false;
227		}
228		}
229	0	else if (c == '\n' \|\| c == '\r')
230		{
231	0	inComment = false;
232		}
233	0	readChar();
234		}
235	0	else if (ALFANUM.indexOf(c) >= 0)
236		{
237	0	if (inNegative)
238		{
239	0	scanNegativeIdentifier();
240		}
241		else
242		{
243	0	scanIdentifier();
244		}
245		}
246	0	else if (SPECIAL.indexOf(c) >= 0)
247		{
248	0	tokens.add(new Token("" + c, line, col));
249	0	readChar();
250		}
251		else
252		{
253	0	readChar();
254		}
255	0	}
256	0	return tokens;
257		}
258		}