Java example source code file (MetaPragma.java)
The MetaPragma.java Java example source code/*
* Copyright (c) 1999, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* COMPONENT_NAME: shasta
*
* ORIGINS: 27
*
* Licensed Materials - Property of IBM
* 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997,1998,1999
* RMI-IIOP v1.0
*
*/
package com.sun.tools.corba.se.idl.som.idlemit;
import java.util.Vector;
import com.sun.tools.corba.se.idl.som.cff.Messages;
/**
* This is an implementation that handles
* #pragma meta scoped_name string
* where
* <UL>
* <LI> scoped_name == "::" separated scoped name
* <LI> string == separated identifiers, such as "localonly",
* "abstract", or "init".
* D59407: NOTE: any non-white-space is grouped
* as part of the identifier.
* </UL>
*
* This pragma handler places a vector of Strings into the dynamicVariable()
* part of the SymtabEntry. The key to access the dynamicVariable()
* is com.sun.tools.corba.se.idl.som.idlemit.MetaPragma.metaKey
*
* It is possible to associate a meta pragma with a forward entry.
* At some point after the parser has completed,
* the method processForward(ForwardEntry entry) should be called
* for each ForwardEntry so that the meta information can be folded from
* the ForwardEntry into the corresponding InterfaceEntry.
*/
public class MetaPragma extends com.sun.tools.corba.se.idl.PragmaHandler {
/* Class variables */
/* key to access the Cached meta info in com.sun.tools.corba.se.idl.SymtabEntry */
public static int metaKey = com.sun.tools.corba.se.idl.SymtabEntry.getVariableKey();
/**
* Main entry point for the MetaPragma handler
* @param pragma string for pragma name
* @param currentToken next token in the input stream.
* @return true if this is a meta pragma.
*/
public boolean process(String pragma, String currentToken) {
if ( !pragma.equals("meta"))
return false;
com.sun.tools.corba.se.idl.SymtabEntry entry ;
String msg;
try {
entry = scopedName();
if ( entry == null){
/* scoped name not found */
parseException(Messages.msg("idlemit.MetaPragma.scopedNameNotFound"));
skipToEOL();
}
else {
msg = (currentToken()+ getStringToEOL());
// System.out.println(entry + ": " + msg);
Vector v;
v = (Vector) entry.dynamicVariable(metaKey);
if ( v== null){
v = new Vector();
entry.dynamicVariable(metaKey, v);
}
parseMsg(v, msg);
}
} catch(Exception e){
// System.out.println("exception in MetaPragma");
}
return true;
}
/**
* Fold the meta info from the forward entry into its corresponding
* interface entry.
* @param forwardEntry the forward entry to process
*/
static public void processForward(com.sun.tools.corba.se.idl.ForwardEntry forwardEntry){
Vector forwardMeta;
try {
forwardMeta = (Vector)forwardEntry.dynamicVariable(metaKey);
} catch (Exception e){
forwardMeta = null;
}
com.sun.tools.corba.se.idl.SymtabEntry forwardInterface = forwardEntry.type();
if (forwardMeta != null && forwardInterface!= null) {
Vector interfaceMeta;
try {
interfaceMeta= (Vector)forwardInterface.dynamicVariable(metaKey);
} catch ( Exception e){
interfaceMeta = null;
}
if ( interfaceMeta == null) {
/* set */
try {
forwardInterface.dynamicVariable(MetaPragma.metaKey, forwardMeta);
} catch(Exception e){};
}
else if (interfaceMeta != forwardMeta) {
/* The above check is needed because sometimes
a forward entry is processed more the once.
Not sure why */
/* merge */
for (int i=0; i < forwardMeta.size(); i++){
try {
Object obj = forwardMeta.elementAt(i);
interfaceMeta.addElement(obj);
} catch (Exception e){};
}
}
}
}
/**
* parse pragma message and place into vector v.
* @param v: vector to add message
* @param msg: string of comma separated message, perhaps with comment.
* This is implemented as a state machine as follows:
*
* State token next action
* -----------------------------------------------------
* initial whitespace initial
* initial SlashStar comment
* initial SlashSlash final
* initial no more final
* initial text text add to text buffer
* initial StarSlash initial
* comment StarSlash initial
* comment SlashStar comment
* comment whitespace comment
* comment SlashSlash comment
* comment text comment
* comment no more final
* text text text add to buffer
* text SlashStar comment put in vector
* text whitespace initial put in vector
* text SlashSlash final put in vector
* text StarSlash initial put in vector
* text no more final put in vector
*
*/
private static int initialState = 0;
private static int commentState = 1;
private static int textState = 2;
private static int finalState =3;
private void parseMsg(Vector v, String msg){
int state = initialState;
String text = "";
int index = 0;
while ( state != finalState ){
boolean isNoMore = index >= msg.length();
char ch = ' ';
boolean isSlashStar = false;
boolean isSlashSlash = false;
boolean isWhiteSpace = false;
boolean isStarSlash = false;
boolean isText = false;
if (!isNoMore ){
ch = msg.charAt(index);
if (ch == '/' && index+1 < msg.length()){
if (msg.charAt(index+1) == '/'){
isSlashSlash = true;
index++;
}
else if (msg.charAt(index+1) == '*'){
isSlashStar= true;
index++;
} else isText = true;
}
else if (ch == '*' && index+1 < msg.length() ){
if (msg.charAt(index+1) == '/'){
isStarSlash = true;
index++;
} else isText = true;
}
else if ( Character.isSpace(ch) || (ch == ',') // 59601
|| (ch == ';') ) // 59683
isWhiteSpace = true;
else isText = true;
}
if (state == initialState){
if (isSlashStar){
state = commentState;
}
else if (isSlashSlash || isNoMore){
state = finalState;
}
else if (isText){
state = textState;
text = text+ ch;
}
}
else if (state == commentState){
if (isNoMore){
state = finalState;
}
else if ( isStarSlash){
state = initialState;
}
}
else if (state == textState){
if (isNoMore || isStarSlash || isSlashSlash ||
isSlashStar || isWhiteSpace ){
if (!text.equals("")) {
v.addElement(text);
// System.err.println("adding " + text);
text = "";
}
if (isNoMore)
state = finalState;
else if (isSlashStar)
state = commentState;
else state = initialState;
}
else if (isText){
text = text+ch;
}
}
index++;
}
}
}
Other Java examples (source code examples)Here is a short list of links related to this Java MetaPragma.java source code file: |
The search page
Other Java source code examples at this package level
Click here to learn more about this project
