graveyard/tools/org/apache/axis/tools/common/InputCppSourceCode.java - axis-axis1-c - Git at Google

 /*
  *   Copyright 2003-2004 The Apache Software Foundation.
 // (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved
  *
  *   Licensed 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.axis.tools.common;
 import java.io.BufferedReader;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.StringTokenizer;

 public class InputCppSourceCode {

 	private ArrayList parts = new ArrayList();
 	private String name;

 	public InputCppSourceCode(BufferedReader br, String name) throws Exception {
 		this.name = name;

 		String s = null;
 		StringBuffer buff = new StringBuffer();
 		for (int i = 1;; i++) {
 			try {
 				s = br.readLine();
 			} catch (Exception e) {
 				System.err.println(
 					"Ignoring exception thrown parsing file "
 						+ name
 						+ " line number "
 						+ i);
 				e.printStackTrace();
 				break;
 			}
 			if (s == null)
 				break;
 			buff.append(s + "\n");
 		}
 		String str = buff.toString();

 		// TODO: When checking for rest.startsWith("struct") should
 		// check the next letter after struct is not alphanumeric otherwise
 		// we'll get false matches on a function called structify() for
 		// instance. Also applies to enum, union, public, typedef, etc

 		String rest, text = "";
 		int scopedepth = 0;
 		String scope = "public";
 		String currentClass = null;
 		for (int idx = 0; idx < str.length(); /* No idx++ */
 			) {
 			rest = str.substring(idx);
 			if (Character.isWhitespace(rest.charAt(0))) {
 				int ridx = 0;
 				while (ridx < rest.length()
 					&& Character.isWhitespace(rest.charAt(ridx)))
 					ridx++;
 				text = rest.substring(0, ridx);
 				FilePart fp = new FilePart(text, FilePart.WHITESPACE);
 				parts.add(fp);
 				idx += ridx;

 			} else if (rest.startsWith("/*")) {
 				int ridx = rest.indexOf("*/"); // Don't use Utils here
 				text = str.substring(idx, idx + ridx + 2);
 				FilePart fp = new FilePart(text, FilePart.COMMENT);
 				parts.add(fp);
 				idx += text.length();

 			} else if (rest.startsWith("//")) {
 				text = str.substring(idx, idx + rest.indexOf("\n"));
 				FilePart fp = new FilePart(text, FilePart.COMMENT);
 				parts.add(fp);
 				idx += text.length();

 			} else if (rest.startsWith("#")) {
 				int ridx = rest.indexOf("\n");
 				char c = rest.charAt(ridx - 1);
 				while (-1 != ridx && '\\' == c) {
 					String rest2 = rest.substring(ridx + 1);
 					ridx += rest2.indexOf("\n") + 1;
 					c = rest.charAt(ridx - 1);
 				}
 				text = str.substring(idx, idx + ridx);
 				FilePart fp = new FilePart(text, FilePart.DIRECTIVE);
 				parts.add(fp);
 				idx += text.length();

 			} else if (rest.startsWith("}")) {
 				if (scopedepth <= 0)
 					Utils.rude(
 						"Braces do not match",
 						name,
 						lineNo(str, idx),
 						rest.substring(0, rest.indexOf("\n")));
 				else
 					scopedepth--;
 				// TODO: better checking that this brace really ends the class
 				if (0 == scopedepth)
 					currentClass = null;
 				scope = "public";
 				parts.add(new FilePart("}", FilePart.ENDSCOPE));
 				idx++;

 			} else if (rest.startsWith(";")) {
 				parts.add(new FilePart(";", FilePart.FIELD));
 				idx++;

 			} else if (
 				!Character.isLetter(rest.charAt(0))
 					&& '~' != rest.charAt(0)
 					&& '_' != rest.charAt(0)) {
 				Utils.rude(
 					"Lines must start with a letter ",
 					name,
 					lineNo(str, idx),
 					rest.substring(0, rest.indexOf("\n")));

 			} else if (MacroPart.isAMacro(rest)) {
 				MacroPart mp = MacroPart.create(rest);
 				parts.add(mp);
 				idx += mp.length();

 			} else if (beginsScope(rest)) {
 				scopedepth++;
 				text = rest.substring(0, Utils.indexOf(rest, "{") + 1);
 				FilePart fp = new FilePart(text, FilePart.BEGINSCOPE);
 				parts.add(fp);
 				idx += text.length();
 				if (Utils.startsWith(text, "class")) {
 					// TODO: cope with comments here
 					// TODO: split out classes into a ClassPart
 					StringTokenizer st =
 						new StringTokenizer(text, Utils.whitespace + ":");
 					st.nextToken(); // step over "class"
 					while (st.hasMoreTokens()) {
 						String word = st.nextToken();
 						if (Configuration.isAttribute(word))
 							continue;
 						currentClass = word;
 						break;
 					}
 				}

 			} else if (isEnumOrUnion(rest)) {
 				int ridx = Utils.findMatching(rest, '{', '}') + 1;
 				String rest2 = rest.substring(ridx);
 				ridx = idx + ridx + Utils.indexOf(rest2, ';') + 1;
 				text = str.substring(idx, ridx);
 				FilePart fp = new FilePart(text, FilePart.ENUM);
 				parts.add(fp);
 				idx += text.length();

 			} else if (
 				scopedepth > 0
 					&& (rest.startsWith("public")
 						|| rest.startsWith("protected")
 						|| rest.startsWith("private"))) {
 				int colon = rest.indexOf(":");
 				if (-1 == colon)
 					Utils.rude(
 						"No colon found after public or private ",
 						name,
 						lineNo(str, idx),
 						rest.substring(0, rest.indexOf("\n")));
 			    scope = str.substring(idx, idx + colon);
 				text = str.substring(idx, idx + colon + 1);
 				FilePart fp = new FilePart(text, FilePart.CLASSATTRIBUTE);
 				parts.add(fp);
 				idx += text.length();

 			} else if (Utils.startsWith(rest, "typedef")) {
 				int semicolon = Utils.indexOf(rest, ';');
 				int brace = Utils.indexOf(rest, '{');

 				if (-1 == semicolon)
 					Utils.rude(
 						"No semicolon found after typedef",
 						name,
 						lineNo(str, idx),
 						rest.substring(0, rest.indexOf("\n")));

 				if (-1 == brace || semicolon < brace) {
 					// Simple typedef
 					text = str.substring(idx, idx + semicolon + 1);
 				} else {
 					// Typedef of a struct, etc
 					int endbrace = Utils.findMatching(rest, '{', '}');
 					String rest2 = rest.substring(endbrace);
 					semicolon = Utils.indexOf(rest2, ';');
 					text = str.substring(idx, idx + endbrace + semicolon + 1);
 				}
 				FilePart fp = new FilePart(text, FilePart.TYPEDEF);
 				parts.add(fp);
 				idx += text.length();

 			} else {
 				if (isMethod(rest)) {

 					int brace = Utils.indexOf(rest, '{');
 					Signature signature =
 						new Signature(str.substring(idx, idx + brace));
 					if (signature.failed())
 						Utils.rude(
 							"Signature parsing failed",
 							name,
 							lineNo(str, idx),
 							signature.getOriginal());
 					if (null != currentClass
 						&& null == signature.getClassName())
 						signature.setClassName(currentClass);
 				    signature.setScope(scope);

 					String body = rest.substring(brace);
 					int endBrace = Utils.findMatching(body, '{', '}');
 					body = body.substring(0, endBrace + 1);
 					int endIdx =
 						idx + signature.originalLength() + body.length();
 					text = str.substring(idx, endIdx);
 					MethodPart mp =
 						new MethodPart(text, signature, body);
 					parts.add(mp);
 					idx += text.length();

 				} else if (isField(rest)) {
 					int semicolon = Utils.indexOf(rest, ';');
 					text = str.substring(idx, idx + semicolon + 1);
 					FilePart fp = new FilePart(text, FilePart.FIELD);
 					parts.add(fp);
 					idx += text.length();

 				} else if (isPrototype(rest)) {
 					int semicolon = Utils.indexOf(rest, ';');
 					text = str.substring(idx, idx + semicolon + 1);
 					PrototypePart pp = new PrototypePart(text, currentClass);
 					pp.setScope(scope);
 					parts.add(pp);
 					idx += text.length();

 				} else {
 					//TODO other file parts here - not sure if there are any others?
 					Utils.rude(
 						"Unrecognised file part",
 						name,
 						lineNo(str, idx),
 						rest.substring(0, rest.indexOf("\n")));
 				} // end if
 			} // end if
 		} // end for
 	}

 	public Iterator getPartIterator() {
 		return parts.iterator();
 	}

 	private int lineNo(String s, int idx) {
 		int n = 0;
 		for (int i = 0; i < idx && i < s.length(); i++)
 			if ('\n' == s.charAt(i))
 				n++;
 		return n;
 	}

 	/**
 	 * Find out whether we are defining a class, struct or extern "C" which
 	 * may contain function implementations. These will have braces which
 	 * begin a new scope. Ignore function prototypes that return a struct.
 	 * struct mystr { int f1; };
 	 * struct mystr func();
 	 * struct mystr func() { struct mystr a; return a; }
 	 */
 	private static boolean beginsScope(String s) throws ParsingException {
 		if (isMethod(s))
 			return false;

 		int brace = Utils.indexOf(s, '{');
 		int semicolon = Utils.indexOf(s, ';');

 		// Return false for class prototypes, but true for class definitions.
 		if (Utils.startsWith(s, "class")) {
 			if (-1 == brace)
 				return false;
 			if (-1 == semicolon)
 				return true;
 			return brace < semicolon;
 		}

 		if (Utils.startsWith(s, "struct")) {
 			if (-1 == brace || -1 == semicolon)
 				return false;
 			return brace < semicolon;
 		}
 		return startsWithExternScope(s);
 	}

 	/**
 	 * There are 4 types of extern ...
 	 * extern int field;
 	 * extern int func();
 	 * extern "C" int func() { return 2; }
 	 * extern "C" { int func() { return 2; } }
 	 * This method should return true only for the last of these three
 	 * examples since only the last one creates a new scope using braces.
 	 */
 	private static boolean startsWithExternScope(String s)
 		throws ParsingException {
 		if (!s.startsWith("extern"))
 			return false;

 		int brace = Utils.indexOf(s, '{');
 		int semicolon = Utils.indexOf(s, ';');
 		int bracket = Utils.indexOf(s, '(');

 		if (-1 == brace)
 			return false;
 		return (-1 == semicolon || brace < semicolon)
 			&& (-1 == bracket || brace < bracket);
 	}

 	/**
 	 * Find out whether we are defining an enum or union which will contain
 	 * braces. Ignore function prototypes that return an enum or union.
 	 * enum colour { red, blue };
 	 * enum colour func();
 	 * enum colour func() { return colour.red; }
 	 */
 	private static boolean isEnumOrUnion(String s) throws ParsingException {
 		if ((!Utils.startsWith(s, "enum") && !Utils.startsWith(s, "union"))
 			|| isMethod(s))
 			return false;

 		int brace = Utils.indexOf(s, '{');
 		int semicolon = Utils.indexOf(s, ';');
 		return -1 != brace && (-1 == semicolon || brace < semicolon);
 	}

 	/**
 	 * Rules to recognise fields and methods...
 		 *
 		 * Fields must contain a semicolon
 	 * Methods may or may not contain a semicolon
 	 * Prototypes must contain a semicolon
 	 * Fields may or may not contain a brace (array initialisers do)
 	 * Methods must contain a brace
 	 * Prototypes must not contain a brace
 	 * Fields may or may not contain a bracket (casts do)
 	 * Methods must contain a bracket
 	 * Prototypes must contain a bracket
 	 *
 	 * It's a method if it contains a bracket and then a brace
 	 * before the first semicolon (if there is a semicolon).
 	 * It's a prototype if it's not a method and it contains brackets before a semicolon.
 	 * It's a field if it's not a method or a prototype and it contains a semicolon.
 	 * If it's not a field, a method or a prototype and we haven't recognised it
 	 * previously then it's an error.
 	 */
 	private static boolean isMethod(String s) throws ParsingException {
 		int semicolon = Utils.indexOf(s, ';');
 		int brace = Utils.indexOf(s, '{');
 		int bracket = Utils.indexOf(s, '(');

 		return (
 			-1 != bracket
 				&& -1 != brace
 				&& bracket < brace
 				&& (-1 == semicolon || brace < semicolon));
 	}

 	private static boolean isPrototype(String s) throws ParsingException {
 		int semicolon = Utils.indexOf(s, ';');
 		int bracket = Utils.indexOf(s, '(');
 		return !isMethod(s)
 			&& -1 != semicolon
 			&& -1 != bracket
 			&& bracket < semicolon;
 	}

 	private static boolean isField(String s) throws ParsingException {
 		int semicolon = Utils.indexOf(s, ';');
 		return !isMethod(s) && !isPrototype(s) && -1 != semicolon;
 	}

 	public String getName() {
 		return name;
 	}

 	public String toString() {
 		StringBuffer text = new StringBuffer();
 		for (int i = 0; i < parts.size(); i++) {
 			text.append(((FilePart) (parts.get(i))).toString());
 		}
 		return text.toString();
 	}

 }
	/*
	* Copyright 2003-2004 The Apache Software Foundation.
	// (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved
	*
	* Licensed 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.axis.tools.common;
	import java.io.BufferedReader;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.StringTokenizer;

	public class InputCppSourceCode {

	private ArrayList parts = new ArrayList();
	private String name;

	public InputCppSourceCode(BufferedReader br, String name) throws Exception {
	this.name = name;

	String s = null;
	StringBuffer buff = new StringBuffer();
	for (int i = 1;; i++) {
	try {
	s = br.readLine();
	} catch (Exception e) {
	System.err.println(
	"Ignoring exception thrown parsing file "
	+ name
	+ " line number "
	+ i);
	e.printStackTrace();
	break;
	}
	if (s == null)
	break;
	buff.append(s + "\n");
	}
	String str = buff.toString();

	// TODO: When checking for rest.startsWith("struct") should
	// check the next letter after struct is not alphanumeric otherwise
	// we'll get false matches on a function called structify() for
	// instance. Also applies to enum, union, public, typedef, etc

	String rest, text = "";
	int scopedepth = 0;
	String scope = "public";
	String currentClass = null;
	for (int idx = 0; idx < str.length(); /* No idx++ */
	) {
	rest = str.substring(idx);
	if (Character.isWhitespace(rest.charAt(0))) {
	int ridx = 0;
	while (ridx < rest.length()
	&& Character.isWhitespace(rest.charAt(ridx)))
	ridx++;
	text = rest.substring(0, ridx);
	FilePart fp = new FilePart(text, FilePart.WHITESPACE);
	parts.add(fp);
	idx += ridx;

	} else if (rest.startsWith("/*")) {
	int ridx = rest.indexOf("*/"); // Don't use Utils here
	text = str.substring(idx, idx + ridx + 2);
	FilePart fp = new FilePart(text, FilePart.COMMENT);
	parts.add(fp);
	idx += text.length();

	} else if (rest.startsWith("//")) {
	text = str.substring(idx, idx + rest.indexOf("\n"));
	FilePart fp = new FilePart(text, FilePart.COMMENT);
	parts.add(fp);
	idx += text.length();

	} else if (rest.startsWith("#")) {
	int ridx = rest.indexOf("\n");
	char c = rest.charAt(ridx - 1);
	while (-1 != ridx && '\\' == c) {
	String rest2 = rest.substring(ridx + 1);
	ridx += rest2.indexOf("\n") + 1;
	c = rest.charAt(ridx - 1);
	}
	text = str.substring(idx, idx + ridx);
	FilePart fp = new FilePart(text, FilePart.DIRECTIVE);
	parts.add(fp);
	idx += text.length();

	} else if (rest.startsWith("}")) {
	if (scopedepth <= 0)
	Utils.rude(
	"Braces do not match",
	name,
	lineNo(str, idx),
	rest.substring(0, rest.indexOf("\n")));
	else
	scopedepth--;
	// TODO: better checking that this brace really ends the class
	if (0 == scopedepth)
	currentClass = null;
	scope = "public";
	parts.add(new FilePart("}", FilePart.ENDSCOPE));
	idx++;

	} else if (rest.startsWith(";")) {
	parts.add(new FilePart(";", FilePart.FIELD));
	idx++;

	} else if (
	!Character.isLetter(rest.charAt(0))
	&& '~' != rest.charAt(0)
	&& '_' != rest.charAt(0)) {
	Utils.rude(
	"Lines must start with a letter ",
	name,
	lineNo(str, idx),
	rest.substring(0, rest.indexOf("\n")));

	} else if (MacroPart.isAMacro(rest)) {
	MacroPart mp = MacroPart.create(rest);
	parts.add(mp);
	idx += mp.length();

	} else if (beginsScope(rest)) {
	scopedepth++;
	text = rest.substring(0, Utils.indexOf(rest, "{") + 1);
	FilePart fp = new FilePart(text, FilePart.BEGINSCOPE);
	parts.add(fp);
	idx += text.length();
	if (Utils.startsWith(text, "class")) {
	// TODO: cope with comments here
	// TODO: split out classes into a ClassPart
	StringTokenizer st =
	new StringTokenizer(text, Utils.whitespace + ":");
	st.nextToken(); // step over "class"
	while (st.hasMoreTokens()) {
	String word = st.nextToken();
	if (Configuration.isAttribute(word))
	continue;
	currentClass = word;
	break;
	}
	}

	} else if (isEnumOrUnion(rest)) {
	int ridx = Utils.findMatching(rest, '{', '}') + 1;
	String rest2 = rest.substring(ridx);
	ridx = idx + ridx + Utils.indexOf(rest2, ';') + 1;
	text = str.substring(idx, ridx);
	FilePart fp = new FilePart(text, FilePart.ENUM);
	parts.add(fp);
	idx += text.length();

	} else if (
	scopedepth > 0
	&& (rest.startsWith("public")
	\|\| rest.startsWith("protected")
	\|\| rest.startsWith("private"))) {
	int colon = rest.indexOf(":");
	if (-1 == colon)
	Utils.rude(
	"No colon found after public or private ",
	name,
	lineNo(str, idx),
	rest.substring(0, rest.indexOf("\n")));
	scope = str.substring(idx, idx + colon);
	text = str.substring(idx, idx + colon + 1);
	FilePart fp = new FilePart(text, FilePart.CLASSATTRIBUTE);
	parts.add(fp);
	idx += text.length();

	} else if (Utils.startsWith(rest, "typedef")) {
	int semicolon = Utils.indexOf(rest, ';');
	int brace = Utils.indexOf(rest, '{');

	if (-1 == semicolon)
	Utils.rude(
	"No semicolon found after typedef",
	name,
	lineNo(str, idx),
	rest.substring(0, rest.indexOf("\n")));

	if (-1 == brace \|\| semicolon < brace) {
	// Simple typedef
	text = str.substring(idx, idx + semicolon + 1);
	} else {
	// Typedef of a struct, etc
	int endbrace = Utils.findMatching(rest, '{', '}');
	String rest2 = rest.substring(endbrace);
	semicolon = Utils.indexOf(rest2, ';');
	text = str.substring(idx, idx + endbrace + semicolon + 1);
	}
	FilePart fp = new FilePart(text, FilePart.TYPEDEF);
	parts.add(fp);
	idx += text.length();

	} else {
	if (isMethod(rest)) {

	int brace = Utils.indexOf(rest, '{');
	Signature signature =
	new Signature(str.substring(idx, idx + brace));
	if (signature.failed())
	Utils.rude(
	"Signature parsing failed",
	name,
	lineNo(str, idx),
	signature.getOriginal());
	if (null != currentClass
	&& null == signature.getClassName())
	signature.setClassName(currentClass);
	signature.setScope(scope);

	String body = rest.substring(brace);
	int endBrace = Utils.findMatching(body, '{', '}');
	body = body.substring(0, endBrace + 1);
	int endIdx =
	idx + signature.originalLength() + body.length();
	text = str.substring(idx, endIdx);
	MethodPart mp =
	new MethodPart(text, signature, body);
	parts.add(mp);
	idx += text.length();

	} else if (isField(rest)) {
	int semicolon = Utils.indexOf(rest, ';');
	text = str.substring(idx, idx + semicolon + 1);
	FilePart fp = new FilePart(text, FilePart.FIELD);
	parts.add(fp);
	idx += text.length();

	} else if (isPrototype(rest)) {
	int semicolon = Utils.indexOf(rest, ';');
	text = str.substring(idx, idx + semicolon + 1);
	PrototypePart pp = new PrototypePart(text, currentClass);
	pp.setScope(scope);
	parts.add(pp);
	idx += text.length();

	} else {
	//TODO other file parts here - not sure if there are any others?
	Utils.rude(
	"Unrecognised file part",
	name,
	lineNo(str, idx),
	rest.substring(0, rest.indexOf("\n")));
	} // end if
	} // end if
	} // end for
	}

	public Iterator getPartIterator() {
	return parts.iterator();
	}

	private int lineNo(String s, int idx) {
	int n = 0;
	for (int i = 0; i < idx && i < s.length(); i++)
	if ('\n' == s.charAt(i))
	n++;
	return n;
	}

	/**
	* Find out whether we are defining a class, struct or extern "C" which
	* may contain function implementations. These will have braces which
	* begin a new scope. Ignore function prototypes that return a struct.
	* struct mystr { int f1; };
	* struct mystr func();
	* struct mystr func() { struct mystr a; return a; }
	*/
	private static boolean beginsScope(String s) throws ParsingException {
	if (isMethod(s))
	return false;

	int brace = Utils.indexOf(s, '{');
	int semicolon = Utils.indexOf(s, ';');

	// Return false for class prototypes, but true for class definitions.
	if (Utils.startsWith(s, "class")) {
	if (-1 == brace)
	return false;
	if (-1 == semicolon)
	return true;
	return brace < semicolon;
	}

	if (Utils.startsWith(s, "struct")) {
	if (-1 == brace \|\| -1 == semicolon)
	return false;
	return brace < semicolon;
	}
	return startsWithExternScope(s);
	}

	/**
	* There are 4 types of extern ...
	* extern int field;
	* extern int func();
	* extern "C" int func() { return 2; }
	* extern "C" { int func() { return 2; } }
	* This method should return true only for the last of these three
	* examples since only the last one creates a new scope using braces.
	*/
	private static boolean startsWithExternScope(String s)
	throws ParsingException {
	if (!s.startsWith("extern"))
	return false;

	int brace = Utils.indexOf(s, '{');
	int semicolon = Utils.indexOf(s, ';');
	int bracket = Utils.indexOf(s, '(');

	if (-1 == brace)
	return false;
	return (-1 == semicolon \|\| brace < semicolon)
	&& (-1 == bracket \|\| brace < bracket);
	}

	/**
	* Find out whether we are defining an enum or union which will contain
	* braces. Ignore function prototypes that return an enum or union.
	* enum colour { red, blue };
	* enum colour func();
	* enum colour func() { return colour.red; }
	*/
	private static boolean isEnumOrUnion(String s) throws ParsingException {
	if ((!Utils.startsWith(s, "enum") && !Utils.startsWith(s, "union"))
	\|\| isMethod(s))
	return false;

	int brace = Utils.indexOf(s, '{');
	int semicolon = Utils.indexOf(s, ';');
	return -1 != brace && (-1 == semicolon \|\| brace < semicolon);
	}

	/**
	* Rules to recognise fields and methods...
	*
	* Fields must contain a semicolon
	* Methods may or may not contain a semicolon
	* Prototypes must contain a semicolon
	* Fields may or may not contain a brace (array initialisers do)
	* Methods must contain a brace
	* Prototypes must not contain a brace
	* Fields may or may not contain a bracket (casts do)
	* Methods must contain a bracket
	* Prototypes must contain a bracket
	*
	* It's a method if it contains a bracket and then a brace
	* before the first semicolon (if there is a semicolon).
	* It's a prototype if it's not a method and it contains brackets before a semicolon.
	* It's a field if it's not a method or a prototype and it contains a semicolon.
	* If it's not a field, a method or a prototype and we haven't recognised it
	* previously then it's an error.
	*/
	private static boolean isMethod(String s) throws ParsingException {
	int semicolon = Utils.indexOf(s, ';');
	int brace = Utils.indexOf(s, '{');
	int bracket = Utils.indexOf(s, '(');

	return (
	-1 != bracket
	&& -1 != brace
	&& bracket < brace
	&& (-1 == semicolon \|\| brace < semicolon));
	}

	private static boolean isPrototype(String s) throws ParsingException {
	int semicolon = Utils.indexOf(s, ';');
	int bracket = Utils.indexOf(s, '(');
	return !isMethod(s)
	&& -1 != semicolon
	&& -1 != bracket
	&& bracket < semicolon;
	}

	private static boolean isField(String s) throws ParsingException {
	int semicolon = Utils.indexOf(s, ';');
	return !isMethod(s) && !isPrototype(s) && -1 != semicolon;
	}

	public String getName() {
	return name;
	}

	public String toString() {
	StringBuffer text = new StringBuffer();
	for (int i = 0; i < parts.size(); i++) {
	text.append(((FilePart) (parts.get(i))).toString());
	}
	return text.toString();
	}

	}