Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   *
   * Copyright 2012 Red Hat, Inc.
   *
   * 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.jboss.classfilewriter.code;
 
 import java.util.List;
 
In immutable local variable state

Author(s):
Stuart Douglas
 
 public class LocalVariableState {

    
The contents, null is used to represent the additional spot taken up by a wide variable.

This list may be shared between frames, so it must never be modified

The very first element represents the first local variable (this for non static methods)

 
     private final List<StackEntrycontents;
 
     private final ConstPool constPool;

    
construct the initial local variable state for a method
 
     public LocalVariableState(ClassMethod method) {
         this. = method.getClassFile().getConstPool();
          = new ArrayList<StackEntry>();
         if (!method.isStatic()) {
             if (method.isConstructor()) {
                 .add(new StackEntry(.method.getClassFile().getDescriptor()));
             } else {
                 .add(StackEntry.of(method.getClassFile().getDescriptor(), method.getClassFile().getConstPool()));
             }
         }
         for (String param : method.getParameters()) {
             StackEntry entry = StackEntry.of(parammethod.getClassFile().getConstPool());
             .add(entry);
             if (entry.isWide()) {
                 .add(new StackEntry(.param));
             }
         }
     }
 
     public LocalVariableState(final ConstPool poolfinal String ... entries) {
         this. = pool;
          = new ArrayList<StackEntry>();
         for(String c : entries) {
             final StackEntry entry = StackEntry.of(c);
             .add(entry);
         }
     }
 
     private LocalVariableState(final List<StackEntrycontentsConstPool constPool) {
         this. = contents;
         this. = constPool;
     }
 
     public List<StackEntrygetContents() {
         return Collections.unmodifiableList();
     }
 
     public StackEntry get(int index) {
         return .get(index);
     }
 
     public LocalVariableState storeWide(int indexStackEntry entry) {
         ArrayList<StackEntrynewContents = new ArrayList<StackEntry>(.size());
         for (int i = 0; i <= index || i < .size(); ++i) {
             if (index == i) {
                 newContents.add(entry);
                 newContents.add(new StackEntry(.entry.getDescriptor()));
                 ++i;
             } else if (i >= .size()) {
                 // write a null in unitialised slots
                // not sure if this is correct
                newContents.add(new StackEntry(.null));
            } else {
                newContents.add(.get(i));
            }
        }
        return new LocalVariableState(newContents);
    }
    public LocalVariableState store(int indexStackEntry entry) {
        ArrayList<StackEntrynewContents = new ArrayList<StackEntry>(.size());
        for (int i = 0; i <= index || i < .size(); ++i) {
            if (index == i) {
                newContents.add(entry);
            } else if (i >= .size()) {
                // write a null in unitialised slots
                // not sure if this is correct
                newContents.add(new StackEntry(.null));
            } else {
                newContents.add(.get(i));
            }
        }
        return new LocalVariableState(newContents);
    }
    public int size() {
        return .size();
    }
    @Override
    public String toString() {
        return "Local Variables: " + .toString();
    }
        List<StackEntrynewContents = new ArrayList<StackEntry>(.size());
        if (entry.getType() == .) {
            for (int i = 0; i < .size(); ++i) {
                StackEntry stackEntry = .get(i);
                if (stackEntry.getType() == .) {
                    newContents.add(StackEntry.of(stackEntry.getDescriptor(), ));
                } else {
                    newContents.add(stackEntry);
                }
            }
            return new LocalVariableState(newContents);
        } else if (entry.getType() == .) {
            for (int i = 0; i < .size(); ++i) {
                StackEntry stackEntry = .get(i);
                if (stackEntry.getType() == .
                        && stackEntry.getNewInstructionLocation() == entry.getNewInstructionLocation()) {
                    newContents.add(StackEntry.of(stackEntry.getDescriptor(), ));
                } else {
                    newContents.add(stackEntry);
                }
            }
            return new LocalVariableState(newContents);
        } else {
            throw new InvalidBytecodeException("entry is not an unitialized object. " + toString());
        }
    }
New to GrepCode? Check out our FAQ X