Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2013 Trillian AB
   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public License
   * as published by the Free Software Foundation; either version 2
   * of the License, or (at your option) any later version.
   *
   * This program 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 for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/gpl-2.0.html>.
  */
 package org.robovm.compiler;
 
 import static org.robovm.compiler.Functions.*;
 import static org.robovm.compiler.Mangler.*;
 import static org.robovm.compiler.Types.*;
 import static org.robovm.compiler.llvm.Type.*;
 
 import java.util.Map;
 
 
 import soot.SootClass;
Creates an interface table for a specific interface class.
 
 public class ITable {
     private Entry[] entries;
 
     private ITable(SootClass clazz) {
         ArrayList<Entryentries = new ArrayList<Entry>();
         for (SootMethod method : clazz.getMethods()) {
             if (!method.isStatic()) {
                 // Interface methods may have a <clinit> method.
                 entries.add(new Entry(entries.size(), method));
             }
         }
         this. = entries.toArray(new Entry[entries.size()]);
     }
 
     public int size() {
         return .;
     }
     
     Entry findEntry(String nameString desc) {
         for (Entry entry : ) {
             if (entry.name.equals(name) && entry.desc.equals(desc)) {
                 return entry;
             }
         }
         return null;
     }
 
     public Entry getEntry(SootMethod method) {
         if (!Modifier.isPublic(method.getModifiers())) {
             return null;
         }
         return findEntry(method.getName(), Types.getDescriptor(method));
     }
     
     public StructureConstant getStruct() {
         ArrayConstantBuilder table = new ArrayConstantBuilder();
         for (int i = 0; i < .i++) {
             table.add(new ConstantBitcast());
         }
         return new StructureConstantBuilder()
                     .add(new IntegerConstant((short.))
                     .add(table.build())
                     .build();
     }
     
     public StructureConstant getStruct(SootClass clazz) {
         if (clazz.isInterface()) {
             throw new IllegalArgumentException("Expected a class got an interface: " + clazz.getName());
         }
         ArrayConstantBuilder table = new ArrayConstantBuilder();
         for (Entry entry : ) {
             ResolvedEntry resolvedEntry = entry.resolve(clazz);
             if (resolvedEntry == null || Modifier.isAbstract(resolvedEntry.getModifiers())) {
                 table.add(new ConstantBitcast());
             } else if (!Modifier.isPublic(resolvedEntry.getModifiers())) {
                 table.add(new ConstantBitcast());
             } else {
                 table.add(new ConstantBitcast(resolvedEntry.getFunctionRef(), ));
            }
        }
        return new StructureConstantBuilder()
                    .add(new IntegerConstant((short.))
                    .add(table.build())
                    .build();
    }
    
    public static class Cache {
        Map<StringITablecache = new HashMap<StringITable>();
        public ITable get(SootClass clazz) {
            if (!clazz.isInterface()) {
                throw new IllegalArgumentException("Not an interface: " + clazz.getName());
            }
            ITable itable = .get(clazz.getName());
            if (itable != null) {
                return itable;
            }
            itable = new ITable(clazz);
            .put(clazz.getName(), itable);
            return itable;
        }
    }
    
    public static class Entry {
        protected int index;
        protected final String name;
        protected final String desc;
        
        Entry(int indexSootMethod method) {
            this(indexmethod.getName(), Types.getDescriptor(method));
        }
        Entry(int indexString nameString desc) {
            this. = index;
            this. = name;
            this. = desc;
        }
        
        public ResolvedEntry resolve(SootClass clazz) {
            while (clazz != null) {
                for (SootMethod m : clazz.getMethods()) {
                    if (m.getName().equals() && .equals(Types.getDescriptor(m))) {
                        return new ResolvedEntry(thism);
                    }
                }
                clazz = clazz.hasSuperclass() ? clazz.getSuperclass() : null;
            }
            return null;
        }
        
        public int getIndex() {
            return ;
        }
        
        public String getName() {
            return ;
        }
        
        public String getDesc() {
            return ;
        }
        @Override
        public String toString() {
            StringBuilder builder = new StringBuilder();
            builder.append("Entry [index=").append()
                    .append(", name=").append().append(", desc=")
                    .append().append("]");
            return builder.toString();
        }
    }
    
    public static class ResolvedEntry extends Entry {
        private final int modifiers;
        private final String declaringClass;
        
        public ResolvedEntry(Entry entrySootMethod method) {
            super(entry.indexentry.nameentry.desc);
            this. = method.getModifiers();
            this. = method.getDeclaringClass().getName();
        }
        
        public int getModifiers() {
            return ;
        }
        
        public String getDeclaringClass() {
            return ;
        }
        
        public FunctionRef getFunctionRef() {
            if (Modifier.isAbstract() || !Modifier.isPublic()) {
                return null;
            }
            String functionName = mangleMethod(.replace('.''/'), );
            if (Modifier.isSynchronized()) {
                functionName += "_synchronized";
            }
            return new FunctionRef(functionNamegetFunctionType(, Modifier.isStatic()));
        }
        @Override
        public String toString() {
            StringBuilder builder = new StringBuilder();
            builder.append("ResolvedEntry [modifiers=").append()
                    .append(", declaringClass=").append()
                    .append(", index=").append().append(", name=")
                    .append().append(", desc=").append().append("]");
            return builder.toString();
        }
    }
New to GrepCode? Check out our FAQ X