1 /*
2 * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
3 * @LastModified: Oct 2017
4 */
5 /*
6 * Licensed to the Apache Software Foundation (ASF) under one or more
7 * contributor license agreements. See the NOTICE file distributed with
8 * this work for additional information regarding copyright ownership.
9 * The ASF licenses this file to You under the Apache License, Version 2.0
10 * (the "License"); you may not use this file except in compliance with
11 * the License. You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 */
21 /*
22 * $Id: UnsupportedElement.java,v 1.2.4.1 2005/09/05 09:26:51 pvedula Exp $
23 */
24
25 package com.sun.org.apache.xalan.internal.xsltc.compiler;
26
27 import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
28 import com.sun.org.apache.bcel.internal.generic.INVOKESTATIC;
29 import com.sun.org.apache.bcel.internal.generic.InstructionList;
30 import com.sun.org.apache.bcel.internal.generic.PUSH;
31 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator;
32 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;
33 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator;
34 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type;
35 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError;
36 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Util;
37 import java.util.ArrayList;
38 import java.util.List;
39
40 /**
41 * @author Morten Jorgensen
42 */
43 final class UnsupportedElement extends SyntaxTreeNode {
44
45 private List<SyntaxTreeNode> _fallbacks = null;
46 private ErrorMsg _message = null;
47 private boolean _isExtension = false;
48
49 /**
50 * Basic consutrcor - stores element uri/prefix/localname
51 */
52 public UnsupportedElement(String uri, String prefix, String local, boolean isExtension) {
53 super(uri, prefix, local);
54 _isExtension = isExtension;
55 }
56
57 /**
58 * There are different categories of unsupported elements (believe it
59 * or not): there are elements within the XSLT namespace (these would
60 * be elements that are not yet implemented), there are extensions of
61 * other XSLT processors and there are unrecognised extension elements
62 * of this XSLT processor. The error message passed to this method
63 * should describe the unsupported element itself and what category
64 * the element belongs in.
65 */
66 public void setErrorMessage(ErrorMsg message) {
67 _message = message;
68 }
69
70 /**
71 * Displays the contents of this element
72 */
73 public void display(int indent) {
74 indent(indent);
75 Util.println("Unsupported element = " + _qname.getNamespace() +
76 ":" + _qname.getLocalPart());
77 displayContents(indent + IndentIncrement);
78 }
79
80
81 /**
82 * Scan and process all fallback children of the unsupported element.
83 */
84 private void processFallbacks(Parser parser) {
85
86 List<SyntaxTreeNode> children = getContents();
87 if (children != null) {
88 final int count = children.size();
89 for (int i = 0; i < count; i++) {
90 SyntaxTreeNode child = children.get(i);
91 if (child instanceof Fallback) {
92 Fallback fallback = (Fallback)child;
93 fallback.activate();
94 fallback.parseContents(parser);
95 if (_fallbacks == null) {
96 _fallbacks = new ArrayList<>();
97 }
98 _fallbacks.add(child);
99 }
100 }
101 }
102 }
103
104 /**
105 * Find any fallback in the descendant nodes; then activate & parse it
106 */
107 public void parseContents(Parser parser) {
108 processFallbacks(parser);
109 }
110
111 /**
112 * Run type check on the fallback element (if any).
113 */
114 public Type typeCheck(SymbolTable stable) throws TypeCheckError {
115 if (_fallbacks != null) {
116 int count = _fallbacks.size();
117 for (int i = 0; i < count; i++) {
118 Fallback fallback = (Fallback)_fallbacks.get(i);
119 fallback.typeCheck(stable);
120 }
121 }
122 return Type.Void;
123 }
124
125 /**
126 * Translate the fallback element (if any).
127 */
128 public void translate(ClassGenerator classGen, MethodGenerator methodGen) {
129 if (_fallbacks != null) {
130 int count = _fallbacks.size();
131 for (int i = 0; i < count; i++) {
132 Fallback fallback = (Fallback)_fallbacks.get(i);
133 fallback.translate(classGen, methodGen);
134 }
135 }
136 // We only go into the else block in forward-compatibility mode, when
137 // the unsupported element has no fallback.
138 else {
139 // If the unsupported element does not have any fallback child, then
140 // at runtime, a runtime error should be raised when the unsupported
141 // element is instantiated. Otherwise, no error is thrown.
142 ConstantPoolGen cpg = classGen.getConstantPool();
143 InstructionList il = methodGen.getInstructionList();
144
145 final int unsupportedElem = cpg.addMethodref(BASIS_LIBRARY_CLASS, "unsupported_ElementF",
146 "(" + STRING_SIG + "Z)V");
147 il.append(new PUSH(cpg, getQName().toString()));
148 il.append(new PUSH(cpg, _isExtension));
149 il.append(new INVOKESTATIC(unsupportedElem));
150 }
151 }
152 }