Exemplo n.º 1
0
 private String toString(Object methodName) {
   if (methodName instanceof String) {
     return (String) methodName;
   } else if (RubyGuards.isRubyString(methodName)) {
     return methodName.toString();
   } else if (RubyGuards.isRubySymbol(methodName)) {
     return Layouts.SYMBOL.getString((DynamicObject) methodName);
   } else {
     throw new UnsupportedOperationException();
   }
 }
Exemplo n.º 2
0
  public int doInt(VirtualFrame frame, Object object) {
    // TODO CS 14-Nov-15 this code is crazy - should have separate nodes for ToRubyInteger and
    // ToJavaInt

    final Object integerObject = executeIntOrLong(frame, object);

    if (wasInteger.profile(integerObject instanceof Integer)) {
      return (int) integerObject;
    }

    if (wasLong.profile(integerObject instanceof Long)) {
      final long longValue = (long) integerObject;

      if (wasLongInRange.profile(CoreLibrary.fitsIntoInteger(longValue))) {
        return (int) longValue;
      }
    }

    CompilerDirectives.transferToInterpreter();
    if (RubyGuards.isRubyBignum(object)) {
      throw new RaiseException(
          getContext().getCoreLibrary().rangeError("bignum too big to convert into `long'", this));
    } else {
      throw new UnsupportedOperationException(object.getClass().toString());
    }
  }
Exemplo n.º 3
0
  private Object lookupRestKeywordArgumentHash(VirtualFrame frame) {
    final Object hash = readUserKeywordsHashNode.execute(frame);

    if (noHash.profile(hash == null)) {
      return Layouts.HASH.createHash(
          coreLibrary().getHashFactory(), null, 0, null, null, null, null, false);
    }

    CompilerDirectives.bailout("Ruby keyword arguments aren't optimized");

    final DynamicObject hashObject = (DynamicObject) hash;

    final List<Map.Entry<Object, Object>> entries = new ArrayList<>();

    outer:
    for (Map.Entry<Object, Object> keyValue : HashOperations.iterableKeyValues(hashObject)) {
      if (!RubyGuards.isRubySymbol(keyValue.getKey())) {
        continue;
      }

      for (String excludedKeyword : excludedKeywords) {
        if (excludedKeyword.equals(keyValue.getKey().toString())) {
          continue outer;
        }
      }

      entries.add(keyValue);
    }

    return BucketsStrategy.create(
        getContext(), entries, Layouts.HASH.getCompareByIdentity(hashObject));
  }
  public Object execute(VirtualFrame frame) {
    final Object childValue = child.execute(frame);

    if (!(RubyGuards.isRubyString(childValue)) && childValue != nil()) {
      CompilerDirectives.transferToInterpreter();
      throw new RaiseException(getContext().getCoreLibrary().typeErrorMustBe("$/", "String", this));
    }

    return childValue;
  }
Exemplo n.º 5
0
 @TruffleBoundary
 protected InternalMethod doLookup(InternalMethod currentMethod, DynamicObject selfMetaClass) {
   assert RubyGuards.isRubyClass(selfMetaClass);
   InternalMethod superMethod = ModuleOperations.lookupSuperMethod(currentMethod, selfMetaClass);
   // TODO (eregon, 12 June 2015): Is this correct?
   if (superMethod != null && superMethod.isUndefined()) {
     superMethod = null;
   }
   return superMethod;
 }
Exemplo n.º 6
0
 private Object timeToUnit(long time, DynamicObject unit) {
   assert RubyGuards.isRubySymbol(unit);
   if (unit == nanosecondSymbol) {
     return time;
   } else if (unit == floatSecondSymbol) {
     return time / 1e9;
   } else {
     throw new UnsupportedOperationException(Layouts.SYMBOL.getString(unit));
   }
 }
Exemplo n.º 7
0
  private DispatchNode doDynamicObject(
      VirtualFrame frame,
      DispatchNode first,
      Object receiverObject,
      Object methodName,
      Object[] argumentsObjects) {
    final DynamicObject callerClass;

    if (ignoreVisibility) {
      callerClass = null;
    } else if (getDispatchAction() == DispatchAction.RESPOND_TO_METHOD) {
      final Frame callerFrame =
          getContext()
              .getCallStack()
              .getCallerFrameIgnoringSend()
              .getFrame(FrameInstance.FrameAccess.READ_ONLY, true);
      callerClass = coreLibrary().getMetaClass(RubyArguments.getSelf(callerFrame.getArguments()));
    } else {
      callerClass = coreLibrary().getMetaClass(RubyArguments.getSelf(frame));
    }

    final InternalMethod method =
        lookup(callerClass, receiverObject, toString(methodName), ignoreVisibility);

    if (method == null) {
      return createMethodMissingNode(first, methodName, receiverObject);
    }

    final DynamicObject receiverMetaClass = coreLibrary().getMetaClass(receiverObject);
    if (RubyGuards.isRubySymbol(receiverObject)) {
      return new CachedBoxedSymbolDispatchNode(
          getContext(), methodName, first, method, getDispatchAction());
    } else if (Layouts.CLASS.getIsSingleton(receiverMetaClass)) {
      return new CachedSingletonDispatchNode(
          getContext(),
          methodName,
          first,
          ((DynamicObject) receiverObject),
          receiverMetaClass,
          method,
          getDispatchAction());
    } else {
      return new CachedBoxedDispatchNode(
          getContext(),
          methodName,
          first,
          ((DynamicObject) receiverObject).getShape(),
          receiverMetaClass,
          method,
          getDispatchAction());
    }
  }
  private Object tryConvertToHash(
      VirtualFrame frame, final int argumentCount, final Object lastArgument) {
    if (respondsToToHashProfile.profile(respondToToHash(frame, lastArgument))) {
      final Object converted = callToHash(frame, lastArgument);

      if (convertedIsHashProfile.profile(RubyGuards.isRubyHash(converted))) {
        RubyArguments.setArgument(frame, argumentCount - 1, converted);
        return converted;
      }
    }

    return null;
  }
Exemplo n.º 9
0
  @Specialization(guards = "isRubyModule(lexicalParentModule)")
  public Object defineModule(VirtualFrame frame, DynamicObject lexicalParentModule) {
    final RubyConstant constant = lookupForExistingModule(frame, name, lexicalParentModule);

    final DynamicObject definingModule;

    if (needToDefineProfile.profile(constant == null)) {
      definingModule =
          ModuleNodes.createModule(
              getContext(), coreLibrary().getModuleClass(), lexicalParentModule, name, this);
    } else {
      final Object constantValue = constant.getValue();

      if (!RubyGuards.isRubyModule(constantValue) || RubyGuards.isRubyClass(constantValue)) {
        errorProfile.enter();
        throw new RaiseException(coreExceptions().typeErrorIsNotA(name, "module", this));
      }

      definingModule = (DynamicObject) constantValue;
    }

    return definingModule;
  }
Exemplo n.º 10
0
 @Override
 public Object execute(VirtualFrame frame) {
   if (RubyGuards.isRubyString(ForeignAccess.getReceiver(frame))) {
     final DynamicObject string = (DynamicObject) ForeignAccess.getReceiver(frame);
     final int index = (int) ForeignAccess.getArguments(frame).get(labelIndex);
     if (index >= Layouts.STRING.getRope(string).byteLength()) {
       return 0;
     } else {
       return (byte) StringOperations.getByteListReadOnly(string).get(index);
     }
   } else {
     CompilerDirectives.transferToInterpreter();
     throw new IllegalStateException("Not implemented");
   }
 }
  @Override
  public Object execute(VirtualFrame frame) {
    final int argumentCount = RubyArguments.getArgumentsCount(frame);

    if (notEnoughArgumentsProfile.profile(argumentCount <= minArgumentCount)) {
      return null;
    }

    final Object lastArgument = RubyArguments.getArgument(frame, argumentCount - 1);

    if (lastArgumentIsHashProfile.profile(RubyGuards.isRubyHash(lastArgument))) {
      return lastArgument;
    }

    return tryConvertToHash(frame, argumentCount, lastArgument);
  }
Exemplo n.º 12
0
 public static boolean isSingleByteOptimizable(DynamicObject string) {
   assert RubyGuards.isRubyString(string);
   return Layouts.STRING.getRope(string).isSingleByteOptimizable();
 }
Exemplo n.º 13
0
 public static boolean isAsciiCompatible(DynamicObject string) {
   assert RubyGuards.isRubyString(string);
   return Layouts.STRING.getRope(string).getEncoding().isAsciiCompatible();
 }
 public RubiniusPrimitiveCallConstructor(DynamicObject method) {
   assert RubyGuards.isRubyMethod(method);
   this.method = method;
 }
Exemplo n.º 15
0
 public static boolean isFixedWidthEncoding(DynamicObject string) {
   assert RubyGuards.isRubyString(string);
   return Layouts.STRING.getRope(string).getEncoding().isFixedWidth();
 }
Exemplo n.º 16
0
 public static boolean isValidUtf8(DynamicObject string) {
   assert RubyGuards.isRubyString(string);
   return StringOperations.isCodeRangeValid(string)
       && Layouts.STRING.getRope(string).getEncoding().isUTF8();
 }
Exemplo n.º 17
0
 public static boolean isEmpty(DynamicObject string) {
   assert RubyGuards.isRubyString(string);
   return Layouts.STRING.getRope(string).isEmpty();
 }
Exemplo n.º 18
0
 public static boolean is7Bit(DynamicObject string) {
   assert RubyGuards.isRubyString(string);
   return StringOperations.codeRange(string) == CodeRange.CR_7BIT;
 }
Exemplo n.º 19
0
 public static boolean isBrokenCodeRange(DynamicObject string) {
   assert RubyGuards.isRubyString(string);
   return StringOperations.codeRange(string) == CodeRange.CR_BROKEN;
 }
Exemplo n.º 20
0
  public static boolean isRopeBuffer(DynamicObject string) {
    assert RubyGuards.isRubyString(string);

    return rope(string) instanceof RopeBuffer;
  }