/** * Annotate the specified node. If any annotations have been recorded and {@link #mark() marked}, * the specified node is wrapped by those annotations and the outer-most annotation is returned. * Otherwise, the specified node is returned. * * @param node The node. * @return The annotated node. */ public Node annotate(Node node) { if (DEBUG) System.out.println("annotate(" + node + ")"); if (null != top.mark) { // Find the mark in the next closest context, if it exists. Annotation base = null; Context c = top.next; while (null != c) { if (null != c.mark) { base = c.mark; break; } c = c.next; } // Apply the annotations between the base and current mark to // the specified node, while also preserving any new // annotations. Annotation a = (Annotation) top.mark.getNode(); top.mark.setNode(node); if (null == base) { node = annotation; annotation = a; } else { node = base.getNode(); base.setNode(a); } top.mark = null; } // Done. return node; }
/** * Mark the current annotation. This method must be called before recognizing the nonterminals to * be annotated. Furthermore, it must be called within the context of a stateful production. */ public void mark() { if (DEBUG) System.out.println("mark()"); if (null == annotation) { top.mark = null; } else { top.mark = annotation.innerMost(); } }
/** * Record a pragma. * * @see Pragma * @param directive The actual directive. * @param location The pragma's source location. */ public void pragma(String directive, Location location) { if (DEBUG) System.out.println("pragma(" + directive + ")"); Pragma pragma = new Pragma(directive, null); pragma.setLocation(location); if (null == annotation) { annotation = pragma; } else { annotation.innerMost().setNode(pragma); } }
/** * Record an ident directive. * * @see SourceIdentity * @param ident The actual identity marker. * @param location The ident directive's source location. */ public void ident(String ident, Location location) { if (DEBUG) System.out.println("ident(" + ident + ")"); SourceIdentity identity = new SourceIdentity(ident, null); identity.setLocation(location); if (null == annotation) { annotation = identity; } else { annotation.innerMost().setNode(identity); } }
/** * Record a line marker. Note that string values for the four flags are interpreted as follows: * Any non-null string counts for <code>true</code>, while null counts for <code>false</code>. * * @see LineMarker * @param file The file name (without quotes). * @param line The line number. * @param isStartFile The start file flag. * @param isReturnToFile The return to file flag. * @param isSystemHeader The system header flag. * @param isExternC The extern C flag. * @param location The line marker's source location. */ public void lineMarker( String file, int line, String isStartFile, String isReturnToFile, String isSystemHeader, String isExternC, Location location) { if (DEBUG) System.out.println("lineMarker(" + file + ": " + line + ")"); int flags = 0; if (null != isStartFile) flags |= LineMarker.FLAG_START_FILE; if (null != isReturnToFile) flags |= LineMarker.FLAG_RETURN_TO_FILE; if (null != isSystemHeader) flags |= LineMarker.FLAG_SYSTEM_HEADER; if (null != isExternC) flags |= LineMarker.FLAG_EXTERN_C; LineMarker marker = new LineMarker(line, file, flags, null); marker.setLocation(location); if (null == annotation) { annotation = marker; } else { annotation.innerMost().setNode(marker); } }