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
*/
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;
}
}
