if( (access & Constants.ACC_STATIC) == 0 ){
if( !TypeUtils.isStatic(access) ){
    protected Emitter getEmitter(ClassVisitor cv) {        return new Emitter(cv) {            public void begin_class(int access, String className, Type superType, Type[] interfaces, String sourceFile) {                if (!TypeUtils.isAbstract(access)) {                    interfaces = TypeUtils.add(interfaces, FIELD_PROVIDER);                }                fields = new HashMap();                super.begin_class(access, className, superType, interfaces, sourceFile);            }            public void declare_field(int access, String name, Type type, Object value) {                super.declare_field(access, name, type, value);                if( (access & Constants.ACC_STATIC) == 0 ){                    fields.put(name, type);                }            }             public CodeVisitor begin_method(int access, Signature sig, Type[] exceptions) {                CodeVisitor v = super.begin_method(access, sig, exceptions);                if (sig.getName().equals(Constants.STATIC_NAME)) {                    generatedClassInit = true;                    invoke_static(getClassType(),INIT_FIELD_PROVIDER);                                    }                return v;            }                        public void end_class() {                if (fields.size() == 0) {                    super.end_class();                    return;                }               final String[] names = (String[])fields.keySet().toArray(new String[fields.size()]);                              int indexes[] = new int[names.length];               for(int i = 0; i < indexes.length; i++ ){ indexes[i] = i; }                                    try {                                        if( !generatedClassInit ){                                              begin_static();                      return_value();                                        }                                                            super.declare_field(                                         Constants.ACC_PRIVATE|Constants.ACC_STATIC,                                         FIELD_NAMES,                                          Constants.TYPE_STRING_ARRAY, null                                );                    super.declare_field(                                         Constants.ACC_PRIVATE|Constants.ACC_STATIC,                                         FIELD_TYPES,                                          Constants.TYPE_CLASS_ARRAY, null                                );                                                      begin_method(Constants.ACC_STATIC,INIT_FIELD_PROVIDER,null);                    push(names.length);                    newarray(Constants.TYPE_STRING);                    dup();                                        for(int i = 0; i < names.length; i++ ){                        dup();                       push(i);                       push(names[i]);                       aastore();                    }                                        putstatic(getClassType(),FIELD_NAMES, Constants.TYPE_STRING_ARRAY);                                        push(names.length);                    newarray(Constants.TYPE_CLASS);                    dup();                                        for(int i = 0; i < names.length; i++ ){                        dup();                       push(i);                       Type type = (Type)fields.get(names[i]);                       ComplexOps.load_class( this, type );                       aastore();                    }                                        putstatic(getClassType(),FIELD_TYPES, Constants.TYPE_CLASS_ARRAY);                    return_value();                                        begin_method(Constants.ACC_PUBLIC, PROVIDER_GET_NAMES, null);                    getstatic(getClassType(), FIELD_NAMES, Constants.TYPE_STRING_ARRAY);                    return_value();                                        begin_method(Constants.ACC_PUBLIC, PROVIDER_GET_TYPES, null);                    getstatic(getClassType(), FIELD_TYPES, Constants.TYPE_CLASS_ARRAY);                    return_value();                                                            begin_method(Constants.ACC_PUBLIC, PROVIDER_SET_BY_INDEX, null);                    load_this();                    load_arg(1);                    load_arg(0);                                                          process_switch( indexes, new ProcessSwitchCallback(){                                                  public void processCase(int key, Label end) throws Exception{                                                        Type type = (Type)fields.get(names[key]);                               unbox(type);                               putfield(names[key]);                               return_value();                                                    }                          public void processDefault() throws Exception{                             throw_exception(ILLEGAL_ARGUMENT_EXCEPTION, "Unknown field index");                                   }                    }                    );                                                                                begin_method(Constants.ACC_PUBLIC, PROVIDER_GET_BY_INDEX, null);                    load_this();                    load_arg(0);                                        process_switch( indexes,new ProcessSwitchCallback(){                                                  public void processCase(int key, Label end) throws Exception{                                                        Type type = (Type)fields.get(names[key]);                               getfield(names[key]);                               box(type);                               return_value();                                                    }                          public void processDefault() throws Exception{                             throw_exception(ILLEGAL_ARGUMENT_EXCEPTION, "Unknown field index");                                   }                    }                    );                                        begin_method(Constants.ACC_PUBLIC, PROVIDER_GET, null);                    load_this();                    load_arg(0);                    // TODO: if this is used to enhance class files SWITCH_STYLE_TRIE should be used                    // to avoid JVM hashcode implementation incompatibilities                    ComplexOps.string_switch(this, names, Constants.SWITCH_STYLE_HASH, new ObjectSwitchCallback() {                        public void processCase(Object key, Label end) {                            Type type = (Type)fields.get(key);                            getfield((String)key);                            box(type);                            return_value();                        }                        public void processDefault() {                            throw_exception(ILLEGAL_ARGUMENT_EXCEPTION, "Unknown field name");                        }                    });                    begin_method(Constants.ACC_PUBLIC, PROVIDER_SET, null);                    load_this();                    load_arg(1);                    load_arg(0);                    ComplexOps.string_switch(this, names, Constants.SWITCH_STYLE_HASH, new ObjectSwitchCallback() {                        public void processCase(Object key, Label end) {                            Type type = (Type)fields.get(key);                            unbox(type);                            putfield((String)key);                            return_value();                        }                        public void processDefault() {                            throw_exception(ILLEGAL_ARGUMENT_EXCEPTION, "Unknown field name");                        }                    });                } catch (Exception e) {                    throw new CodeGenerationException(e);                }                super.end_class();            }        };    }