@Override protected boolean isChildField(Object field) { return ((NodeFieldAccessor) field).getKind() == NodeFieldAccessor.NodeFieldKind.CHILD; }
@Override protected boolean isChildField(Object field) { return ((NodeFieldAccessor) field).getKind() == NodeFieldAccessor.NodeFieldKind.CHILD; }
@Override protected boolean isChildrenField(Object field) { return ((NodeFieldAccessor) field).getKind() == NodeFieldAccessor.NodeFieldKind.CHILDREN; }
@SuppressWarnings({"deprecation", "unused"}) private static boolean isChildrenField(NodeClass nodeClass, com.oracle.truffle.api.nodes.NodeFieldAccessor field) { return field.getKind() == com.oracle.truffle.api.nodes.NodeFieldAccessor.NodeFieldKind.CHILDREN; }
@Override protected boolean isChildrenField(Object field) { return ((NodeFieldAccessor) field).getKind() == NodeFieldAccessor.NodeFieldKind.CHILDREN; }
@SuppressWarnings({"deprecation", "unused"}) private static boolean isChildField(NodeClass nodeClass, com.oracle.truffle.api.nodes.NodeFieldAccessor field) { return field.getKind() == com.oracle.truffle.api.nodes.NodeFieldAccessor.NodeFieldKind.CHILD; }
@Override protected boolean isCloneableField(Object field) { return ((NodeFieldAccessor) field).getKind() == NodeFieldAccessor.NodeFieldKind.DATA && NodeCloneable.class.isAssignableFrom(((NodeFieldAccessor) field).getType()); }
@Override protected boolean isCloneableField(Object field) { return ((NodeFieldAccessor) field).getKind() == NodeFieldAccessor.NodeFieldKind.DATA && NodeCloneable.class.isAssignableFrom(((NodeFieldAccessor) field).getType()); }
private void serializeChildFields(VariableLengthIntBuffer buffer, Node nodeInstance, NodeFieldAccessor[] nodeFields) throws UnsupportedConstantPoolTypeException { for (int i = 0; i < nodeFields.length; i++) { NodeFieldAccessor field = nodeFields[i]; if (field.getKind() == NodeFieldKind.CHILD) { Object childObject = unsafe.getObject(nodeInstance, field.getOffset()); if (childObject != null && !(childObject instanceof Node)) { throw new AssertionError("Node children must be instanceof Node"); } serialize(buffer, (Node) childObject); } } }
/** * Determines whether a proposed child replacement would be safe: structurally and type. */ public static boolean isReplacementSafe(Node parent, Node oldChild, Node newChild) { assert newChild != null; if (parent != null) { final NodeFieldAccessor field = findChildField(parent, oldChild); if (field != null) { switch (field.getKind()) { case CHILD: return field.getType().isAssignableFrom(newChild.getClass()); case CHILDREN: return field.getType().getComponentType().isAssignableFrom(newChild.getClass()); default: throw new IllegalStateException(); } } } return false; }
private void deserializeChildFields(Node parent, NodeFieldAccessor[] nodeFields) { for (int i = nodeFields.length - 1; i >= 0; i--) { NodeFieldAccessor field = nodeFields[i]; if (field.getKind() == NodeFieldKind.CHILD) { unsafe.putObject(parent, field.getOffset(), popNode(parent, field.getType())); } } }
private void deserializeChildrenFields(Node parent, NodeFieldAccessor[] nodeFields) { for (int i = nodeFields.length - 1; i >= 0; i--) { NodeFieldAccessor field = nodeFields[i]; if (field.getKind() == NodeFieldKind.CHILDREN) { unsafe.putObject(parent, field.getOffset(), popArray(parent, field.getType())); } } }
private static boolean assertAssignable(NodeFieldAccessor field, Object newValue) { if (newValue == null) { return true; } if (field.getKind() == NodeFieldKind.CHILD) { if (field.getType().isAssignableFrom(newValue.getClass())) { return true; } else { assert false : "Child class " + newValue.getClass().getName() + " is not assignable to field \"" + field.getName() + "\" of type " + field.getType().getName(); return false; } } else if (field.getKind() == NodeFieldKind.CHILDREN) { if (field.getType().getComponentType().isAssignableFrom(newValue.getClass())) { return true; } else { assert false : "Child class " + newValue.getClass().getName() + " is not assignable to field \"" + field.getName() + "\" of type " + field.getType().getName(); return false; } } throw new IllegalArgumentException(); }
/** * Finds the field in a parent node, if any, that holds a specified child node. * * @return the field (possibly an array) holding the child, {@code null} if not found. * @since 0.8 or earlier */ @SuppressWarnings("deprecation") @Deprecated public static NodeFieldAccessor findChildField(Node parent, Node child) { assert child != null; NodeClass parentNodeClass = parent.getNodeClass(); for (NodeFieldAccessor field : parentNodeClass.getFields()) { if (field.getKind() == NodeFieldAccessor.NodeFieldKind.CHILD) { if (field.getObject(parent) == child) { return field; } } else if (field.getKind() == NodeFieldAccessor.NodeFieldKind.CHILDREN) { Object arrayObject = field.getObject(parent); if (arrayObject != null) { Object[] array = (Object[]) arrayObject; for (int i = 0; i < array.length; i++) { if (array[i] == child) { return field; } } } } } return null; }
/** * Finds the field in a parent node, if any, that holds a specified child node. * * @return the field (possibly an array) holding the child, {@code null} if not found. * @since 0.8 or earlier */ @SuppressWarnings("deprecation") @Deprecated public static NodeFieldAccessor findChildField(Node parent, Node child) { assert child != null; NodeClass parentNodeClass = parent.getNodeClass(); for (NodeFieldAccessor field : parentNodeClass.getFields()) { if (field.getKind() == NodeFieldAccessor.NodeFieldKind.CHILD) { if (field.getObject(parent) == child) { return field; } } else if (field.getKind() == NodeFieldAccessor.NodeFieldKind.CHILDREN) { Object arrayObject = field.getObject(parent); if (arrayObject != null) { Object[] array = (Object[]) arrayObject; for (int i = 0; i < array.length; i++) { if (array[i] == child) { return field; } } } } } return null; }
private static String getNodeFieldName(Node parent, Node node, String defaultName) { NodeFieldAccessor[] fields = parent.getNodeClass().getFields(); for (NodeFieldAccessor field : fields) { Object value = field.loadValue(parent); if (field.getKind() == NodeFieldKind.CHILD && value == node) { return field.getName(); } else if (field.getKind() == NodeFieldKind.CHILDREN) { int index = 0; for (Object arrayNode : (Object[]) value) { if (arrayNode == node) { return field.getName() + "[" + index + "]"; } index++; } } } return defaultName; }
private static LinkedHashMap<String, Node> findNamedNodeChildren(Node node) { LinkedHashMap<String, Node> nodes = new LinkedHashMap<>(); NodeClass nodeClass = node.getNodeClass(); for (NodeFieldAccessor field : nodeClass.getFields()) { NodeFieldKind kind = field.getKind(); if (kind == NodeFieldKind.CHILD || kind == NodeFieldKind.CHILDREN) { Object value = field.loadValue(node); if (value != null) { if (kind == NodeFieldKind.CHILD) { nodes.put(field.getName(), (Node) value); } else if (kind == NodeFieldKind.CHILDREN) { Object[] children = (Object[]) value; for (int i = 0; i < children.length; i++) { if (children[i] != null) { nodes.put(field.getName() + "[" + i + "]", (Node) children[i]); } } } } } } return nodes; }
private void deserializeDataFields(VariableLengthIntBuffer buffer, Node nodeInstance, NodeFieldAccessor[] nodeFields) throws UnsupportedConstantPoolTypeException { for (int i = 0; i < nodeFields.length; i++) { NodeFieldAccessor field = nodeFields[i]; if (field.getKind() == NodeFieldKind.DATA) { Class<?> fieldClass = field.getType(); long offset = field.getOffset(); // source sections are not serialized // TODO add support for source sections if (field.getType().isAssignableFrom(SourceSection.class)) { continue; } int cpi = buffer.get(); if (cpi == VariableLengthIntBuffer.NULL) { deserializeDataFieldsLengthNull(nodeInstance, fieldClass, offset); } else { deserializeDataFieldsDefault(nodeInstance, fieldClass, offset, cpi); } } } }
private void readNodeProperties(Node node) { NodeFieldAccessor[] fields = node.getNodeClass().getFields(); for (NodeFieldAccessor field : fields) { if (field.getKind() == NodeFieldKind.DATA) { String key = field.getName(); if (getPropertyElement(node, key) == null) { Object value = field.loadValue(node); setNodeProperty(node, key, value); } } } }
private void serializeChildrenFields(VariableLengthIntBuffer buffer, Node nodeInstance, NodeFieldAccessor[] nodeFields) throws UnsupportedConstantPoolTypeException { for (int i = 0; i < nodeFields.length; i++) { NodeFieldAccessor field = nodeFields[i]; if (field.getKind() == NodeFieldKind.CHILDREN) { Object childArrayObject = unsafe.getObject(nodeInstance, field.getOffset()); if (childArrayObject != null && !(childArrayObject instanceof Node[])) { throw new AssertionError("Node children must be instanceof Node[]"); } buffer.put(cp.putClass(field.getType())); Node[] childArray = (Node[]) childArrayObject; if (childArray == null) { buffer.put(VariableLengthIntBuffer.NULL); } else { buffer.put(cp.putInt(childArray.length)); for (int j = 0; j < childArray.length; j++) { serialize(buffer, childArray[j]); } } } } }