Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.codehaus.groovy.syntax;
import org.codehaus.groovy.GroovyBugError;
/**
* A CSTNode produced by the Lexer.
*
* @see antlr.Parser
* @see antlr.Token
* @see Reduction
* @see Types
*
* @author bob mcwhirter
* @author Chris Poirier
*/
public class Token extends CSTNode
{
public static final Token NULL = new Token();
public static final Token EOF = new Token( Types.EOF, "", -1, -1 );
//---------------------------------------------------------------------------
// TOKEN INITIALIZATION AND SUCH
private int type = Types.UNKNOWN; // the actual type identified by the lexer
private int meaning = Types.UNKNOWN; // an interpretation applied to the token after the fact
private String text = ""; // the text of the token
private int startLine = -1; // the source line on which the token begins
private int startColumn = -1; // the source column on which the token begins
/**
* Initializes the Token with the specified information.
*/
public Token( int type, String text, int startLine, int startColumn )
{
this.type = type;
this.meaning = type;
this.text = text;
this.startLine = startLine;
this.startColumn = startColumn;
}
/**
* Initializes the NULL Token.
*/
private Token() { }
/**
* Returns a copy of this Token.
*/
public Token dup()
{
Token token = new Token( this.type, this.text, this.startLine, this.startColumn );
token.setMeaning( this.meaning );
return token;
}
//---------------------------------------------------------------------------
// NODE IDENTIFICATION AND MEANING
/**
* Returns the meaning of this node. If the node isEmpty(), returns
* the type of Token.NULL.
*/
public int getMeaning()
{
return meaning;
}
/**
* Sets the meaning for this node (and it's root Token). Not
* valid if the node isEmpty(). Returns this token, for
* convenience.
*/
public CSTNode setMeaning( int meaning )
{
this.meaning = meaning;
return this;
}
/**
* Returns the actual type of the node. If the node isEmpty(), returns
* the type of Token.NULL.
*/
public int getType()
{
return type;
}
//---------------------------------------------------------------------------
// MEMBER ACCESS
/**
* Returns the number of elements in the node (including root).
*/
public int size()
{
return 1;
}
/**
* Returns the specified element, or null.
*/
public CSTNode get( int index )
{
if( index > 0 )
{
throw new GroovyBugError( "attempt to access Token element other than root" );
}
return this;
}
/**
* Returns the root of the node. By convention, all nodes have
* a Token as the first element (or root), which indicates the type
* of the node. May return null if the node isEmpty().
*/
public Token getRoot()
{
return this;
}
/**
* Returns the text of the root node. Uses getRoot(true)
* to get the root, so you will only receive null in return if the
* root token returns it.
*/
public String getRootText()
{
return text;
}
/**
* Returns the text of the token. Equivalent to
* getRootText() when called directly.
*/
public String getText()
{
return text;
}
/**
* Not advisable, but if you need to adjust the token's text, this
* will do it.
*/
public void setText( String text )
{
this.text = text;
}
/**
* Returns the starting line of the node. Returns -1
* if not known.
*/
public int getStartLine()
{
return startLine;
}
/**
* Returns the starting column of the node. Returns -1
* if not known.
*/
public int getStartColumn()
{
return startColumn;
}
//---------------------------------------------------------------------------
// OPERATIONS
/**
* Creates a Reduction from this token. Returns self if the
* node is already a Reduction.
*/
public Reduction asReduction()
{
return new Reduction( this );
}
/**
* Creates a Reduction from this token, adding the supplied
* node as the second element.
*/
public Reduction asReduction( CSTNode second )
{
Reduction created = asReduction();
created.add( second );
return created;
}
/**
* Creates a Reduction from this token, adding the supplied
* nodes as the second and third element, respectively.
*/
public Reduction asReduction( CSTNode second, CSTNode third )
{
Reduction created = asReduction( second );
created.add( third );
return created;
}
/**
* Creates a Reduction from this token, adding the supplied
* nodes as the second, third, and fourth element, respectively.
*/
public Reduction asReduction( CSTNode second, CSTNode third, CSTNode fourth )
{
Reduction created = asReduction( second, third );
created.add( fourth );
return created;
}
//---------------------------------------------------------------------------
// TOKEN FACTORIES
/**
* Creates a token that represents a keyword. Returns null if the
* specified text isn't a keyword.
*/
public static Token newKeyword( String text, int startLine, int startColumn )
{
int type = Types.lookupKeyword( text );
if( type != Types.UNKNOWN )
{
return new Token( type, text, startLine, startColumn );
}
return null;
}
/**
* Creates a token that represents a double-quoted string.
*/
public static Token newString( String text, int startLine, int startColumn )
{
return new Token( Types.STRING, text, startLine, startColumn );
}
/**
* Creates a token that represents an identifier.
*/
public static Token newIdentifier( String text, int startLine, int startColumn )
{
return new Token( Types.IDENTIFIER, text, startLine, startColumn );
}
/**
* Creates a token that represents an integer.
*/
public static Token newInteger( String text, int startLine, int startColumn )
{
return new Token( Types.INTEGER_NUMBER, text, startLine, startColumn );
}
/**
* Creates a token that represents a decimal number.
*/
public static Token newDecimal( String text, int startLine, int startColumn )
{
return new Token( Types.DECIMAL_NUMBER, text, startLine, startColumn );
}
/**
* Creates a token that represents a symbol, using a library for the text.
*/
public static Token newSymbol( int type, int startLine, int startColumn )
{
return new Token( type, Types.getText(type), startLine, startColumn );
}
/**
* Creates a token that represents a symbol, using a library for the type.
*/
public static Token newSymbol( String type, int startLine, int startColumn )
{
return new Token( Types.lookupSymbol(type), type, startLine, startColumn );
}
/**
* Creates a token with the specified meaning.
*/
public static Token newPlaceholder( int type )
{
Token token = new Token( Types.UNKNOWN, "", -1, -1 );
token.setMeaning( type );
return token;
}
}
