001: package com.teamkonzept.lib.templates;
002:
003: import java.io.*;
004: import java.util.*;
005:
006: import com.teamkonzept.lib.*;
007:
008: /**
009: * Ein TK_AtomTag wird aus dem Template gefiltert
010: * @author $Author: alex $
011: * @version $Revision: 1.11 $
012:
013: */
014: public class TKTagTagBase extends TKTag {
015:
016: public static final String ATTR_LABEL = "label";
017: public static final String ATTR_SIZE = "size";
018: public static final String ATTR_NAME = "attrName";
019: public static final String ATTR_LOCATION = "attrLocation";
020:
021: public static final String PARAMS_STRING = "PARAMS";
022:
023: public String label = null;
024: public String paramsString = null;
025: public TKHashtable params = null;
026: public TKTemplateSyntax argumentText = null;
027:
028: public int tagType() {
029: return -1;
030: };
031:
032: private static String identifierFirstCodes = "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
033: private static String digitCodes = "0123456789";
034: private static String identifierCodes = identifierFirstCodes
035: + digitCodes;
036:
037: /**
038: * Konstruktor 1
039: * Ein Syntaxbaum fuer ein Template wird erzeugt.
040: *
041: * @param String def, Name des Tags
042: * @param boolean hasSubTags
043: */
044: public TKTagTagBase(TKTemplateSyntax parent, String def,
045: boolean hasSubTags) throws TKTemplateSyntaxException {
046: super (parent);
047:
048: if (hasSubTags)
049: paramsString = def;
050: else
051: label = getParams(def, false, null);
052: }
053:
054: protected void makeParam(StringBuffer name, StringBuffer value,
055: boolean hasSubTags, TKTemplateData td)
056: throws TKTemplateSyntaxException {
057:
058: String valString = value == null ? "" : value.toString();
059:
060: if (hasSubTags) {
061:
062: TKTemplateSyntax syntax = parent.newChild(valString, parent
063: .getSource(), true);
064:
065: if (td != null) {
066:
067: TKTemplateData subTd = new TKTemplateData(td);
068:
069: td = subTd;
070: td.setLocalVariable("TEMPLATE_SYNTAX_DEFAULT_ENCODING",
071: TKAnsiConverter.CONV_ID);
072: }
073:
074: valString = syntax.apply(td);
075: }
076:
077: params.put(name.toString().trim(), valString);
078: }
079:
080: protected String getParams(String def, boolean hasSubTags,
081: TKTemplateData td) throws TKTemplateSyntaxException {
082: params = new TKHashtable();
083:
084: int pos = def.indexOf(':');
085: if (pos < 0) {
086:
087: if (hasSubTags)
088: return parent.newChild(def, parent.getSource(),
089: hasSubTags).apply(td);
090: else
091: return def;
092: }
093:
094: String label = def.substring(0, pos++);
095: if (hasSubTags)
096: label = parent.newChild(label, parent.getSource(),
097: hasSubTags).apply(td);
098:
099: StringBuffer name = null;
100: StringBuffer value = null;
101: boolean inName = true;
102:
103: while (pos < def.length()) {
104:
105: char chr = def.charAt(pos++);
106:
107: if (chr == ';') {
108:
109: if (name != null)
110: makeParam(name, value, hasSubTags, td);
111: inName = true;
112: name = null;
113: value = null;
114: continue;
115: }
116:
117: if (chr == '=') {
118: inName = false;
119: continue;
120: }
121:
122: if ((chr == '\\') && (pos < def.length()))
123: chr = def.charAt(pos++);
124:
125: (inName ? (name == null ? (name = new StringBuffer())
126: : name)
127: : (value == null ? (value = new StringBuffer())
128: : value)).append(chr);
129: }
130:
131: if (name != null)
132: makeParam(name, value, hasSubTags, td);
133:
134: return label;
135: }
136:
137: public static boolean quotingRequired(String text) {
138:
139: boolean isId = true;
140: boolean isInt = true;
141: boolean isFloat = true;
142:
143: if (text == null)
144: return false;
145:
146: int pos = 0;
147: while (pos < text.length()) {
148:
149: char chr = text.charAt(pos++);
150:
151: if ((pos == 0) && (identifierFirstCodes.indexOf(chr) == -1))
152: isId = false;
153: else if ((pos != 0) && (identifierCodes.indexOf(chr) == -1))
154: isId = false;
155:
156: if (chr == '.') {
157: if (!isInt)
158: isFloat = false;
159: else
160: isInt = false;
161: } else if (digitCodes.indexOf(chr) == -1) {
162: isInt = false;
163: isFloat = false;
164: }
165:
166: if (!isId && !isInt && !isFloat)
167: return true;
168: }
169:
170: return false;
171: }
172:
173: public static String par2quotes(String text) {
174:
175: if (text == null)
176: return null;
177:
178: StringBuffer buf = new StringBuffer();
179: buf.append('"');
180:
181: int pos = 0;
182: while (pos < text.length()) {
183:
184: char chr = text.charAt(pos++);
185:
186: if ((chr == '\\') || (chr == '"'))
187: buf.append('\\');
188:
189: buf.append(chr);
190: }
191:
192: buf.append('"');
193: return buf.toString();
194: }
195:
196: public String wrapValue(String value) {
197:
198: if (value == null)
199: return null;
200: else if (quotingRequired(value))
201: return par2quotes(value);
202: else
203: return value;
204: }
205:
206: /*******************************************************************
207: /**
208: * Der entsprechende Body-Part des Templates wird bearbeitet
209: *
210: * @param TKTemplateData td
211: * @return den String, der den bearbeiteten Body-Part enthaelt
212: */
213: public String apply(TKTemplateData td)
214: throws TKTemplateSyntaxException {
215: if (paramsString != null)
216: label = getParams(paramsString, true, td);
217:
218: String markupName = label;
219: Object value = td.getVariable("TAG_DEFINITION_" + markupName);
220:
221: if (value == null) { /* Markup nicht definiert, einfach durchreichen ...*/
222:
223: StringBuffer result = new StringBuffer();
224: result.append('<').append(markupName);
225:
226: Enumeration keys = params.keys();
227: while (keys.hasMoreElements()) {
228:
229: String name = (String) keys.nextElement();
230: String val = (String) params.get(name);
231:
232: if ((name == null) || (name.length() == 0))
233: continue;
234: result.append(' ').append(name);
235:
236: if ((val != null) && (val.length() != 0))
237: result.append('=').append(wrapValue(val));
238: }
239:
240: result.append('>');
241:
242: if (tagType() == TKTagTag.TAG_TYPE) {
243:
244: if (argumentText != null)
245: result.append(argumentText.apply(td));
246: result.append("</").append(markupName).append('>');
247: }
248:
249: return result.toString();
250: }
251:
252: if (value instanceof String)
253: return (String) value;
254:
255: if (!(value instanceof TKTemplateSyntax))
256: return null;
257:
258: TKTemplateSyntax definitionText = (TKTemplateSyntax) value;
259:
260: TKTemplateData subTd = new TKTemplateData(td);
261:
262: if (argumentText != null) {
263: TKTemplate template = argumentText.getNewTemplate();
264: template.td = td;
265: subTd.setLocalVariable("TAG_ARGUMENT", template);
266: }
267:
268: Enumeration keys = params.keys();
269: while (keys.hasMoreElements()) {
270:
271: String name = (String) keys.nextElement();
272: String val = (String) params.get(name);
273:
274: subTd.setLocalVariable("TAG_PARAM_" + name, val);
275: }
276:
277: return definitionText.apply(subTd);
278: }
279:
280: /*******************************************************************
281: /**
282: * Der entsprechende Body-Part des Templates wird bearbeitet
283: *
284: * @param td TKTemplateData
285: * @param writer Writer in den der bearbeitete Body-Part geschrieben wird.
286: */
287: public void apply(TKTemplateData td, Writer writer)
288: throws TKTemplateSyntaxException, IOException {
289: if (paramsString != null)
290: label = getParams(paramsString, true, td);
291:
292: String markupName = label;
293: Object value = td.getVariable("TAG_DEFINITION_" + markupName);
294:
295: if (value == null) { /* Markup nicht definiert, einfach durchreichen ...*/
296:
297: StringBuffer result = new StringBuffer();
298: result.append('<').append(markupName);
299:
300: Enumeration keys = params.keys();
301: while (keys.hasMoreElements()) {
302:
303: String name = (String) keys.nextElement();
304: String val = (String) params.get(name);
305:
306: if ((name == null) || (name.length() == 0))
307: continue;
308: result.append(' ').append(name);
309:
310: if ((val != null) && (val.length() != 0))
311: result.append('=').append(wrapValue(val));
312: }
313:
314: result.append('>');
315:
316: if (tagType() == TKTagTag.TAG_TYPE) {
317:
318: if (argumentText != null)
319: result.append(argumentText.apply(td));
320: result.append("</").append(markupName).append('>');
321: }
322:
323: writer.write(result.toString());
324: return;
325:
326: }
327:
328: if (value instanceof String) {
329: writer.write((String) value);
330: return;
331: }
332:
333: if (!(value instanceof TKTemplateSyntax)) {
334: return;
335: }
336:
337: TKTemplateSyntax definitionText = (TKTemplateSyntax) value;
338:
339: TKTemplateData subTd = new TKTemplateData(td);
340:
341: if (argumentText != null) {
342: TKTemplate template = argumentText.getNewTemplate();
343: template.td = td;
344: subTd.setLocalVariable("TAG_ARGUMENT", template);
345: }
346:
347: Enumeration keys = params.keys();
348: while (keys.hasMoreElements()) {
349:
350: String name = (String) keys.nextElement();
351: String val = (String) params.get(name);
352:
353: subTd.setLocalVariable("TAG_PARAM_" + name, val);
354: }
355:
356: definitionText.apply(subTd, writer);
357: return;
358: }
359:
360: }
|