/*
 * Copyright (c) 1996, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package org.openjdk.asmtools.jasm;

import static org.openjdk.asmtools.jasm.TypeAnnotationUtils.*;
import static org.openjdk.asmtools.jasm.JasmTokens.*;
import static org.openjdk.asmtools.jasm.ConstantPool.*;
import static org.openjdk.asmtools.jasm.Tables.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.TreeMap;

/**
 * ParserAnnotation
 *
 * ParserAnnotation is a parser class owned by Parser.java. It is primarily responsible
 * for parsing Annotations (for classes, methods or fields).
 *
 * ParserAnnotation can parse the different types of Annotation Attributes:
 * Runtime(In)Visible Annotations (JDK 6+) Default Annotations (JDK 6+)
 * Runtime(In)VisibleParameter Annotations (JDK 7+) Runtime(In)VisibleType Annotations
 * (JSR308, JDK8+)
 */
public class ParserAnnotation extends ParseBase {

    /*-------------------------------------------------------- */
    /* Annotation Inner Classes */
    /**
     * AnnotationElemValue
     *
     * Used to store Annotation values
     */
    class AnnotationElemValue implements Data {

        AnnotationData annotation;

        public AnnotationElemValue(AnnotationData annotation) {
            this.annotation = annotation;
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeByte('@');
            annotation.write(out);
        }

        @Override
        public int getLength() {
            return 1 + annotation.getLength();
        }
    }

    /**
     * ClassElemValue
     *
     * Annotation Element value referring to a class
     */
    class ClassElemValue implements Data {

        ConstCell indx;

        public ClassElemValue(ConstCell indx) {
            this.indx = indx;
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeByte('c');
            indx.write(out);
        }

        @Override
        public int getLength() {
            return 3;
        }
    }

    /**
     * ArrayElemValue
     *
     * Annotation Element value referring to an Array
     */
    class ArrayElemValue implements Data {

        ArrayList<Data> elemValues;
        int arrayLength = 0;

        public ArrayElemValue() {
            this.elemValues = new ArrayList<>();
        }

        void add(Data elemValue) {
            elemValues.add(elemValue);
            arrayLength += elemValue.getLength();
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeByte('[');
            out.writeShort(elemValues.size());

            for (Data eval : elemValues) {
                eval.write(out);
            }
        }

        @Override
        public int getLength() {
            return 3 + arrayLength;
        }
    }

    /**
     * ConstElemValue
     *
     * Annotation Element value referring to a Constant
     */
    class ConstElemValue implements Data {

        char tag;
        ConstCell indx;

        public ConstElemValue(char tag, ConstCell indx) {
            this.tag = tag;
            this.indx = indx;
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeByte(tag);
            indx.write(out);
        }

        @Override
        public int getLength() {
            return 3;
        }
    }

    /**
     * EnumElemValue
     *
     * Element Value for Enums
     */
    class EnumElemValue implements Data {

        ConstCell type;
        ConstCell value;

        public EnumElemValue(ConstCell type, ConstCell value) {
            this.type = type;
            this.value = value;
        }

        @Override
        public void write(CheckedDataOutputStream out) throws IOException {
            out.writeByte('e');
            type.write(out);
            value.write(out);
        }

        @Override
        public int getLength() {
            return 5;
        }
    }

    /*-------------------------------------------------------- */
    /* Annotation Parser Fields */
    /**
     * local handles on the scanner, main parser, and the error reporting env
     */
    private static TTVis ttVisitor;
    /*-------------------------------------------------------- */

    /**
     * main constructor
     *
     * @param scanner
     * @param parser
     * @param env
     */
    protected ParserAnnotation(Scanner scanner, Parser parser, Environment env) {
        super.init(scanner, parser, env);
        ttVisitor = new TTVis();
        ttVisitor.init(env, scanner);
    }

    protected void scanParamName(int totalParams, int paramNum, MethodData curMethod) throws IOException {
        debugScan(" - - - > [ParserAnnotation.scanParamName]: Begin ");
        scanner.scan();
        scanner.expect(Token.LBRACE);
        // First scan the Name (String, or CPX to name)
        ConstCell nameCell = null;
        if ((scanner.token == Token.IDENT) || scanner.checkTokenIdent()) {
            // Got a Class Name
            nameCell = parser.parseName();
        } else if (scanner.token == Token.CPINDEX) {
            int cpx = scanner.intValue;
            nameCell = parser.pool.getCell(cpx);
            // check the constant
            ConstValue nameCellValue = nameCell.ref;
            if (!(nameCellValue instanceof ConstValue_String)) {
                // throw an error
                env.error(scanner.pos, "paramname.constnum.invaltype", cpx);
                throw new Scanner.SyntaxError();
            }

        } else {
            // throw scan error - unexpected token
            env.error(scanner.pos, "paramname.token.unexpected", scanner.stringValue);
            throw new Scanner.SyntaxError();
        }

        // Got the name cell. Next, scan the access flags
        int mod = parser.scanModifiers();

        scanner.expect(Token.RBRACE);

        curMethod.addMethodParameter(totalParams, paramNum, nameCell, mod);

        debugScan(" - - - > [ParserAnnotation.scanParamName]: End ");
    }

    /**
     * scanAnnotations
     *
     * The main entry for parsing an annotation list.
     *
     * @return An ArrayList of parsed annotations
     * @throws IOException
     */
    protected ArrayList<AnnotationData> scanAnnotations() throws IOException {
        ArrayList<AnnotationData> annttns = new ArrayList<>();

        while (scanner.token == Token.ANNOTATION) {
            if (isAnnotationToken(scanner.stringValue)) {
                annttns.add(parseAnnotation());
            } else if (isTypeAnnotationToken(scanner.stringValue)) {
                annttns.add(parseTypeAnnotation());
            }
        }

        if (annttns.size() > 0) {
            return annttns;
        } else {
            return null;
        }
    }

    /**
     * isAnnotation
     *
     * examines the beginning of a string to see if it starts with an annotation character
     *
     * @param str
     * @return True if the string starts with an annotation char.
     */
    protected boolean isAnnotation(String str) {
        return (str.startsWith("@"));
    }

    /**
     * isAnnotationToken
     *
     * examines the beginning of a string to see if it starts with an annotation
     * characters ('@+' = visible annotation, '@-' = invisible).
     *
     * @param str
     * @return True if the string starts with an annotation char.
     */
    protected boolean isAnnotationToken(String str) {
        return (str.startsWith("@+") || str.startsWith("@-"));
    }

    /**
     * isTypeAnnotationToken
     *
     * examines the beginning of a string to see if it starts with type annotation
     * characters ('@T+' = visible type annotation, '@T-' = invisible).
     *
     * @param str
     * @return True if the string starts with an annotation char.
     */
    protected boolean isTypeAnnotationToken(String str) {
        return (str.startsWith("@T+") || str.startsWith("@T-"));
    }

    /**
     * isInvisibleAnnotToken
     *
     * examines the end of an annotation token to determine visibility ('+' = visible
     * annotation, '-' = invisible).
     *
     * @param str
     * @return True if the token implies invisible annotation.
     */
    protected boolean isInvisibleAnnotToken(String str) {
        return (str.endsWith("-"));
    }

    /**
     * parseDefaultAnnotation
     *
     * parses a default Annotation attribute
     *
     * @return the parsed Annotation Attribute
     * @throws org.openjdk.asmtools.jasm.Scanner.SyntaxError
     * @throws IOException
     */
    protected DefaultAnnotationAttr parseDefaultAnnotation() throws Scanner.SyntaxError, IOException {
        scanner.scan();
        DefaultAnnotationAttr attr = null;
        Data value = null;
        scanner.expect(Token.LBRACE);

        if ((scanner.token != Token.EOF) && (scanner.token != Token.RBRACE)) {
            value = scanAnnotationData("default");
        }
        scanner.expect(Token.RBRACE);
        attr = new DefaultAnnotationAttr(parser.cd,
                AttrTag.ATT_AnnotationDefault.parsekey(),
                value);
        return attr;
    }

    /**
     * parseParamAnnots
     *
     * Parses Parameter Annotations attributes.
     *
     * @param _totalParams
     * @param curMethod
     * @throws org.openjdk.asmtools.jasm.Scanner.SyntaxError
     * @throws IOException
     */
    protected void parseParamAnnots(int _totalParams, MethodData curMethod) throws Scanner.SyntaxError, IOException {
        debugScan(" - - - > [ParserAnnotation.parseParamAnnots]: Begin, totalParams =  " + _totalParams + " ");
        // _The method thinks there are N+1 params in the signature
        // (N = total params in the call list) + 1 (return value)
        int totalParams = _totalParams - 1;
        TreeMap<Integer, ArrayList<AnnotationData>> pAnnots = new TreeMap<>();

        while (scanner.token == Token.INTVAL) {
            // Create the Parameter Array for  Param Annotations

            // Do something with Parameter annotations
            // --------------------
            // First - validate that the parameter number (integer)
            // (eg >= 0, < numParams, and param num is not previously set)
            int paramNum = scanner.intValue;
            Integer iParamNum = new Integer(paramNum);
            if (paramNum < 0 || paramNum >= totalParams) {
                //invalid Parameter number.  Throw an error.
                env.error(scanner.pos, "invalid.paramnum", paramNum);
            }
            if (pAnnots.get(iParamNum) != null) {
                // paramter is already populated with annotations/pnames, Throw an error.
                env.error(scanner.pos, "duplicate.paramnum", paramNum);
            }
            // 2nd - Parse the COLON (invalid if not present)
            scanner.scan();
            scanner.expect(Token.COLON);

            // 3rd - parse either an optional ParamName, or a list of annotations
            if (scanner.token == Token.PARAM_NAME) {
                //parse the ParamName
                scanParamName(_totalParams, iParamNum, curMethod);
            }

            // 4th - parse each Annotation (followed by comma, followed by annotation
            //       assign array of annotations to param array
            if (scanner.token == Token.ANNOTATION) {
                ArrayList<AnnotationData> pAnnot = scanAnnotations();
                pAnnots.put(iParamNum, pAnnot);

                for (AnnotationData data : pAnnot) {
                    curMethod.addParamAnnotation(totalParams, paramNum, data);
                }
            }

        }
    }

    /* ************************* Private Members  *************************** */
    /**
     * parseTypeAnnotation
     *
     * parses an individual annotation.
     *
     * @return a parsed annotation.
     * @throws IOException
     */
    private AnnotationData parseTypeAnnotation() throws Scanner.SyntaxError, IOException {
        boolean invisible = isInvisibleAnnotToken(scanner.stringValue);
        scanner.scan();
        debugScan("     [ParserAnnotation.parseTypeAnnotation]: id = " + scanner.stringValue + " ");
        String annoName = "L" + scanner.stringValue + ";";
        TypeAnnotationData anno = new TypeAnnotationData(parser.pool.FindCellAsciz(annoName), invisible);
        scanner.scan();
        debugScan("     [ParserAnnotation.parseTypeAnnotation]:new type annotation: " + annoName + " ");

        scanner.expect(Token.LBRACE);

        // Scan the usual annotation data
        _scanAnnotation(anno);

        // scan the Target
        _scanTypeTarget(anno);

        // scan the Location
        _scanTargetPath(anno);

        scanner.expect(Token.RBRACE);
        return anno;
    }

    /**
     * scanAnnotation
     *
     * parses an individual annotation.
     *
     * @return a parsed annotation.
     * @throws IOException
     */
    private AnnotationData parseAnnotation() throws Scanner.SyntaxError, IOException {
        debugScan(" - - - > [ParserAnnotation.parseAnnotation]: Begin ");
        boolean invisible = isInvisibleAnnotToken(scanner.stringValue);
        scanner.scan();
        String annoName = "L" + scanner.stringValue + ";";

        AnnotationData anno = new AnnotationData(parser.pool.FindCellAsciz(annoName), invisible);
        scanner.scan();
        debugScan("[ParserAnnotation.parseAnnotation]: new annotation: " + annoName);
        _scanAnnotation(anno);

        return anno;
    }

    /**
     * _scanAnnotation
     *
     * parses an individual annotation-data.
     *
     * @return a parsed annotation.
     * @throws IOException
     */
    private void _scanAnnotation(AnnotationData annotData) throws Scanner.SyntaxError, IOException {
        debugScan(" - - - > [ParserAnnotation._scanAnnotation]: Begin");
        scanner.expect(Token.LBRACE);

        while ((scanner.token != Token.EOF) && (scanner.token != Token.RBRACE)) {
            ConstCell nameCell = parser.parseName();
            scanner.expect(Token.ASSIGN);

            ConstValue cellref = nameCell.ref;
            if (cellref.tag != ConstType.CONSTANT_UTF8) {
                throw new Scanner.SyntaxError();
            }
            String name = ((ConstValue_String) cellref)._toString();
            debugScan(" - - - > [ParserAnnotation._scanAnnotation]: Annot - Field Name: " + name);
            Data data = scanAnnotationData(name);
            annotData.add(new AnnotationData.ElemValuePair(nameCell, data));

            // consume tokens inbetween annotation fields
            if (scanner.token == Token.COMMA) {
                scanner.scan();
            }
        }
        scanner.expect(Token.RBRACE);
    }

    /**
     * _scanAnnotation
     *
     * parses an individual annotation-data.
     *
     * @return a parsed annotation.
     * @throws IOException
     */
    private void _scanTypeTarget(TypeAnnotationData annotData) throws Scanner.SyntaxError, IOException {
        debugScan("     [ParserAnnotation._scanTypeTarget]: Begin ");
        scanner.expect(Token.LBRACE);

        //Scan the target_type and the target_info
        scanner.expect(Token.IDENT);
        debugScan("     [ParserAnnotation._scanTypeTarget]: TargetType: " + scanner.idValue);
        TypeAnnotationUtils.TargetType tt = TypeAnnotationUtils.getTargetType(scanner.idValue);
        if (tt == null) {
            env.error(scanner.pos, "incorrect.typeannot.target", scanner.idValue);
            throw new Scanner.SyntaxError();
        }

        debugScan("     [ParserAnnotation._scanTypeTarget]: Got TargetType: " + tt);

        if (ttVisitor.scanner == null) {
            ttVisitor.scanner = scanner;
        }
        ttVisitor.visitExcept(tt);

        annotData.targetInfo = ttVisitor.getTargetInfo();
        annotData.targetType = tt;
        debugScan("     [ParserAnnotation._scanTypeTarget]: Got TargetInfo: " + annotData.targetInfo);

        scanner.expect(Token.RBRACE);
    }

    /**
     * TTVis
     *
     * Target Type visitor, used for constructing the target-info within a type
     * annotation. visitExcept() is the entry point. ti is the constructed target info.
     */
    private static class TTVis extends TypeAnnotationUtils.TypeAnnotationTargetVisitor {

        private TypeAnnotationUtils.TargetInfo ti;
        private IOException IOProb;
        private Scanner.SyntaxError SyProb;
        private Scanner scanner;
        private Environment env;

        public TTVis() {
            super();
            reset();
        }

        public void init(Environment en, Scanner scn) {
            if (scanner == null) {
                scanner = scn;
            }
            if (env == null) {
                env = en;
            }
        }

        public final void reset() {
            ti = null;
            IOProb = null;
            SyProb = null;
        }

        //This is the entry point for a visitor that tunnels exceptions
        public void visitExcept(TypeAnnotationUtils.TargetType tt) throws IOException, Scanner.SyntaxError {
            IOProb = null;
            SyProb = null;
            ti = null;

            visit(tt);

            if (IOProb != null) {
                throw IOProb;
            }

            if (SyProb != null) {
                throw SyProb;
            }
        }

        public TypeAnnotationUtils.TargetInfo getTargetInfo() {
            return ti;
        }

        // this fn gathers intvals, and tunnels any exceptions thrown by
        // the scanner
        private int scanIntVal(TypeAnnotationUtils.TargetType tt) {
            int ret = -1;
            if (scanner.token == Token.INTVAL) {
                ret = scanner.intValue;
                try {
                    scanner.scan();
                } catch (IOException e) {
                    IOProb = e;
                } catch (Scanner.SyntaxError e) {
                    SyProb = e;
                }
            } else {
                env.error(scanner.pos, "incorrect.typeannot.targtype.int", tt.parseKey(), scanner.token);
                SyProb = new Scanner.SyntaxError();
            }
            return ret;
        }

        // this fn gathers intvals, and tunnels any exceptions thrown by
        // the scanner
        private String scanStringVal(TypeAnnotationUtils.TargetType tt) {
            String ret = "";
            if (scanner.token == Token.STRINGVAL) {
                ret = scanner.stringValue;
                try {
                    scanner.scan();
                } catch (IOException e) {
                    IOProb = e;
                } catch (Scanner.SyntaxError e) {
                    SyProb = e;
                }
            } else {
                env.error(scanner.pos, "incorrect.typeannot.targtype.string", tt.parseKey(), scanner.token);
                SyProb = new Scanner.SyntaxError();
            }
            return ret;
        }

        // this fn gathers intvals, and tunnels any exceptions thrown by
        // the scanner
        private void scanBrace(boolean left) {
            try {
                scanner.expect(left ? Token.LBRACE : Token.RBRACE);
            } catch (IOException e) {
                IOProb = e;
            } catch (Scanner.SyntaxError e) {
                SyProb = e;
            }
        }

        private boolean error() {
            return IOProb != null || SyProb != null;
        }

        @Override
        public void visit_type_param_target(TypeAnnotationUtils.TargetType tt) {
            env.traceln("Type Param Target: ");
            int byteval = scanIntVal(tt); // param index
            if (!error()) {
                ti = new TypeAnnotationUtils.typeparam_target(tt, byteval);
            }
        }

        @Override
        public void visit_supertype_target(TypeAnnotationUtils.TargetType tt) {
            env.traceln("SuperType Target: ");
            int shortval = scanIntVal(tt); // type index
            if (!error()) {
                ti = new TypeAnnotationUtils.supertype_target(tt, shortval);
            }
        }

        @Override
        public void visit_typeparam_bound_target(TypeAnnotationUtils.TargetType tt) {
            env.traceln("TypeParam Bound Target: ");
            int byteval1 = scanIntVal(tt); // param index
            if (error()) {
                return;
            }
            int byteval2 = scanIntVal(tt); // bound index
            if (error()) {
                return;
            }
            ti = new TypeAnnotationUtils.typeparam_bound_target(tt, byteval1, byteval2);
        }

        @Override
        public void visit_empty_target(TypeAnnotationUtils.TargetType tt) {
            env.traceln("Empty Target: ");
            if (!error()) {
                ti = new TypeAnnotationUtils.empty_target(tt);
            }
        }

        @Override
        public void visit_methodformalparam_target(TypeAnnotationUtils.TargetType tt) {
            env.traceln("MethodParam Target: ");
            int byteval = scanIntVal(tt); // param index
            if (!error()) {
                ti = new TypeAnnotationUtils.methodformalparam_target(tt, byteval);
            }
        }

        @Override
        public void visit_throws_target(TypeAnnotationUtils.TargetType tt) {
            env.traceln("Throws Target: ");
            int shortval = scanIntVal(tt); // exception index
            if (!error()) {
                ti = new TypeAnnotationUtils.throws_target(tt, shortval);
            }
        }

        @Override
        public void visit_localvar_target(TypeAnnotationUtils.TargetType tt) {
            env.traceln("LocalVar Target: ");
            TypeAnnotationUtils.localvar_target locvartab = new TypeAnnotationUtils.localvar_target(tt, 0);
            ti = locvartab;

            while ((scanner.token != Token.EOF) && (scanner.token != Token.RBRACE)) {
                // consume the left brace
                scanBrace(true);
                if (error()) {
                    return;
                }
                // scan the local var triple
                int shortval1 = scanIntVal(tt); // startPC
                if (error()) {
                    return;
                }
                int shortval2 = scanIntVal(tt); // length
                if (error()) {
                    return;
                }
                int shortval3 = scanIntVal(tt); // CPX
                locvartab.addEntry(shortval1, shortval2, shortval3);
                scanBrace(false);
                if (error()) {
                    return;
                }
            }
        }

        @Override
        public void visit_catch_target(TypeAnnotationUtils.TargetType tt) {
            env.traceln("Catch Target: ");
            int shortval = scanIntVal(tt); // catch index

            ti = new TypeAnnotationUtils.catch_target(tt, shortval);
        }

        @Override
        public void visit_offset_target(TypeAnnotationUtils.TargetType tt) {
            env.traceln("Offset Target: ");
            int shortval = scanIntVal(tt); // offset index
            if (!error()) {
                ti = new TypeAnnotationUtils.offset_target(tt, shortval);
            }
        }

        @Override
        public void visit_typearg_target(TypeAnnotationUtils.TargetType tt) {
            env.traceln("TypeArg Target: ");
            int shortval = scanIntVal(tt); // offset
            if (error()) {
                return;
            }
            int byteval = scanIntVal(tt); // type index
            if (error()) {
                return;
            }
            ti = new TypeAnnotationUtils.typearg_target(tt, shortval, byteval);
        }

    }

    /**
     * _scanTypeLocation
     *
     * parses an individual annotation-data.
     *
     * @return a parsed annotation.
     * @throws IOException
     */
    private void _scanTargetPath(TypeAnnotationData annotData) throws Scanner.SyntaxError, IOException {

        ArrayList<TypePathEntry> targPath = new ArrayList<>();
        // parse the location info
        scanner.expect(Token.LBRACE);

        while ((scanner.token != Token.EOF) && (scanner.token != Token.RBRACE)) {
            TypePathEntry tpe = _scanTypePathEntry();

            scanner.scan();
            // throw away comma
            if (scanner.token == Token.COMMA) {
                scanner.scan();
            }
        }
        scanner.expect(Token.RBRACE);
        annotData.targetPath = targPath;
    }

    /**
     * _scanTypeLocation
     *
     * parses an individual annotation-data.
     *
     * @return a parsed annotation.
     * @throws IOException
     */
    private TypePathEntry _scanTypePathEntry() throws Scanner.SyntaxError, IOException {
        TypePathEntry tpe;

        if ((scanner.token != Token.EOF) && (scanner.token == Token.STRINGVAL)) {
            String pathEntryKey = scanner.stringValue;
            PathKind pk = pathKind(pathEntryKey);
            if (pk == null) {
                // unexpected Type Path
                env.error(scanner.pos, "incorrect.typeannot.pathentry", scanner.stringValue);
                throw new Scanner.SyntaxError();
            }
            if (pk == PathKind.ITHARG_PARAMETERTYPE) {
                //
                // need to scan the index
                // Take the form:  INNER_TYPE(#)
                scanner.expect(Token.LPAREN);
                int index = 0;
                if ((scanner.token != Token.EOF) && (scanner.token == Token.INTVAL)) {
                    index = scanner.intValue;
                } else {
                    // incorrect Arg index
                    env.error(scanner.pos, "incorrect.typeannot.pathentry.argindex", scanner.token);
                    throw new Scanner.SyntaxError();
                }

                scanner.expect(Token.RPAREN);
                tpe = new TypePathEntry(pk.key(), (char) index);
            } else {
                tpe = new TypePathEntry(pk.key(), (char) 0);
            }
        } else {
            // unexpected Type Path
            env.error(scanner.pos, "incorrect.typeannot.pathentry", scanner.token);
            throw new Scanner.SyntaxError();
        }

        return tpe;
    }

    /**
     * scanAnnotationArray
     *
     * Scans an Array of annotations.
     *
     * @param name Name of the annotation
     * @return Array Element
     * @throws IOException if scanning errors exist
     */
    private ArrayElemValue scanAnnotationArray(String name) throws IOException {
        scanner.scan();
        ArrayElemValue arrayElem = new ArrayElemValue();

        while ((scanner.token != Token.EOF) && (scanner.token != Token.RBRACE)) {
            Data data = scanAnnotationData(name + " {}");
            arrayElem.add(data);

            // consume tokens inbetween annotation fields
            if (scanner.token == Token.COMMA) {
                scanner.scan();
            }
        }

        scanner.expect(Token.RBRACE);
        return arrayElem;
    }

    /**
     * scanAnnotationEnum
     *
     * Scans an annotation enum val.
     *
     * @param name Annotation Name
     * @return Constant element value for the Class Annotation.
     * @throws IOException
     */
    private Data scanAnnotationClass(String name) throws IOException {
        Data constVal = null;
        // scan the next identifier.
        // if it is an Ident, consume it as the class name.
        scanner.scan();
        switch (scanner.token) {
            case IDENT:
                env.traceln("[AnnotationParser.scanAnnotationData]:: Constant Class Field: " + name + " = " + scanner.stringValue);
                //need to encode the stringval as an (internal) descriptor.
                String desc = parser.encodeClassString(scanner.stringValue);

                // note: for annotations, a class field points to a string with the class descriptor.
                constVal = new ConstElemValue('c', parser.pool.FindCellAsciz(desc));
                scanner.scan();
                break;
            case CPINDEX:
                // could be a reference to a class name
                env.traceln("[AnnotationParser.scanAnnotationData]:: Constant Class Field: " + name + " = " + scanner.stringValue);
                Integer ConstNmCPX = new Integer(scanner.stringValue);
                constVal = new ClassElemValue(parser.pool.getCell(ConstNmCPX));
                scanner.scan();
                break;
            default:
                env.error(scanner.pos, "incorrect.annot.class", scanner.stringValue);
                throw new Scanner.SyntaxError();
        }

        return constVal;
    }

    /**
     * scanAnnotationEnum
     *
     * Scans an annotation enum val.
     *
     * @param name Annotation Name
     * @return Enumeration Element Value
     * @throws IOException for scanning errors.
     */
    private EnumElemValue scanAnnotationEnum(String name) throws IOException {
        scanner.scan();
        EnumElemValue enumval = null;
        switch (scanner.token) {
            case IDENT:
                // could be a string identifying enum class and name
                String enumClassName = scanner.stringValue;
                scanner.scan();
                // could be a string identifying enum class and name
                switch (scanner.token) {
                    case IDENT:
                        // could be a string identifying enum class and name
                        String enumTypeName = scanner.stringValue;
                        env.traceln("[AnnotationParser.scanAnnotationEnum]:: Constant Enum Field: " + name + " = " + enumClassName + " " + enumTypeName);
                        String encodedClass = parser.encodeClassString(enumClassName);
                        ConstElemValue classConst = new ConstElemValue('s', parser.pool.FindCellAsciz(encodedClass));
                        ConstElemValue typeConst = new ConstElemValue('s', parser.pool.FindCellAsciz(enumTypeName));
                        enumval = new EnumElemValue(classConst.indx, typeConst.indx);
                        scanner.scan();
                        break;

                    default:
                        env.error(scanner.pos, "incorrect.annot.enum", scanner.stringValue);
                        throw new Scanner.SyntaxError();
                }
                break;
            case CPINDEX:
                Integer typeNmCPX = new Integer(scanner.stringValue);
                scanner.scan();
                //need two indexes to form a proper enum
                switch (scanner.token) {
                    case CPINDEX:
                        Integer ConstNmCPX = new Integer(scanner.stringValue);
                        env.traceln("[AnnotationParser.scanAnnotationEnum]:: Enumeration Field: " + name + " = #" + typeNmCPX + " #" + ConstNmCPX);
                        enumval = new EnumElemValue(parser.pool.getCell(typeNmCPX), parser.pool.getCell(ConstNmCPX));
                        scanner.scan();
                        break;
                    default:
                        env.error(scanner.pos, "incorrect.annot.enum.cpx");
                        throw new Scanner.SyntaxError();
                }
                break;
        }

        return enumval;
    }

    /**
     * scanAnnotationData
     *
     * parses the internals of an annotation.
     *
     * @param name Annotation Name
     * @return a Data data structure containing the annotation data.
     * @throws IOException for scanning errors.
     */
    private Data scanAnnotationData(String name) throws IOException {
        Data data = null;
        switch (scanner.token) {
            // This handles the Annotation types (as normalized in the constant pool)
            // Some primitive types (Boolean, char, short, byte) are identified by a keyword.
            case INTVAL:
                env.traceln("[AnnotationParser.scanAnnotationData]:: Integer Field: " + name + " = " + scanner.intValue);
                data = new ConstElemValue('I', parser.pool.FindCell(ConstType.CONSTANT_INTEGER, new Integer(scanner.intValue)));
                scanner.scan();
                break;
            case DOUBLEVAL:
                env.traceln("[AnnotationParser.scanAnnotationData]:: Double Field: " + name + " = " + scanner.doubleValue);
                double dval = new Double(scanner.doubleValue);
                long ivdal = Double.doubleToLongBits(dval);
                Long val = new Long(ivdal);
                data = new ConstElemValue('D', parser.pool.FindCell(ConstType.CONSTANT_DOUBLE, val));
                scanner.scan();
                break;
            case FLOATVAL:
                env.traceln("[AnnotationParser.scanAnnotationData]:: Float Field: " + name + " = " + scanner.floatValue);
                float fval = new Float(scanner.floatValue);
                int ifval = Float.floatToIntBits(fval);
                Integer val1 = new Integer(ifval);
                data = new ConstElemValue('F', parser.pool.FindCell(ConstType.CONSTANT_FLOAT, val1));
                scanner.scan();
                break;
            case LONGVAL:
                env.traceln("[AnnotationParser.scanAnnotationData]:: Long Field: " + name + " = " + scanner.longValue);
                data = new ConstElemValue('J', parser.pool.FindCell(ConstType.CONSTANT_LONG, new Long(scanner.longValue)));
                scanner.scan();
                break;
            case STRINGVAL:
                env.traceln("[AnnotationParser.scanAnnotationData]:: String Field: " + name + " = " + scanner.stringValue);
                data = new ConstElemValue('s', parser.pool.FindCellAsciz(scanner.stringValue));
                scanner.scan();
                break;
            case CLASS:
                env.traceln("[AnnotationParser.scanAnnotationData]:: Class) keyword: " + scanner.stringValue);
                data = scanAnnotationClass(name);
                break;
            case ENUM:
                // scan the next two identifiers (eg ident.ident), or 2 CPRefs.
                // if it is an Ident, use consume it as the class name.
                env.traceln("[AnnotationParser.scanAnnotationData]:: Enum) keyword: " + scanner.stringValue);
                data = scanAnnotationEnum(name);
                break;
            case IDENT:
                env.traceln("[AnnotationParser.scanAnnotationData]:: JASM Keyword: (annotation field name: " + name + ") keyword: " + scanner.stringValue);
                data = scanAnnotationIdent(scanner.stringValue, name);
                break;
            case ANNOTATION:
                env.traceln("[AnnotationParser.scanAnnotationData]:: Annotation Field: " + name + " = " + scanner.stringValue);
                data = new AnnotationElemValue(parseAnnotation());
                break;
            case LBRACE:
                env.traceln("[AnnotationParser.scanAnnotationData]:: Annotation Array Field: " + name);
                data = scanAnnotationArray(name);
                break;
            default:
                env.error(scanner.pos, "incorrect.annot.token", scanner.token);
                throw new Scanner.SyntaxError();
        }

        return data;
    }

    /**
     * scanAnnotationIdent
     *
     * parses the identifier of an annotation.
     *
     * @param ident Basic Type identifier
     * @param name Annotation Name
     * @return Basic Type Annotation data
     * @throws IOException if scanning errors occur
     */
    private Data scanAnnotationIdent(String ident, String name) throws IOException {
        // Handle JASM annotation Keyword Identifiers
        Data data = null;
        BasicType type = basictype(ident);
        switch (type) {

            case T_BOOLEAN:
                // consume the keyword, get the value
                scanner.scan();
                switch (scanner.token) {
                    case INTVAL:
                        // Handle Boolean value in integer form
                        env.traceln("Boolean Field: " + name + " = " + scanner.intValue);
                        Integer val = new Integer(scanner.intValue);
                        if (val > 1 || val < 0) {
                            env.traceln("Warning: Boolean Field: " + name + " value is not 0 or 1, value = " + scanner.intValue);
                        }
                        data = new ConstElemValue('Z', parser.pool.FindCell(ConstType.CONSTANT_INTEGER, val));
                        scanner.scan();
                        break;
                    case IDENT:
                        // handle boolean value with true/false keywords
                        int val1 = 0;
                        switch (scanner.stringValue) {
                            case "true":
                                val1 = 1;
                                break;
                            case "false":
                                val1 = 0;
                                break;
                            default:
                                throw new IOException("Incorrect Annotation (boolean), expected true/false), got \"" + scanner.stringValue + "\".");
                        }
                        env.traceln("Boolean Field: " + name + " = " + scanner.stringValue);
                        data = new ConstElemValue('Z', parser.pool.FindCell(ConstType.CONSTANT_INTEGER, new Integer(val1)));
                        scanner.scan();
                        break;
                    default:
                        env.error(scanner.pos, "incorrect.annot.bool", scanner.stringValue);
                        throw new Scanner.SyntaxError();
                }
                break;
            case T_BYTE:
                // consume the keyword, get the value
                scanner.scan();
                switch (scanner.token) {
                    case INTVAL:
                        env.traceln("Byte Field: " + name + " = " + scanner.intValue);
                        Integer val = new Integer(scanner.intValue);
                        if (val > 0xFF) {
                            env.traceln("Warning: Byte Field: " + name + " value is greater than 0xFF, value = " + scanner.intValue);
                        }
                        data = new ConstElemValue('B', parser.pool.FindCell(ConstType.CONSTANT_INTEGER, val));
                        scanner.scan();
                        break;
                    default:
                        env.error(scanner.pos, "incorrect.annot.byte", scanner.stringValue);
                        throw new Scanner.SyntaxError();
                }
                break;
            case T_CHAR:
                // consume the keyword, get the value
                scanner.scan();
                switch (scanner.token) {
                    case INTVAL:
                        env.traceln("Char Field: " + name + " = " + scanner.intValue);
                        Integer val = new Integer(scanner.intValue);
                        // Bounds check?
                        data = new ConstElemValue('C', parser.pool.FindCell(ConstType.CONSTANT_INTEGER, val));
                        scanner.scan();
                        break;
                    default:
                        env.error(scanner.pos, "incorrect.annot.char", scanner.stringValue);
                        throw new Scanner.SyntaxError();
                }
                break;
            case T_SHORT:
                // consume the keyword, get the value
                scanner.scan();
                switch (scanner.token) {
                    case INTVAL:
                        env.traceln("Short Field: " + name + " = " + scanner.intValue);
                        Integer val = new Integer(scanner.intValue);
                        if (val > 0xFFFF) {
                            env.traceln("Warning: Short Field: " + name + " value is greater than 0xFFFF, value = " + scanner.intValue);
                        }
                        data = new ConstElemValue('S', parser.pool.FindCell(ConstType.CONSTANT_INTEGER, val));
                        scanner.scan();
                        break;
                    default:
                        env.error(scanner.pos, "incorrect.annot.short", scanner.stringValue);
                        throw new Scanner.SyntaxError();
                }
                break;
            default:
                env.error(scanner.pos, "incorrect.annot.keyword", ident);
                throw new Scanner.SyntaxError();
        }

        return data;
    }
}