returns the first open register slot after parameters

@param m
the method for which you want the parameters
@return the first available register slot
542158
public static int getFirstRegisterSlot(Method m) {
        Type[] parms = m.getArgumentTypes();

        int first = m.isStatic() ? 0 : 1;
        for (Type t : parms) {
            first += getSignatureSize(t.getSignature());
        }

        return first;
    }
1078574
public Double getImaginary(int m, int n)
    {
        IndexMN i = new IndexMN(m,n);
        if ( imaginary.containsKey(i) )
        {
            return imaginary.get(i);
        }
        return new Double(0);
    }
1216523
public String getMethodSignature() {
        if (method != null) {
            String methodSignature = method.toString();
            return methodSignature.replaceFirst("public void ", "");
        }
        return null;
    }
531357
public MethodInfo getInitializer() {
        int size = mMethods.size();

        for (int i=0; i<size; i++) {
            MethodInfo method = mMethods.get(i);
            if ("<clinit>".equals(method.getName())) {
                return method;
            }
        }

        return null;
    }
907004
public static Parameter[] parameterizeArguments(final ClassNode receiver, final MethodNode m) {
        Map<GenericsTypeName, GenericsType> genericFromReceiver = GenericsUtils.extractPlaceholders(receiver);
        Map<GenericsTypeName, GenericsType> contextPlaceholders = extractGenericsParameterMapOfThis(m);
        Parameter[] methodParameters = m.getParameters();
        Parameter[] params = new Parameter[methodParameters.length];
        for (int i = 0; i < methodParameters.length; i++) {
            Parameter methodParameter = methodParameters[i];
            ClassNode paramType = methodParameter.getType();
            params[i] = buildParameter(genericFromReceiver, contextPlaceholders, methodParameter, paramType);
        }
        return params;
    }
1200400
public Collection<TypeQualifierValue<?>> getDirectlyRelevantTypeQualifiers(MethodDescriptor m) {
        Collection<TypeQualifierValue<?>> result = methodToDirectlyRelevantQualifiersMap.get(m);
        if (result != null) {
            return result;
        }
        return Collections.<TypeQualifierValue<?>> emptyList();
    }
1064642
public static String stringFor(int m)
    {
        switch (m)
        {
            case CUFFT_R2C : return "CUFFT_R2C";
            case CUFFT_C2R : return "CUFFT_C2R";
            case CUFFT_C2C : return "CUFFT_C2C";
            case CUFFT_D2Z : return "CUFFT_D2Z";
            case CUFFT_Z2D : return "CUFFT_Z2D";
            case CUFFT_Z2Z : return "CUFFT_Z2Z";
        }
        return "INVALID cufftType: " + m;
    }
268517
public String getPositionInString(ModificationFeature mf)
	{
		Set vals = SITE_ACC.getValueFromBean(mf);

		if (!vals.isEmpty())
		{
			int x = ((Integer) vals.iterator().next());
			if (x > 0) return "@" + x;
		}

		vals = INTERVAL_BEGIN_ACC.getValueFromBean(mf);

		if (!vals.isEmpty())
		{
			int begin = ((Integer) vals.iterator().next());

			vals = INTERVAL_END_ACC.getValueFromBean(mf);

			if (!vals.isEmpty())
			{
				int end = ((Integer) vals.iterator().next());

				if (begin > 0 && end > 0 && begin <= end)
				{
					if (begin == end) return "@"  + begin;
					else return "@" + "[" + begin + "-" + end + "]";
				}
			}
		}

		return "";
	}
1243804
public alluxio.grpc.RegisterCommandOrBuilder getRegisterCommandOrBuilder() {
    return registerCommand_ == null ? alluxio.grpc.RegisterCommand.getDefaultInstance() : registerCommand_;
  }
1355874
public alluxio.grpc.RegisterMasterPOptionsOrBuilder getOptionsOrBuilder() {
    return options_ == null ? alluxio.grpc.RegisterMasterPOptions.getDefaultInstance() : options_;
  }
216851
public String getFirst(String name)
    {
        List<String> values = delegate.get(name);
        if (values != null) {
            if (values.size() > 0) {
                return values.get(0);
            }
        }
        return null;
    }
676299
public LWMConfig getMQLink(String name) {

        String thisMethodName = "getMQLink";

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, thisMethodName, name);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, thisMethodName, null);
        }

        return null;
    }
1195794
public final String pop()
  {

    if (m_firstFree <= 0)
      return null;

    m_firstFree--;

    String s = m_map[m_firstFree];

    m_map[m_firstFree] = null;

    return s;
  }
117744
private static Collection<AnnotationValue> getDirectAnnotation(XMethod m, int parameter) {
        HashMap<XMethod, Map<Integer, Collection<AnnotationValue>>> directParameterAnnotations = getDirectParameterAnnotations();
        Map<Integer, Collection<AnnotationValue>> map = directParameterAnnotations.get(m);
        if (map == null) {
            int n = m.getNumParams();
            if (m.isVarArgs())
            {
                n--; // ignore annotations on varargs parameters
            }
            map = new HashMap<>(n + 2);
            for (int i = 0; i < n; i++) {
                Collection<AnnotationValue> a = TypeQualifierResolver.resolveTypeQualifiers(m.getParameterAnnotations(i));
                if (!a.isEmpty()) {
                    map.put(i, a);
                }
            }
            if (map.isEmpty()) {
                map = Collections.emptyMap();
            }
            directParameterAnnotations.put(m, map);
        }

        Collection<AnnotationValue> result = map.get(parameter);
        if (result != null) {
            return result;
        }
        return Collections.emptyList();
    }
327054
protected int getFirstFreeInputGateIndex() {

		for (int i = 0; i < this.backwardEdges.size(); i++) {

			if (this.backwardEdges.get(i) == null) {
				return i;
			}
		}

		return this.backwardEdges.size();
	}
642747
synchronized public int getFirstFreeDTMID()
  {
    int n = m_dtms.length;
    for (int i = 1; i < n; i++)
    {
      if(null == m_dtms[i])
      {
        return i;
      }
    }
		return n; // count on addDTM() to throw exception if out of range
  }
188327
public static void register(FastProtocolId id, Method m) {
    synchronized (FastProtocolRegister.class) {
      String name = id.toString();
      if (name.length() != NAME_LEN) {
        // we only allow two-byte serialization codes
        throw new RuntimeException("Code must be " + NAME_LEN + " bytes long");
      }
      if (m == null) {
        throw new RuntimeException("Method cannot be null");
      }
      Method registeredMethod = idToMethod.get(name);
      if (registeredMethod != null && registeredMethod != m) {
        throw new RuntimeException(
            "Trying to register different method with name: " + name);
      } else if (registeredMethod == m) {
        return; // quietly
      }
      LOG.info("FastProtocol - Registering method: " + name + " method: "
          + m.getName());
      idToMethod.put(name, m);
      methodToId.put(m, name);
    }
  }