diff options
Diffstat (limited to 'src/main/java/io/devnulllabs/openjava/ptree/ModifierList.java')
| -rw-r--r-- | src/main/java/io/devnulllabs/openjava/ptree/ModifierList.java | 232 |
1 files changed, 232 insertions, 0 deletions
diff --git a/src/main/java/io/devnulllabs/openjava/ptree/ModifierList.java b/src/main/java/io/devnulllabs/openjava/ptree/ModifierList.java new file mode 100644 index 0000000..48c7139 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/ptree/ModifierList.java @@ -0,0 +1,232 @@ +/* + * ModifierList.java 1.0 + * + * @see io.devnulllabs.openjava.ptree.ParseTree + * @version last updated: 06/11/97 + * @author Michiaki Tatsubori + */ +package io.devnulllabs.openjava.ptree; + +import java.lang.reflect.Modifier; + +import io.devnulllabs.openjava.ptree.util.ParseTreeVisitor; + +/** + * The ModifierList class presents for the node of parse tree + * of qualified name. + * This is a List of String for extended modifiers. + */ +public class ModifierList extends List { + + /* + * Access modifier flag constants from <em>The Java Virtual + * Machine Specification</em>, Table 4.1. + */ + public static final int PUBLIC = Modifier.PUBLIC; + public static final int PROTECTED = Modifier.PROTECTED; + public static final int PRIVATE = Modifier.PRIVATE; + public static final int STATIC = Modifier.STATIC; + public static final int FINAL = Modifier.FINAL; + public static final int SYNCHRONIZED = Modifier.SYNCHRONIZED; + public static final int VOLATILE = Modifier.VOLATILE; + public static final int TRANSIENT = Modifier.TRANSIENT; + public static final int NATIVE = Modifier.NATIVE; + // public static final int INTERFACE = Modifier.INTERFACE; + public static final int ABSTRACT = Modifier.ABSTRACT; + // public static final int STRICT = Modifier.STRICT; + // public static final int EXPLICIT = Modifier.EXPLICIT; + + public static final int EMPTY = 0; + + private int mod = 0; + + public ModifierList() { + super(" "); + } + + public ModifierList(String e0) { + super(" ", e0); + } + + public ModifierList(int mod) { + this(); + this.mod = mod; + } + + public String toString() { + return toString(this.getRegular()); + } + + /** + * Return a string describing the access modifier flags in + * the specified modifier. For example: + * <blockquote><pre> + * public final synchronized + * private transient volatile + * </pre></blockquote> + * The modifier names are return in canonical order, as + * specified by <em>The Java Language Specification</em>. + */ + public static String toString(int mod) { + StringBuffer sb = new StringBuffer(); + int len; + + if ((mod & PUBLIC) != 0) + sb.append("public "); + if ((mod & PRIVATE) != 0) + sb.append("private "); + if ((mod & PROTECTED) != 0) + sb.append("protected "); + + /* Canonical order */ + if ((mod & ABSTRACT) != 0) + sb.append("abstract "); + if ((mod & STATIC) != 0) + sb.append("static "); + if ((mod & FINAL) != 0) + sb.append("final "); + if ((mod & TRANSIENT) != 0) + sb.append("transient "); + if ((mod & VOLATILE) != 0) + sb.append("volatile "); + if ((mod & NATIVE) != 0) + sb.append("native "); + if ((mod & SYNCHRONIZED) != 0) + sb.append("synchronized "); + + // if ((mod & INTERFACE) != 0) sb.append( "interface " ); + + // if ((mod & STRICT) != 0) sb.append( "strict " ); + // if ((mod & EXPLICIT) != 0) sb.append( "explicit " ); + + if ((len = sb.length()) > 0) /* trim trailing space */ + return sb.toString().substring(0, len - 1); + return ""; + } + + public boolean isEmpty() { + return (super.isEmpty() && getRegular() == EMPTY); + } + + public boolean isEmptyAsRegular() { + return (getRegular() == EMPTY); + } + + public boolean contains(String str) { + if (str == null) + return false; + if (str.equals("public") && contains(PUBLIC)) + return true; + if (str.equals("private") && contains(PRIVATE)) + return true; + if (str.equals("protected") && contains(PROTECTED)) + return true; + if (str.equals("abstract") && contains(ABSTRACT)) + return true; + if (str.equals("static") && contains(STATIC)) + return true; + if (str.equals("final") && contains(FINAL)) + return true; + if (str.equals("transient") && contains(TRANSIENT)) + return true; + if (str.equals("volatile") && contains(VOLATILE)) + return true; + if (str.equals("native") && contains(NATIVE)) + return true; + if (str.equals("synchronized") && contains(SYNCHRONIZED)) { + return true; + } + return super.contains(str); + } + + public boolean contains(int mod) { + return ((this.mod & mod) != 0); + } + + /** + * Gets the specified element at + * + * @param n + */ + public String get(int n) { + return (String) contents_elementAt(n); + } + + /** + * Sets the specified element at the specified place of the list + * + * @param p element + * @param n the number where to set element + */ + public void set(int n, String p) { + contents_setElementAt(p, n); + } + + /** + * Adds the specified element after the list + * This causes side-effect. + * + * @param p a modifier to be inserted into the list + */ + public void add(int mod) { + this.mod |= mod; + } + + /** + * Adds the specified element after the list + * This causes side-effect. + * + * @param p a modifier to be inserted into the list + */ + public void add(String p) { + contents_addElement(p); + } + + /** + * Removes an element at the specified point from this list + * + * @param n where to remove element. + */ + public String remove(int n) { + String removed = (String) contents_elementAt(n); + contents_removeElementAt(n); + return removed; + } + + /** + * Inserts the specified element into the list + * before the specified element of the list. + * This causes side-effect. + * + * @param p the element to be inserted into the list + * @param n number of the element before which insertion ocuurs + */ + public void insertElementAt(String p, int n) { + contents_insertElementAt(p, n); + } + + /** + * Appends a list after this list. + * + * @param lst a list to be appended + */ + public void append(ModifierList lst) { + this.mod |= lst.getRegular(); + for (int i = 0; i < lst.size(); i++) { + contents_addElement(lst.get(i)); + } + } + + public int getRegular() { + return this.mod; + } + + public void setRegular(int mod) { + this.mod = mod; + } + + public void accept(ParseTreeVisitor v) throws ParseTreeException { + v.visit(this); + } + +} |