mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-08-13 19:25:38 +02:00
Code Issues Wiki Activity

adapting the UPC plugin to the new LR parser (work in progress)

Browse source
This commit is contained in:
Mike Kucera 2008-04-07 22:45:08 +00:00
parent 97a10ee586
commit 83cc247f9c
58 changed files with 704 additions and 2007 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
lrparser/org.eclipse.cdt.core.lrparser.tests/META-INF/MANIFEST.MF
View file

@ -11,6 +11,8 @@ Require-Bundle: org.eclipse.core.runtime,
org.eclipse.core.resources,
org.eclipse.cdt.core.lrparser;bundle-version="4.0.1"
Eclipse-LazyStart: true
Export-Package: org.eclipse.cdt.core.lrparser.tests.c99
Export-Package: org.eclipse.cdt.core.lrparser.tests,
org.eclipse.cdt.core.lrparser.tests.c99,
org.eclipse.cdt.core.lrparser.tests.cpp
Bundle-Vendor: %Bundle-Vendor.0
Bundle-Localization: plugin

1
lrparser/org.eclipse.cdt.core.lrparser/META-INF/MANIFEST.MF
View file

@ -9,6 +9,7 @@ Require-Bundle: org.eclipse.cdt.core,
org.eclipse.core.runtime
Export-Package: org.eclipse.cdt.core.dom.lrparser,
org.eclipse.cdt.core.dom.lrparser.action,
org.eclipse.cdt.core.dom.lrparser.action.c99,
org.eclipse.cdt.core.dom.lrparser.c99,
org.eclipse.cdt.core.dom.lrparser.cpp,
org.eclipse.cdt.internal.core.dom.lrparser.c99;x-internal:=true

2
lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/BaseExtensibleLanguage.java
View file

@ -62,7 +62,7 @@ public abstract class BaseExtensibleLanguage extends AbstractLanguage implements
* A token map is used to map tokens from the DOM preprocessor
* to the tokens defined by an LPG parser.
*/
protected abstract ITokenMap getTokenMap();
protected abstract IDOMTokenMap getTokenMap();
/**

19
lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/CPreprocessorAdapter.java
View file

@ -14,7 +14,6 @@ import lpg.lpgjavaruntime.IToken;
import lpg.lpgjavaruntime.Token;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.lrparser.action.ITokenMap;
import org.eclipse.cdt.core.parser.EndOfFileException;
import org.eclipse.cdt.core.parser.IScanner;
@ -40,9 +39,7 @@ class CPreprocessorAdapter {
private static final int DUMMY_TOKEN_KIND = 0;
private static final int tCOMPLETION = org.eclipse.cdt.core.parser.IToken.tCOMPLETION;
private static final int tEND_OF_INPUT = org.eclipse.cdt.core.parser.IToken.tEND_OF_INPUT;
private static final int tEOC = org.eclipse.cdt.core.parser.IToken.tEOC;
@ -53,7 +50,7 @@ class CPreprocessorAdapter {
* TODO: should preprocessor.nextTokenRaw() be called instead?
*/
@SuppressWarnings("restriction")
public static void runCPreprocessor(IScanner preprocessor, ITokenCollector tokenCollector, ITokenMap tokenMap, IASTTranslationUnit tu) {
public static void runCPreprocessor(IScanner preprocessor, ITokenCollector tokenCollector, IDOMTokenMap tokenMap, IASTTranslationUnit tu) {
// LPG requires that the token stream start with a dummy token
tokenCollector.addToken(createDummyToken());
@ -62,12 +59,12 @@ class CPreprocessorAdapter {
try {
while(true) {
org.eclipse.cdt.core.parser.IToken domToken = preprocessor.nextToken(); // throws EndOfFileException
int type = domToken.getType();
int newKind = tokenMap.mapKind(type);
int newKind = tokenMap.mapKind(domToken);
IToken token = new LPGTokenAdapter(domToken, newKind);
tokenCollector.addToken(token);
int type = domToken.getType();
if(type == tCOMPLETION) {
// the token after the completion token must be an EOC token
org.eclipse.cdt.core.parser.IToken domEocToken = preprocessor.nextToken();
@ -90,16 +87,16 @@ class CPreprocessorAdapter {
private static IToken createEOCToken(org.eclipse.cdt.core.parser.IToken domEocToken, ITokenMap tokenMap) {
return new LPGTokenAdapter(domEocToken, tokenMap.mapKind(domEocToken.getType()));
private static IToken createEOCToken(org.eclipse.cdt.core.parser.IToken domEocToken, IDOMTokenMap tokenMap) {
return new LPGTokenAdapter(domEocToken, tokenMap.mapKind(domEocToken));
}
private static IToken createDummyToken() {
return new Token(null, 0, 0, DUMMY_TOKEN_KIND);
}
private static IToken createEOFToken(ITokenMap tokenMap) {
return new Token(null, 0, 0, tokenMap.mapKind(tEND_OF_INPUT));
private static IToken createEOFToken(IDOMTokenMap tokenMap) {
return new Token(null, 0, 0, tokenMap.getEOFTokenKind());
}

22
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/UPCLexerFactory.java → lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/IDOMTokenMap.java
View file

@ -1,5 +1,5 @@
/*******************************************************************************
* Copyright (c) 2006, 2007 IBM Corporation and others.
* Copyright (c) 2006, 2008 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@ -8,19 +8,19 @@
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.cdt.internal.core.dom.parser.upc;
package org.eclipse.cdt.core.dom.lrparser;
import org.eclipse.cdt.core.dom.c99.ILexer;
import org.eclipse.cdt.core.dom.c99.ILexerFactory;
import org.eclipse.cdt.core.parser.CodeReader;
import org.eclipse.cdt.core.parser.IToken;
/**
* Creates new lexers for tokenizing included files.
* Maps tokens returned by CPreprocessor to the corresponding
* token kind used by an LPG based parser.
*
* @author Mike Kucera
*
*/
public class UPCLexerFactory implements ILexerFactory {
public ILexer createLexer(CodeReader reader) {
return new UPCLexer(reader);
}
public interface IDOMTokenMap {
int mapKind(IToken token);
int getEOFTokenKind();
}

4
lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/ITokenMap.java
View file

@ -16,10 +16,6 @@ package org.eclipse.cdt.core.dom.lrparser.action;
* Maps tokens defined in parser extensions back to the token kinds
* defined in the lr parsers.
*
* When LPG is used to generate a parser extension it will
* generate all-new token kinds. In order for the semantic actions to be able
* to interpret these token kinds correctly they will be mapped back
* to the token kinds defined in C99Parsersym.
*
* @author Mike Kucera
*/

23
lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/action/c99/C99BuildASTParserAction.java
View file

@ -217,13 +217,18 @@ public class C99BuildASTParserAction extends BuildASTParserAction {
/**
* Sets a token specifier.
* Needs to be overrideable for new decl spec keywords.
* Applies a specifier to a decl spec node.
*
* @param token Allows subclasses to override this method and use any
* object to determine how to set a specifier.
* In plain C99 specifiers are always just single tokens, but in language
* extensions specifiers may be more complex. Thats why this method takes
* Object as the type of the specifier, so that it may be overridden in subclasses
* and used with arbitray objects as the specifier.
*/
protected void setSpecifier(ICASTDeclSpecifier node, IToken token) {
protected void setSpecifier(ICASTDeclSpecifier node, Object specifier) {
if(!(specifier instanceof IToken))
return;
IToken token = (IToken)specifier;
int kind = asC99Kind(token);
switch(kind){
case TK_typedef: node.setStorageClass(IASTDeclSpecifier.sc_typedef); return;
@ -479,8 +484,8 @@ public class C99BuildASTParserAction extends BuildASTParserAction {
ICASTSimpleDeclSpecifier declSpec = nodeFactory.newCSimpleDeclSpecifier();
for(Object token : astStack.closeScope())
setSpecifier(declSpec, (IToken)token);
for(Object specifier : astStack.closeScope())
setSpecifier(declSpec, specifier);
setOffsetAndLength(declSpec);
astStack.push(declSpec);
@ -500,8 +505,8 @@ public class C99BuildASTParserAction extends BuildASTParserAction {
ICASTDeclSpecifier declSpec = CollectionUtils.findFirstAndRemove(topScope, ICASTDeclSpecifier.class);
// now apply the rest of the specifiers
for(Object token : topScope)
setSpecifier(declSpec, (IToken)token);
for(Object specifier : topScope)
setSpecifier(declSpec, specifier);
setOffsetAndLength(declSpec);
astStack.push(declSpec);

8
lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/c99/C99Language.java
View file

@ -15,10 +15,9 @@ import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.gnu.c.GCCLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.IDOMTokenMap;
import org.eclipse.cdt.core.dom.lrparser.IParser;
import org.eclipse.cdt.core.dom.lrparser.action.ITokenMap;
import org.eclipse.cdt.core.dom.lrparser.action.c99.C99ASTNodeFactory;
import org.eclipse.cdt.core.dom.lrparser.action.cpp.CPPASTNodeFactory;
import org.eclipse.cdt.core.index.IIndex;
import org.eclipse.cdt.core.model.IContributedModelBuilder;
import org.eclipse.cdt.core.model.ITranslationUnit;
@ -26,7 +25,6 @@ import org.eclipse.cdt.core.parser.IScanner;
import org.eclipse.cdt.core.parser.ParserLanguage;
import org.eclipse.cdt.internal.core.dom.lrparser.c99.C99Parser;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTTranslationUnit;
import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTTranslationUnit;
/**
* ILanguage implementation for the C99 parser.
@ -38,7 +36,7 @@ public class C99Language extends BaseExtensibleLanguage {
public static final String PLUGIN_ID = "org.eclipse.cdt.core.lrparser"; //$NON-NLS-1$
public static final String ID = PLUGIN_ID + ".c99"; //$NON-NLS-1$
private static final ITokenMap TOKEN_MAP = DOMToC99TokenMap.DEFAULT_MAP;
private static final IDOMTokenMap TOKEN_MAP = DOMToC99TokenMap.DEFAULT_MAP;
private static GCCLanguage GCC_LANGUAGE = GCCLanguage.getDefault();
@ -55,7 +53,7 @@ public class C99Language extends BaseExtensibleLanguage {
}
@Override
protected ITokenMap getTokenMap() {
protected IDOMTokenMap getTokenMap() {
return TOKEN_MAP;
}

16
lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/c99/DOMToC99TokenMap.java
View file

@ -13,7 +13,8 @@ package org.eclipse.cdt.core.dom.lrparser.c99;
import static org.eclipse.cdt.core.parser.IToken.*;
import static org.eclipse.cdt.internal.core.dom.lrparser.c99.C99Parsersym.*;
import org.eclipse.cdt.core.dom.lrparser.action.ITokenMap;
import org.eclipse.cdt.core.dom.lrparser.IDOMTokenMap;
import org.eclipse.cdt.core.parser.IToken;
/**
* Maps tokens types returned by CPreprocessor to token types
@ -28,7 +29,7 @@ import org.eclipse.cdt.core.dom.lrparser.action.ITokenMap;
* @author Mike Kucera
*
*/
public final class DOMToC99TokenMap implements ITokenMap {
public final class DOMToC99TokenMap implements IDOMTokenMap {
public static final DOMToC99TokenMap DEFAULT_MAP = new DOMToC99TokenMap();
@ -37,9 +38,9 @@ public final class DOMToC99TokenMap implements ITokenMap {
// just a private constructor
}
public int mapKind(int kind) {
public int mapKind(IToken token) {
switch(kind) {
switch(token.getType()) {
case tIDENTIFIER : return TK_identifier;
case tINTEGER : return TK_integer;
case tCOLON : return TK_Colon;
@ -137,9 +138,14 @@ public final class DOMToC99TokenMap implements ITokenMap {
case tEND_OF_INPUT : return TK_EOF_TOKEN;
default:
assert false : "token not recognized by the C99 parser: " + kind; //$NON-NLS-1$
assert false : "token not recognized by the C99 parser: " + token.getType(); //$NON-NLS-1$
return TK_Invalid;
}
}
public int getEOFTokenKind() {
return TK_EOF_TOKEN;
}
}

18
lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/cpp/DOMToISOCPPTokenMap.java
View file

@ -10,11 +10,12 @@
*******************************************************************************/
package org.eclipse.cdt.core.dom.lrparser.cpp;
import org.eclipse.cdt.core.dom.lrparser.action.ITokenMap;
import static org.eclipse.cdt.core.parser.IToken.*;
import static org.eclipse.cdt.internal.core.dom.lrparser.cpp.CPPParsersym.*;
import org.eclipse.cdt.core.dom.lrparser.IDOMTokenMap;
import org.eclipse.cdt.core.parser.IToken;
/**
* Maps tokens types returned by CPreprocessor to token types
* expected by the C++ parser.
@ -27,7 +28,7 @@ import static org.eclipse.cdt.internal.core.dom.lrparser.cpp.CPPParsersym.*;
* @author Mike Kucera
*
*/
public class DOMToISOCPPTokenMap implements ITokenMap {
public class DOMToISOCPPTokenMap implements IDOMTokenMap {
public static final DOMToISOCPPTokenMap DEFAULT_MAP = new DOMToISOCPPTokenMap();
@ -36,9 +37,9 @@ public class DOMToISOCPPTokenMap implements ITokenMap {
// just a private constructor
}
public int mapKind(int kind) {
public int mapKind(IToken token) {
switch(kind) {
switch(token.getType()) {
case tIDENTIFIER : return TK_identifier;
case tINTEGER : return TK_integer;
case tCOLONCOLON : return TK_ColonColon;
@ -166,9 +167,14 @@ public class DOMToISOCPPTokenMap implements ITokenMap {
case tEND_OF_INPUT : return TK_EOF_TOKEN;
default:
assert false : "token not recognized by the ISO CPP parser: " + kind; //$NON-NLS-1$
assert false : "token not recognized by the ISO CPP parser: " + token.getType(); //$NON-NLS-1$
return TK_Invalid;
}
}
public int getEOFTokenKind() {
return TK_EOF_TOKEN;
}
}

6
lrparser/org.eclipse.cdt.core.lrparser/src/org/eclipse/cdt/core/dom/lrparser/cpp/ISOCPPLanguage.java
View file

@ -15,8 +15,8 @@ import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.IDOMTokenMap;
import org.eclipse.cdt.core.dom.lrparser.IParser;
import org.eclipse.cdt.core.dom.lrparser.action.ITokenMap;
import org.eclipse.cdt.core.dom.lrparser.action.cpp.CPPASTNodeFactory;
import org.eclipse.cdt.core.index.IIndex;
import org.eclipse.cdt.core.model.IContributedModelBuilder;
@ -36,7 +36,7 @@ public class ISOCPPLanguage extends BaseExtensibleLanguage {
public static final String PLUGIN_ID = "org.eclipse.cdt.core.lrparser"; //$NON-NLS-1$
public static final String ID = PLUGIN_ID + ".isocpp"; //$NON-NLS-1$
private static final ITokenMap TOKEN_MAP = DOMToISOCPPTokenMap.DEFAULT_MAP;
private static final IDOMTokenMap TOKEN_MAP = DOMToISOCPPTokenMap.DEFAULT_MAP;
private static GPPLanguage GPP_LANGUAGE = GPPLanguage.getDefault();
@ -53,7 +53,7 @@ public class ISOCPPLanguage extends BaseExtensibleLanguage {
}
@Override
protected ITokenMap getTokenMap() {
protected IDOMTokenMap getTokenMap() {
return TOKEN_MAP;
}

6
upc/org.eclipse.cdt.core.parser.upc.tests/META-INF/MANIFEST.MF
View file

@ -5,12 +5,12 @@ Bundle-SymbolicName: org.eclipse.cdt.core.parser.upc.tests
Bundle-Version: 4.0.0.qualifier
Require-Bundle: org.eclipse.core.runtime,
org.junit,
org.eclipse.cdt.core.parser.c99,
org.eclipse.cdt.core.tests,
org.eclipse.cdt.core,
org.eclipse.core.resources,
org.eclipse.cdt.core.parser.c99.tests,
org.eclipse.cdt.core.parser.upc
org.eclipse.cdt.core.parser.upc,
org.eclipse.cdt.core.lrparser;bundle-version="4.0.1",
org.eclipse.cdt.core.lrparser.tests;bundle-version="4.0.0"
Eclipse-LazyStart: false
Bundle-Vendor: %Bundle-Vendor.0
Bundle-Localization: plugin

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99CommentTests.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99CommentTests;
import org.eclipse.cdt.core.lrparser.tests.c99.C99CommentTests;
public class UPCC99CommentTests extends C99CommentTests {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99CompleteParser2Tests.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99CompleteParser2Tests;
import org.eclipse.cdt.core.lrparser.tests.c99.C99CompleteParser2Tests;
public class UPCC99CompleteParser2Tests extends C99CompleteParser2Tests {

6
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99CompletionBasicTest.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.c99.C99Language;
import org.eclipse.cdt.core.parser.c99.tests.C99CompletionBasicTest;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.c99.C99Language;
import org.eclipse.cdt.core.lrparser.tests.c99.C99CompletionBasicTest;
public class UPCC99CompletionBasicTest extends C99CompletionBasicTest {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99CompletionParseTest.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99CompletionParseTest;
import org.eclipse.cdt.core.lrparser.tests.c99.C99CompletionParseTest;
public class UPCC99CompletionParseTest extends C99CompletionParseTest {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99DOMLocationInclusionTests.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99DOMLocationInclusionTests;
import org.eclipse.cdt.core.lrparser.tests.c99.C99DOMLocationInclusionTests;
public class UPCC99DOMLocationInclusionTests extends C99DOMLocationInclusionTests {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99DOMLocationMacroTests.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99DOMLocationMacroTests;
import org.eclipse.cdt.core.lrparser.tests.c99.C99DOMLocationMacroTests;
public class UPCC99DOMLocationMacroTests extends C99DOMLocationMacroTests {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99DOMLocationTests.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99DOMLocationTests;
import org.eclipse.cdt.core.lrparser.tests.c99.C99DOMLocationTests;
public class UPCC99DOMLocationTests extends C99DOMLocationTests {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99DOMPreprocessorInformationTest.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99DOMPreprocessorInformationTest;
import org.eclipse.cdt.core.lrparser.tests.c99.C99DOMPreprocessorInformationTest;
public class UPCC99DOMPreprocessorInformationTest extends C99DOMPreprocessorInformationTest {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99DigraphTrigraphTests.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99DigraphTrigraphTests;
import org.eclipse.cdt.core.lrparser.tests.c99.C99DigraphTrigraphTests;
public class UPCC99DigraphTrigraphTests extends C99DigraphTrigraphTests {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99GCCTests.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99GCCTests;
import org.eclipse.cdt.core.lrparser.tests.c99.C99GCCTests;
public class UPCC99GCCTests extends C99GCCTests {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99KnRTests.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99KnRTests;
import org.eclipse.cdt.core.lrparser.tests.c99.C99KnRTests;
public class UPCC99KnRTests extends C99KnRTests {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99SelectionParseTest.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99SelectionParseTest;
import org.eclipse.cdt.core.lrparser.tests.c99.C99SelectionParseTest;
public class UPCC99SelectionParseTest extends C99SelectionParseTest {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99SpecTests.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99SpecTests;
import org.eclipse.cdt.core.lrparser.tests.c99.C99SpecTests;
public class UPCC99SpecTests extends C99SpecTests {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99TaskParserTest.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99TaskParserTest;
import org.eclipse.cdt.core.lrparser.tests.c99.C99TaskParserTest;
public class UPCC99TaskParserTest extends C99TaskParserTest {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99Tests.java
View file

@ -12,9 +12,9 @@ package org.eclipse.cdt.core.parser.upc.tests;
import junit.framework.TestSuite;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99Tests;
import org.eclipse.cdt.core.lrparser.tests.c99.C99Tests;
/**
* Run the C99 tests against the UPC parser
*

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99UtilOldTests.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99UtilOldTests;
import org.eclipse.cdt.core.lrparser.tests.c99.C99UtilOldTests;
public class UPCC99UtilOldTests extends C99UtilOldTests {

4
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCC99UtilTests.java
View file

@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.cdt.core.parser.upc.tests;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.parser.c99.tests.C99UtilTests;
import org.eclipse.cdt.core.lrparser.tests.c99.C99UtilTests;
public class UPCC99UtilTests extends C99UtilTests {

32
upc/org.eclipse.cdt.core.parser.upc.tests/src/org/eclipse/cdt/core/parser/upc/tests/UPCLanguageExtensionTests.java
View file

@ -33,15 +33,15 @@ import org.eclipse.cdt.core.dom.ast.IASTTypeIdExpression;
import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression;
import org.eclipse.cdt.core.dom.ast.IScope;
import org.eclipse.cdt.core.dom.ast.IVariable;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.upc.UPCLanguage;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTDeclSpecifier;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTForallStatement;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTKeywordExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSimpleDeclSpecifier;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSizeofExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSynchronizationStatement;
import org.eclipse.cdt.core.parser.c99.tests.ParseHelper;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTUnaryExpression;
import org.eclipse.cdt.core.lrparser.tests.ParseHelper;
import org.eclipse.cdt.internal.core.parser.ParserException;
public class UPCLanguageExtensionTests extends TestCase {
@ -494,24 +494,24 @@ public class UPCLanguageExtensionTests extends TestCase {
IASTUnaryExpression cexpr = (IASTUnaryExpression)((IASTExpressionStatement)body[1]).getExpression();
assertEquals(IASTUnaryExpression.op_sizeof, cexpr.getOperator());
IUPCASTSizeofExpression expr;
IUPCASTUnaryExpression expr;
expr = (IUPCASTSizeofExpression)((IASTExpressionStatement)body[2]).getExpression();
assertEquals(IUPCASTSizeofExpression.op_upc_localsizeof, expr.getUPCSizeofOperator());
expr = (IUPCASTUnaryExpression)((IASTExpressionStatement)body[2]).getExpression();
assertEquals(IUPCASTUnaryExpression.op_upc_localsizeof, expr.getOperator());
expr = (IUPCASTSizeofExpression)((IASTExpressionStatement)body[3]).getExpression();
assertEquals(IUPCASTSizeofExpression.op_upc_localsizeof, expr.getUPCSizeofOperator());
expr = (IUPCASTUnaryExpression)((IASTExpressionStatement)body[3]).getExpression();
assertEquals(IUPCASTUnaryExpression.op_upc_localsizeof, expr.getOperator());
expr = (IUPCASTSizeofExpression)((IASTExpressionStatement)body[4]).getExpression();
assertEquals(IUPCASTSizeofExpression.op_upc_blocksizeof, expr.getUPCSizeofOperator());
expr = (IUPCASTUnaryExpression)((IASTExpressionStatement)body[4]).getExpression();
assertEquals(IUPCASTUnaryExpression.op_upc_blocksizeof, expr.getOperator());
expr = (IUPCASTSizeofExpression)((IASTExpressionStatement)body[5]).getExpression();
assertEquals(IUPCASTSizeofExpression.op_upc_blocksizeof, expr.getUPCSizeofOperator());
expr = (IUPCASTUnaryExpression)((IASTExpressionStatement)body[5]).getExpression();
assertEquals(IUPCASTUnaryExpression.op_upc_blocksizeof, expr.getOperator());
expr = (IUPCASTSizeofExpression)((IASTExpressionStatement)body[6]).getExpression();
assertEquals(IUPCASTSizeofExpression.op_upc_elemsizeof, expr.getUPCSizeofOperator());
expr = (IUPCASTUnaryExpression)((IASTExpressionStatement)body[6]).getExpression();
assertEquals(IUPCASTUnaryExpression.op_upc_elemsizeof, expr.getOperator());
expr = (IUPCASTSizeofExpression)((IASTExpressionStatement)body[7]).getExpression();
assertEquals(IUPCASTSizeofExpression.op_upc_elemsizeof, expr.getUPCSizeofOperator());
expr = (IUPCASTUnaryExpression)((IASTExpressionStatement)body[7]).getExpression();
assertEquals(IUPCASTUnaryExpression.op_upc_elemsizeof, expr.getOperator());
}
}

2
upc/org.eclipse.cdt.core.parser.upc/META-INF/MANIFEST.MF
View file

@ -7,7 +7,7 @@ Bundle-ClassPath: .
Require-Bundle: org.eclipse.cdt.core,
net.sourceforge.lpg.lpgjavaruntime;bundle-version="1.1.0";visibility:=reexport,
org.eclipse.core.runtime,
org.eclipse.cdt.core.parser.c99
org.eclipse.cdt.core.lrparser;bundle-version="4.0.1"
Export-Package: org.eclipse.cdt.core.dom.upc,
org.eclipse.cdt.core.dom.upc.ast,
org.eclipse.cdt.internal.core.dom.parser.upc;x-internal:=true,

0
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/UPCParser.g → upc/org.eclipse.cdt.core.parser.upc/grammar/UPCParser.g
View file

153
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/core/dom/parser/upc/DOMToUPCTokenMap.java Normal file
View file

@ -0,0 +1,153 @@
/*******************************************************************************
* Copyright (c) 2006, 2007 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.cdt.core.dom.parser.upc;
import static org.eclipse.cdt.core.parser.IToken.*;
import static org.eclipse.cdt.internal.core.dom.parser.upc.UPCParsersym.*;
import org.eclipse.cdt.core.dom.lrparser.IDOMTokenMap;
import org.eclipse.cdt.core.parser.IToken;
import org.eclipse.cdt.core.parser.util.CharArrayMap;
import org.eclipse.cdt.internal.core.dom.parser.upc.UPCParsersym;
/**
* Maps token kinds from CPreprocessor to the tokens kinds
* created by LPG.
*
* TODO UPC keywords need to be syntax highlighted
*
* @author Mike Kucera
*/
@SuppressWarnings("nls")
public class DOMToUPCTokenMap implements IDOMTokenMap {
public int mapKind(IToken token) {
switch(token.getType()) {
case tIDENTIFIER :
Integer keywordKind = UPCKeyword.getTokenKind(token.getCharImage());
return keywordKind == null ? TK_identifier : keywordKind;
case tINTEGER : return TK_integer;
case tCOLON : return TK_Colon;
case tSEMI : return TK_SemiColon;
case tCOMMA : return TK_Comma;
case tQUESTION : return TK_Question;
case tLPAREN : return TK_LeftParen;
case tRPAREN : return TK_RightParen;
case tLBRACKET : return TK_LeftBracket;
case tRBRACKET : return TK_RightBracket;
case tLBRACE : return TK_LeftBrace;
case tRBRACE : return TK_RightBrace;
case tPLUSASSIGN : return TK_PlusAssign;
case tINCR : return TK_PlusPlus;
case tPLUS : return TK_Plus;
case tMINUSASSIGN : return TK_MinusAssign;
case tDECR : return TK_MinusMinus;
case tARROW : return TK_Arrow;
case tMINUS : return TK_Minus;
case tSTARASSIGN : return TK_StarAssign;
case tSTAR : return TK_Star;
case tMODASSIGN : return TK_PercentAssign;
case tMOD : return TK_Percent;
case tXORASSIGN : return TK_CaretAssign;
case tXOR : return TK_Caret;
case tAMPERASSIGN : return TK_AndAssign;
case tAND : return TK_AndAnd;
case tAMPER : return TK_And;
case tBITORASSIGN : return TK_OrAssign;
case tOR : return TK_OrOr;
case tBITOR : return TK_Or;
case tBITCOMPLEMENT: return TK_Tilde;
case tNOTEQUAL : return TK_NE;
case tNOT : return TK_Bang;
case tEQUAL : return TK_EQ;
case tASSIGN : return TK_Assign;
case tUNKNOWN_CHAR : return TK_Invalid;
case tSHIFTL : return TK_LeftShift;
case tLTEQUAL : return TK_LE;
case tLT : return TK_LT;
case tSHIFTRASSIGN : return TK_RightShiftAssign;
case tSHIFTR : return TK_RightShift;
case tGTEQUAL : return TK_GE;
case tGT : return TK_GT;
case tSHIFTLASSIGN : return TK_LeftShiftAssign;
case tELLIPSIS : return TK_DotDotDot;
case tDOT : return TK_Dot;
case tDIVASSIGN : return TK_SlashAssign;
case tDIV : return TK_Slash;
case t_auto : return TK_auto;
case t_break : return TK_break;
case t_case : return TK_case;
case t_char : return TK_char;
case t_const : return TK_const;
case t_continue : return TK_continue;
case t_default : return TK_default;
case t_do : return TK_do;
case t_double : return TK_double;
case t_else : return TK_else;
case t_enum : return TK_enum;
case t_extern : return TK_extern;
case t_float : return TK_float;
case t_for : return TK_for;
case t_goto : return TK_goto;
case t_if : return TK_if;
case t_inline : return TK_inline;
case t_int : return TK_int;
case t_long : return TK_long;
case t_register : return TK_register;
case t_return : return TK_return;
case t_short : return TK_short;
case t_sizeof : return TK_sizeof;
case t_static : return TK_static;
case t_signed : return TK_signed;
case t_struct : return TK_struct;
case t_switch : return TK_switch;
case t_typedef : return TK_typedef;
case t_union : return TK_union;
case t_unsigned : return TK_unsigned;
case t_void : return TK_void;
case t_volatile : return TK_volatile;
case t_while : return TK_while;
case tFLOATINGPT : return TK_floating;
case tSTRING : return TK_stringlit;
case tLSTRING : return TK_stringlit;
case tCHAR : return TK_charconst;
case tLCHAR : return TK_charconst;
case t__Bool : return TK__Bool;
case t__Complex : return TK__Complex;
case t__Imaginary : return TK__Imaginary;
case t_restrict : return TK_restrict;
case tCOMPLETION : return TK_Completion;
case tEOC : return TK_EndOfCompletion;
case tEND_OF_INPUT : return TK_EOF_TOKEN;
default:
assert false : "token not recognized by the UPC parser: " + token.getType();
return TK_Invalid;
}
}
protected String[] getOrderedTerminalSymbols() {
return UPCParsersym.orderedTerminalSymbols;
}
public int getEOFTokenKind() {
return TK_EOF_TOKEN;
}
}

56
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/core/dom/parser/upc/UPCASTNodeFactory.java
View file

@ -1,5 +1,5 @@
/*******************************************************************************
* Copyright (c) 2006, 2007 IBM Corporation and others.
* Copyright (c) 2006, 2008 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
@ -10,72 +10,90 @@
*******************************************************************************/
package org.eclipse.cdt.core.dom.parser.upc;
import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTStatement;
import org.eclipse.cdt.core.dom.ast.IASTTypeId;
import org.eclipse.cdt.core.dom.ast.IASTTypeIdExpression;
import org.eclipse.cdt.core.dom.ast.c.ICASTCompositeTypeSpecifier;
import org.eclipse.cdt.core.dom.ast.c.ICASTElaboratedTypeSpecifier;
import org.eclipse.cdt.core.dom.ast.c.ICASTEnumerationSpecifier;
import org.eclipse.cdt.core.dom.ast.c.ICASTSimpleDeclSpecifier;
import org.eclipse.cdt.core.dom.ast.c.ICASTTypedefNameSpecifier;
import org.eclipse.cdt.core.dom.parser.c99.C99ASTNodeFactory;
import org.eclipse.cdt.core.dom.lrparser.action.c99.C99ASTNodeFactory;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTForallStatement;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTKeywordExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSizeofExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSynchronizationStatement;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTUnaryExpression;
import org.eclipse.cdt.internal.core.dom.parser.upc.ast.UPCASTCompositeTypeSpecifier;
import org.eclipse.cdt.internal.core.dom.parser.upc.ast.UPCASTElaboratedTypeSpecifier;
import org.eclipse.cdt.internal.core.dom.parser.upc.ast.UPCASTEnumerationSpecifier;
import org.eclipse.cdt.internal.core.dom.parser.upc.ast.UPCASTForallStatement;
import org.eclipse.cdt.internal.core.dom.parser.upc.ast.UPCASTKeywordExpression;
import org.eclipse.cdt.internal.core.dom.parser.upc.ast.UPCASTSimpleDeclSpecifier;
import org.eclipse.cdt.internal.core.dom.parser.upc.ast.UPCASTSizeofExpression;
import org.eclipse.cdt.internal.core.dom.parser.upc.ast.UPCASTSynchronizationStatement;
import org.eclipse.cdt.internal.core.dom.parser.upc.ast.UPCASTTypeIdExpression;
import org.eclipse.cdt.internal.core.dom.parser.upc.ast.UPCASTTypedefNameSpecifier;
import org.eclipse.cdt.internal.core.dom.parser.upc.ast.UPCASTUnaryExpression;
/**
* Creates AST nodes that are specific to the UPC parser.
*
* The methods in ASTNodeFactory that build nodes for declaration
* specifiers are overridden here to replace thos nodes with the UPC nodes for
* specifiers are overridden here to replace those nodes with the UPC nodes for
* declaration specifiers. These UPC specific nodes add support
* for 'strict', 'relaxed' and 'shared'.
*/
public class UPCASTNodeFactory extends C99ASTNodeFactory {
public IUPCASTKeywordExpression newKeywordExpression() {
return new UPCASTKeywordExpression();
@Override
public IASTTypeIdExpression newTypeIdExpression(int operator, IASTTypeId typeId) {
return new UPCASTTypeIdExpression(operator, typeId);
}
public IUPCASTKeywordExpression newKeywordExpression(int keywordKind) {
return new UPCASTKeywordExpression(keywordKind);
}
public IUPCASTSizeofExpression newSizeofExpression() {
return new UPCASTSizeofExpression();
@Override
public IUPCASTUnaryExpression newUnaryExpression(int operator, IASTExpression operand) {
return new UPCASTUnaryExpression(operator, operand);
}
public IUPCASTSynchronizationStatement newSyncronizationStatment() {
return new UPCASTSynchronizationStatement();
public IUPCASTSynchronizationStatement newSyncronizationStatment(IASTExpression barrierExpression, int statmentKind) {
return new UPCASTSynchronizationStatement(barrierExpression, statmentKind);
}
public IUPCASTForallStatement newForallStatement() {
return new UPCASTForallStatement();
public IUPCASTForallStatement newForallStatement(IASTStatement init, IASTExpression condition,
IASTExpression iterationExpression, IASTStatement body, IASTExpression affinity) {
return new UPCASTForallStatement(init, condition, iterationExpression, body, affinity);
}
/**
* Override to return UPC version of decl specifier.
*/
@Override
public ICASTSimpleDeclSpecifier newCSimpleDeclSpecifier() {
return new UPCASTSimpleDeclSpecifier();
}
public ICASTCompositeTypeSpecifier newCCompositeTypeSpecifier() {
return new UPCASTCompositeTypeSpecifier();
@Override
public ICASTCompositeTypeSpecifier newCCompositeTypeSpecifier(int key, IASTName name) {
return new UPCASTCompositeTypeSpecifier(key, name);
}
public ICASTElaboratedTypeSpecifier newCElaboratedTypeSpecifier() {
return new UPCASTElaboratedTypeSpecifier();
@Override
public ICASTElaboratedTypeSpecifier newElaboratedTypeSpecifier(int kind, IASTName name) {
return new UPCASTElaboratedTypeSpecifier(kind, name);
}
public ICASTEnumerationSpecifier newCEnumerationSpecifier() {
return new UPCASTEnumerationSpecifier();
@Override
public ICASTEnumerationSpecifier newEnumerationSpecifier(IASTName name) {
return new UPCASTEnumerationSpecifier(name);
}
@Override
public ICASTTypedefNameSpecifier newCTypedefNameSpecifier() {
return new UPCASTTypedefNameSpecifier();
}

69
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/core/dom/parser/upc/UPCKeyword.java Normal file
View file

@ -0,0 +1,69 @@
package org.eclipse.cdt.core.dom.parser.upc;
import static org.eclipse.cdt.internal.core.dom.parser.upc.UPCParsersym.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.eclipse.cdt.core.dom.lrparser.c99.C99Language;
import org.eclipse.cdt.core.parser.util.CharArrayMap;
/**
* Enumeration of keywords that UPC adds to C99.
*
* @author Mike Kucera
*/
public enum UPCKeyword {
MYTHREAD(TK_MYTHREAD),
THREADS(TK_THREADS),
UPC_MAX_BLOCKSIZE(TK_UPC_MAX_BLOCKSIZE),
relaxed(TK_relaxed),
shared(TK_shared),
strict(TK_strict),
upc_barrier(TK_upc_barrier),
upc_localsizeof(TK_upc_localsizeof),
upc_blocksizeof(TK_upc_blocksizeof),
upc_elemsizeof(TK_upc_elemsizeof),
upc_notify(TK_upc_notify),
upc_fence(TK_upc_fence),
upc_wait(TK_upc_wait),
upc_forall(TK_upc_forall);
private final int tokenKind;
private static List<String> names = new ArrayList<String>();
private static final CharArrayMap<Integer> tokenMap = new CharArrayMap<Integer>();
UPCKeyword(int tokenKind) {
this.tokenKind = tokenKind;
}
static { // cannot refer to static fields from constructor
for(UPCKeyword keyword : values()) {
String name = keyword.name();
names.add(name);
tokenMap.put(name.toCharArray(), keyword.tokenKind);
}
}
public int getTokenKind() {
return tokenKind;
}
public static String[] getUPCOnlyKeywords() {
return names.toArray(new String[names.size()]);
}
public static String[] getAllKeywords() {
List<String> allKeywords = new ArrayList<String>(names);
allKeywords.addAll(Arrays.asList(C99Language.getDefault().getKeywords()));
return allKeywords.toArray(new String[allKeywords.size()]);
}
public static Integer getTokenKind(char[] image) {
return tokenMap.get(image);
}
}

106
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/core/dom/parser/upc/UPCKeywordMap.java
View file

@ -1,106 +0,0 @@
/*******************************************************************************
* Copyright (c) 2006, 2007 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.cdt.core.dom.parser.upc;
import org.eclipse.cdt.core.dom.parser.c99.LPGKeywordMap;
import org.eclipse.cdt.core.dom.parser.c99.C99KeywordMap;
import org.eclipse.cdt.internal.core.dom.parser.upc.UPCParsersym;
/**
* Provides UPC specific keywords in addition to the C99 keywords.
*
* Keyword token mappings from the superclass must be overridden.
*
* @author Mike Kucera
*/
public class UPCKeywordMap extends LPGKeywordMap {
public UPCKeywordMap() {
putKeyword(UPCParsersym.TK_MYTHREAD);
putKeyword(UPCParsersym.TK_THREADS);
putKeyword(UPCParsersym.TK_UPC_MAX_BLOCKSIZE);
putKeyword(UPCParsersym.TK_relaxed);
putKeyword(UPCParsersym.TK_shared);
putKeyword(UPCParsersym.TK_strict);
putKeyword(UPCParsersym.TK_upc_barrier);
putKeyword(UPCParsersym.TK_upc_localsizeof);
putKeyword(UPCParsersym.TK_upc_blocksizeof);
putKeyword(UPCParsersym.TK_upc_elemsizeof);
putKeyword(UPCParsersym.TK_upc_notify);
putKeyword(UPCParsersym.TK_upc_fence);
putKeyword(UPCParsersym.TK_upc_wait);
putKeyword(UPCParsersym.TK_upc_forall);
// The keyword token mappings from the superclass must be overridden.
// This is because LPG generates totally different values for token
// kinds every time you generate a parser.
putKeyword(UPCParsersym.TK_auto);
putKeyword(UPCParsersym.TK_break);
putKeyword(UPCParsersym.TK_case);
putKeyword(UPCParsersym.TK_char);
putKeyword(UPCParsersym.TK_const);
putKeyword(UPCParsersym.TK_continue);
putKeyword(UPCParsersym.TK_default);
putKeyword(UPCParsersym.TK_do);
putKeyword(UPCParsersym.TK_double);
putKeyword(UPCParsersym.TK_else);
putKeyword(UPCParsersym.TK_enum);
putKeyword(UPCParsersym.TK_extern);
putKeyword(UPCParsersym.TK_float);
putKeyword(UPCParsersym.TK_for);
putKeyword(UPCParsersym.TK_goto);
putKeyword(UPCParsersym.TK_if);
putKeyword(UPCParsersym.TK_inline);
putKeyword(UPCParsersym.TK_int);
putKeyword(UPCParsersym.TK_long);
putKeyword(UPCParsersym.TK_register);
putKeyword(UPCParsersym.TK_restrict);
putKeyword(UPCParsersym.TK_return);
putKeyword(UPCParsersym.TK_short);
putKeyword(UPCParsersym.TK_signed);
putKeyword(UPCParsersym.TK_sizeof);
putKeyword(UPCParsersym.TK_static);
putKeyword(UPCParsersym.TK_struct);
putKeyword(UPCParsersym.TK_switch);
putKeyword(UPCParsersym.TK_typedef);
putKeyword(UPCParsersym.TK_union);
putKeyword(UPCParsersym.TK_unsigned);
putKeyword(UPCParsersym.TK_void);
putKeyword(UPCParsersym.TK_volatile);
putKeyword(UPCParsersym.TK_while);
putKeyword(UPCParsersym.TK__Bool);
putKeyword(UPCParsersym.TK__Complex);
putKeyword(UPCParsersym.TK__Imaginary);
addBuiltinType(UPCParsersym.TK_char);
addBuiltinType(UPCParsersym.TK_double);
addBuiltinType(UPCParsersym.TK_float);
addBuiltinType(UPCParsersym.TK_int);
addBuiltinType(UPCParsersym.TK_long);
addBuiltinType(UPCParsersym.TK_short);
addBuiltinType(UPCParsersym.TK_signed);
addBuiltinType(UPCParsersym.TK_unsigned);
addBuiltinType(UPCParsersym.TK_void);
addBuiltinType(UPCParsersym.TK__Bool);
addBuiltinType(UPCParsersym.TK__Complex);
addBuiltinType(UPCParsersym.TK__Imaginary);
}
protected String[] getOrderedTerminalSymbols() {
return UPCParsersym.orderedTerminalSymbols;
}
}

146
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/core/dom/parser/upc/UPCParserAction.java
View file

@ -18,19 +18,18 @@ import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.ast.IASTExpressionStatement;
import org.eclipse.cdt.core.dom.ast.IASTNode;
import org.eclipse.cdt.core.dom.ast.IASTStatement;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.IASTTypeId;
import org.eclipse.cdt.core.dom.ast.IASTTypeIdExpression;
import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression;
import org.eclipse.cdt.core.dom.ast.c.ICASTDeclSpecifier;
import org.eclipse.cdt.core.dom.c99.IASTNodeFactory;
import org.eclipse.cdt.core.dom.c99.IParserActionTokenProvider;
import org.eclipse.cdt.core.dom.parser.c99.ASTStack;
import org.eclipse.cdt.core.dom.parser.c99.C99ParserAction;
import org.eclipse.cdt.core.dom.parser.c99.ITokenMap;
import org.eclipse.cdt.core.dom.lrparser.IParserActionTokenProvider;
import org.eclipse.cdt.core.dom.lrparser.action.c99.C99BuildASTParserAction;
import org.eclipse.cdt.core.dom.lrparser.action.c99.IC99ASTNodeFactory;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTDeclSpecifier;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTForallStatement;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTKeywordExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSizeofExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTUnaryExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSynchronizationStatement;
import org.eclipse.cdt.internal.core.dom.parser.upc.UPCParsersym;
@ -39,25 +38,15 @@ import org.eclipse.cdt.internal.core.dom.parser.upc.UPCParsersym;
* Extension to the C99ParserAction that adds support fot building
* an AST with UPC specific nodes.
*/
public class UPCParserAction extends C99ParserAction {
public class UPCParserAction extends C99BuildASTParserAction {
private final UPCASTNodeFactory nodeFactory;
public UPCParserAction(IParserActionTokenProvider parser) {
super(parser);
public UPCParserAction(UPCASTNodeFactory nodeFactory, IParserActionTokenProvider parser, IASTTranslationUnit tu) {
super(nodeFactory, parser, tu);
super.setTokenMap(UPCParsersym.orderedTerminalSymbols);
this.nodeFactory = (UPCASTNodeFactory) super.getNodeFactory();
}
/**
* Adds support for UPC specific nodes.
* Some of the methods in UPCASTNodeFactory are overrides
* and are called up in C99ParserAction.
*/
protected IASTNodeFactory createNodeFactory() {
return new UPCASTNodeFactory();
this.nodeFactory = nodeFactory;
}
@ -70,8 +59,7 @@ public class UPCParserAction extends C99ParserAction {
* constant ::= 'MYTHREAD' | 'THREADS' | 'UPC_MAX_BLOCKSIZE'
*/
public void consumeKeywordExpression(int keywordKind) {
IUPCASTKeywordExpression expr = nodeFactory.newKeywordExpression();
expr.setKeywordKind(keywordKind);
IUPCASTKeywordExpression expr = nodeFactory.newKeywordExpression(keywordKind);
setOffsetAndLength(expr);
astStack.push(expr);
}
@ -83,14 +71,8 @@ public class UPCParserAction extends C99ParserAction {
* | 'upc_elemsizeof' unary_expression
*/
public void consumeExpressionUpcSizeofOperator(int sizeofOp) {
IUPCASTSizeofExpression expr = nodeFactory.newSizeofExpression();
expr.setUPCSizeofOperator(sizeofOp);
IASTExpression operand = (IASTExpression) astStack.pop();
expr.setOperand(operand);
operand.setParent(expr);
operand.setPropertyInParent(IASTUnaryExpression.OPERAND);
IUPCASTUnaryExpression expr = nodeFactory.newUnaryExpression(sizeofOp, operand);
setOffsetAndLength(expr);
astStack.push(expr);
}
@ -103,15 +85,9 @@ public class UPCParserAction extends C99ParserAction {
*/
public void consumeExpressionUpcSizeofTypeName(int sizeofOp) {
IASTTypeId typeId = (IASTTypeId) astStack.pop();
IASTTypeIdExpression expr = nodeFactory.newTypeIdExpression();
expr.setTypeId(typeId);
typeId.setParent(expr);
typeId.setPropertyInParent(IASTTypeIdExpression.TYPE_ID);
IASTTypeIdExpression expr = nodeFactory.newTypeIdExpression(sizeofOp, typeId);
setOffsetAndLength(expr);
astStack.push(expr);
consumeExpressionUpcSizeofOperator(sizeofOp);
}
@ -125,16 +101,8 @@ public class UPCParserAction extends C99ParserAction {
* | 'upc_fence' ';'
*/
public void consumeStatementSynchronizationStatement(int statementKind, boolean hasBarrierExpr) {
IUPCASTSynchronizationStatement statement = nodeFactory.newSyncronizationStatment();
statement.setStatementKind(statementKind);
if(hasBarrierExpr) {
IASTExpression barrierExpression = (IASTExpression) astStack.pop();
statement.setBarrierExpression(barrierExpression);
barrierExpression.setParent(statement);
barrierExpression.setPropertyInParent(IUPCASTSynchronizationStatement.BARRIER_EXPRESSION);
}
IASTExpression barrierExpression = hasBarrierExpr ? (IASTExpression) astStack.pop() : null;
IUPCASTSynchronizationStatement statement = nodeFactory.newSyncronizationStatment(barrierExpression, statementKind);
setOffsetAndLength(statement);
astStack.push(statement);
}
@ -146,72 +114,32 @@ public class UPCParserAction extends C99ParserAction {
* | 'upc_forall' '(' declaration expression ';' expression ';' affinity ')' statement
*/
public void consumeStatementUPCForallLoop(boolean hasExpr1, boolean hasExpr2, boolean hasExpr3, boolean hasAffinity) {
IUPCASTForallStatement forStat = nodeFactory.newForallStatement();
IASTStatement body = (IASTStatement) astStack.pop();
forStat.setBody(body);
body.setParent(forStat);
body.setPropertyInParent(IUPCASTForallStatement.BODY);
boolean affinityContinue = false;
IASTExpression affinity = null;
if(hasAffinity) {
Object o = astStack.pop();
if(o instanceof IASTExpression) {
IASTExpression expr = (IASTExpression)o;
forStat.setAffinityExpression(expr);
expr.setParent(forStat);
expr.setPropertyInParent(IUPCASTForallStatement.AFFINITY);
}
if(o instanceof IToken) {
IToken token = (IToken) o;
assert token.getKind() == UPCParsersym.TK_continue;
forStat.setAffinityContinue(true);
}
if(o instanceof IASTExpression)
affinity = (IASTExpression)o;
else if(o instanceof IToken)
affinityContinue = true;
}
if(hasExpr3) {
IASTExpression expr = (IASTExpression) astStack.pop();
forStat.setIterationExpression(expr);
expr.setParent(forStat);
expr.setPropertyInParent(IUPCASTForallStatement.ITERATION);
}
if(hasExpr2) {
IASTExpression expr = (IASTExpression) astStack.pop();
forStat.setConditionExpression(expr);
expr.setParent(forStat);
expr.setPropertyInParent(IUPCASTForallStatement.CONDITION);
}
IASTExpression expr3 = hasExpr3 ? (IASTExpression) astStack.pop() : null;
IASTExpression expr2 = hasExpr2 ? (IASTExpression) astStack.pop() : null;
IASTStatement initializer = nodeFactory.newNullStatement();
if(hasExpr1) { // may be an expression or a declaration
IASTNode node = (IASTNode) astStack.pop();
if(node instanceof IASTExpression) {
IASTExpressionStatement stat = nodeFactory.newExpressionStatement();
IASTExpression expr = (IASTExpression)node;
stat.setExpression(expr);
expr.setParent(stat);
expr.setPropertyInParent(IASTExpressionStatement.EXPRESSION);
forStat.setInitializerStatement(stat);
stat.setParent(forStat);
stat.setPropertyInParent(IUPCASTForallStatement.INITIALIZER);
}
else if(node instanceof IASTDeclaration) {
IASTDeclarationStatement stat = nodeFactory.newDeclarationStatement();
IASTDeclaration declaration = (IASTDeclaration)node;
stat.setDeclaration(declaration);
declaration.setParent(stat);
declaration.setPropertyInParent(IASTDeclarationStatement.DECLARATION);
forStat.setInitializerStatement(stat);
stat.setParent(forStat);
stat.setPropertyInParent(IUPCASTForallStatement.INITIALIZER);
}
}
else {
forStat.setInitializerStatement(nodeFactory.newNullStatement());
Object node = astStack.pop();
if(node instanceof IASTExpression)
initializer = nodeFactory.newExpressionStatement((IASTExpression)node);
else if(node instanceof IASTDeclaration)
initializer = nodeFactory.newDeclarationStatement((IASTDeclaration)node);
}
IUPCASTForallStatement forStat = nodeFactory.newForallStatement(initializer, expr2, expr3, body, affinity);
forStat.setAffinityContinue(affinityContinue);
setOffsetAndLength(forStat);
astStack.push(forStat);
}
@ -249,11 +177,12 @@ public class UPCParserAction extends C99ParserAction {
/**
* Overrides setSpecifier to add support for temporary layout qualifier nodes.
*/
protected void setSpecifier(ICASTDeclSpecifier declSpec, Object o) {
if(o instanceof IToken)
setTokenSpecifier((IUPCASTDeclSpecifier)declSpec, (IToken)o);
@Override
protected void setSpecifier(ICASTDeclSpecifier declSpec, Object specifier) {
if(specifier instanceof IToken)
setTokenSpecifier((IUPCASTDeclSpecifier)declSpec, (IToken)specifier);
else
setLayoutQualifier((IUPCASTDeclSpecifier)declSpec, (UPCParserActionLayoutQualifier) o);
setLayoutQualifier((IUPCASTDeclSpecifier)declSpec, (UPCParserActionLayoutQualifier) specifier);
}
@ -289,10 +218,7 @@ public class UPCParserAction extends C99ParserAction {
}
else if(layoutQualifier.expression != null) {
node.setSharedQualifier(IUPCASTDeclSpecifier.sh_shared_constant_expression);
IASTExpression expr = layoutQualifier.expression;
node.setBlockSizeExpression(expr);
expr.setParent(node);
expr.setPropertyInParent(IUPCASTDeclSpecifier.BLOCK_SIZE_EXPRESSION);
node.setBlockSizeExpression(layoutQualifier.expression);
}
else {
node.setSharedQualifier(IUPCASTDeclSpecifier.sh_shared_indefinite_allocation);

127
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/core/dom/upc/UPCLanguage.java
View file

@ -10,81 +10,112 @@
*******************************************************************************/
package org.eclipse.cdt.core.dom.upc;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.cdt.core.dom.ILinkage;
import org.eclipse.cdt.core.dom.c99.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.c99.IC99TokenCollector;
import org.eclipse.cdt.core.dom.c99.IKeywordMap;
import org.eclipse.cdt.core.dom.c99.ILexerFactory;
import org.eclipse.cdt.core.dom.c99.IPPTokenComparator;
import org.eclipse.cdt.core.dom.c99.IParser;
import org.eclipse.cdt.core.dom.c99.IPreprocessorExtensionConfiguration;
import org.eclipse.cdt.core.dom.parser.c99.GCCPreprocessorExtensionConfiguration;
import org.eclipse.cdt.core.dom.parser.upc.UPCKeywordMap;
import org.eclipse.cdt.internal.core.dom.parser.upc.UPCLexerFactory;
import org.eclipse.cdt.internal.core.dom.parser.upc.UPCPPTokenComparator;
import org.eclipse.cdt.internal.core.dom.parser.upc.UPCParser;
import org.eclipse.cdt.internal.core.dom.parser.upc.UPCTokenCollector;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.lrparser.BaseExtensibleLanguage;
import org.eclipse.cdt.core.dom.lrparser.IDOMTokenMap;
import org.eclipse.cdt.core.dom.lrparser.IParser;
import org.eclipse.cdt.core.dom.lrparser.action.c99.C99ASTNodeFactory;
import org.eclipse.cdt.core.dom.lrparser.c99.C99Language;
import org.eclipse.cdt.core.dom.parser.upc.DOMToUPCTokenMap;
import org.eclipse.cdt.core.dom.parser.upc.UPCKeyword;
import org.eclipse.cdt.core.index.IIndex;
import org.eclipse.cdt.core.model.IContributedModelBuilder;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.cdt.core.parser.IScanner;
import org.eclipse.cdt.core.parser.ParserLanguage;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTTranslationUnit;
/**
* Implementation of the ILanguage extension point, adds UPC as a language to CDT.
*
* Just hooks into C99Language and provides UPC specifier parser and keyword map.
*
*
* @author Mike Kucera
*/
public class UPCLanguage extends BaseExtensibleLanguage {
protected static final IPreprocessorExtensionConfiguration
GCC_PREPROCESSOR_EXTENSION = new GCCPreprocessorExtensionConfiguration();
// TODO: this should probably go somewhere else
public static final String PLUGIN_ID = "org.eclipse.cdt.core.parser.upc"; //$NON-NLS-1$
public static final String ID = PLUGIN_ID + ".upc"; //$NON-NLS-1$
private static final UPCKeywordMap keywordMap = new UPCKeywordMap();
private static final UPCLanguage myDefault = new UPCLanguage();
private static final IDOMTokenMap TOKEN_MAP = new DOMToUPCTokenMap();
private static final C99Language C99_LANGUAGE = C99Language.getDefault();
private static final UPCLanguage myDefault = new UPCLanguage();
private static final String[] keywords = UPCKeyword.getAllKeywords();
public static UPCLanguage getDefault() {
return myDefault;
}
@Override
protected IDOMTokenMap getTokenMap() {
return TOKEN_MAP;
}
@Override
public IParser getParser() {
//return new UPCParser();
return null;
}
public IContributedModelBuilder createModelBuilder(ITranslationUnit tu) {
return null;
}
public String getId() {
return ID;
}
public int getLinkageID() {
return ILinkage.C_LINKAGE_ID;
}
public String getName() {
// TODO: this has to be read from a message bundle
return "UPC";//$NON-NLS-1$
public IASTName[] getSelectedNames(IASTTranslationUnit ast, int start, int length) {
return C99_LANGUAGE.getSelectedNames(ast, start, length);
}
public String[] getBuiltinTypes() {
return C99_LANGUAGE.getBuiltinTypes();
}
public String[] getKeywords() {
return keywords;
}
public String[] getPreprocessorKeywords() {
return C99_LANGUAGE.getPreprocessorKeywords();
}
@Override
protected ParserLanguage getParserLanguageForPreprocessor() {
return ParserLanguage.C;
}
/**
* Gets the translation unit object and sets the index and the location resolver.
*/
@SuppressWarnings("restriction")
@Override
protected IASTTranslationUnit createASTTranslationUnit(IIndex index, IScanner preprocessor) {
IASTTranslationUnit tu = C99ASTNodeFactory.DEFAULT_INSTANCE.newTranslationUnit();
tu.setIndex(index);
if(tu instanceof CASTTranslationUnit) {
((CASTTranslationUnit)tu).setLocationResolver(preprocessor.getLocationResolver());
}
return tu;
}
public IParser getParser() {
return new UPCParser();
}
public IKeywordMap getKeywordMap() {
return keywordMap;
}
protected IPreprocessorExtensionConfiguration getPreprocessorExtensionConfiguration() {
return GCC_PREPROCESSOR_EXTENSION;
}
protected ILexerFactory getLexerFactory() {
return new UPCLexerFactory();
}
protected IPPTokenComparator getTokenComparator() {
return new UPCPPTokenComparator();
}
protected IC99TokenCollector getTokenCollector() {
return new UPCTokenCollector();
}
}

12
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/core/dom/upc/ast/IUPCASTForallStatement.java
View file

@ -17,18 +17,6 @@ import org.eclipse.cdt.core.dom.ast.IASTStatement;
public interface IUPCASTForallStatement extends IASTForStatement {
public static final ASTNodeProperty CONDITION = new ASTNodeProperty(
"IUPCASTForallStatement.CONDITION - IASTExpression condition of IUPCASTForallStatement"); //$NON-NLS-1$
public static final ASTNodeProperty ITERATION = new ASTNodeProperty(
"IUPCASTForallStatement.ITERATION - IASTExpression iteration of IUPCASTForallStatement"); //$NON-NLS-1$
public static final ASTNodeProperty BODY = new ASTNodeProperty(
"IUPCASTForallStatement.BODY - IASTStatement body of IUPCASTForallStatement"); //$NON-NLS-1$
public static final ASTNodeProperty INITIALIZER = new ASTNodeProperty(
"IUPCASTForallStatement.INITIALIZER - initializer for IUPCASTForallStatement"); //$NON-NLS-1$
public static final ASTNodeProperty AFFINITY = new ASTNodeProperty(
"IUPCASTForallStatement.AFFINITY - IASTExpression affinity for IUPCASTForallStatement"); //$NON-NLS-1$

12
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/core/dom/upc/ast/IUPCASTTypeIdExpression.java Normal file
View file

@ -0,0 +1,12 @@
package org.eclipse.cdt.core.dom.upc.ast;
import org.eclipse.cdt.core.dom.ast.IASTTypeIdExpression;
public interface IUPCASTTypeIdExpression extends IASTTypeIdExpression {
public final int op_upc_localsizeof = op_last + 1;
public final int op_upc_blocksizeof = op_last + 2;
public final int op_upc_elemsizeof = op_last + 3;
}

16
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/core/dom/upc/ast/IUPCASTSizeofExpression.java → upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/core/dom/upc/ast/IUPCASTUnaryExpression.java
View file

@ -12,18 +12,12 @@ package org.eclipse.cdt.core.dom.upc.ast;
import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression;
public interface IUPCASTSizeofExpression extends IASTUnaryExpression {
public interface IUPCASTUnaryExpression extends IASTUnaryExpression {
public final int op_sizeof = 0;
public final int op_upc_localsizeof = op_last + 1;
public final int op_upc_localsizeof = 1;
public final int op_upc_blocksizeof = op_last + 2;
public final int op_upc_blocksizeof = 2;
public final int op_upc_elemsizeof = op_last + 3;
public final int op_upc_elemsizeof = 3;
public void setUPCSizeofOperator(int upcSizeofOperator);
public int getUPCSizeofOperator();
}
}

30
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/UPCLexer.g
View file

@ -1,30 +0,0 @@
-----------------------------------------------------------------------------------
-- Copyright (c) 2006, 2007 IBM Corporation and others.
-- All rights reserved. This program and the accompanying materials
-- are made available under the terms of the Eclipse Public License v1.0
-- which accompanies this distribution, and is available at
-- http://www.eclipse.org/legal/epl-v10.html
--
-- Contributors:
-- IBM Corporation - initial API and implementation
-----------------------------------------------------------------------------------
%Options la=1
%options package=org.eclipse.cdt.internal.core.dom.parser.upc
%options template=LexerTemplateD.g
%options export_terminals=("UPCLexerBaseexp.java", "TK_")
%options verbose
%Options list
%options single_productions
$Import
C99Lexer.g
$End
$Globals
/.
import org.eclipse.cdt.internal.core.dom.parser.c99.preprocessor.Token;
./
$End

518
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/UPCLexer.java
View file

@ -1,518 +0,0 @@
/*******************************************************************************
* Copyright (c) 2006, 2007 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
// This file was generated by LPG
package org.eclipse.cdt.internal.core.dom.parser.upc;
import lpg.lpgjavaruntime.*;
import org.eclipse.cdt.core.parser.CodeReader;
import org.eclipse.cdt.internal.core.dom.parser.c99.C99LexerKind;
import org.eclipse.cdt.internal.core.dom.parser.c99.preprocessor.TokenList;
import org.eclipse.cdt.internal.core.dom.parser.c99.preprocessor.Token;
import org.eclipse.cdt.core.dom.c99.ILexer;
import org.eclipse.cdt.internal.core.dom.parser.c99.preprocessor.Token;
public class UPCLexer extends LpgLexStream implements UPCParsersym, UPCLexersym, RuleAction , ILexer
{
private static ParseTable prs = new UPCLexerprs();
private PrsStream prsStream;
private LexParser lexParser = new LexParser(this, prs, this);
public PrsStream getPrsStream() { return prsStream; }
public int getToken(int i) { return lexParser.getToken(i); }
public int getRhsFirstTokenIndex(int i) { return lexParser.getFirstToken(i); }
public int getRhsLastTokenIndex(int i) { return lexParser.getLastToken(i); }
public int getLeftSpan() { return lexParser.getFirstToken(); }
public int getRightSpan() { return lexParser.getLastToken(); }
public UPCLexer(String filename, int tab) throws java.io.IOException
{
super(filename, tab);
}
public UPCLexer(char[] input_chars, String filename, int tab)
{
super(input_chars, filename, tab);
}
public UPCLexer(char[] input_chars, String filename)
{
this(input_chars, filename, 1);
}
public UPCLexer() {}
public String[] orderedExportedSymbols() { return UPCParsersym.orderedTerminalSymbols; }
public LexStream getLexStream() { return (LexStream) this; }
public void lexer(PrsStream prsStream)
{
lexer(null, prsStream);
}
public void lexer(Monitor monitor, PrsStream prsStream)
{
if (getInputChars() == null)
throw new NullPointerException("LexStream was not initialized");//$NON-NLS-1$
this.prsStream = prsStream;
prsStream.makeToken(0, 0, 0); // Token list must start with a bad token
lexParser.parseCharacters(monitor); // Lex the input characters
int i = getStreamIndex();
prsStream.makeToken(i, i, TK_EOF_TOKEN); // and end with the end of file token
prsStream.setStreamLength(prsStream.getSize());
return;
}
private TokenList tokenList = null;
private boolean returnCommentTokens = false;
private char[] input = null; // the input character buffer
public UPCLexer(CodeReader reader) {
super(reader.buffer, new String(reader.filename));
}
// defined in interface ILexer
public synchronized TokenList lex(int options) {
if((OPTION_GENERATE_COMMENT_TOKENS & options) != 0)
returnCommentTokens = true;
tokenList = new TokenList();
input = super.getInputChars();
lexParser.parseCharacters(null); // Lex the input characters
TokenList result = tokenList;
tokenList = null;
input = null;
return result;
}
protected void makeToken(int kind) {
// ignore comments if desired
if(!returnCommentTokens && (kind == TK_MultiLineComment || kind == TK_SingleLineComment))
return;
int startOffset = lexParser.getFirstToken();
int endOffset = lexParser.getLastToken();
// an adjustment for trigraphs, commented out for optimization purposes
//if(kind != C99Parsersym.TK_Question && startOffset == endOffset && input[startOffset] == '?') {
// // The token starts with a '?' but its not a question token, then it must be a trigraph.
// endOffset += 2; // make sure the toString() method of the token returns the entire trigraph sequence
//}
tokenList.add(new Token(startOffset, endOffset, kind, input));
}
public void reportError(int leftOffset, int rightOffset) {
Token token = new Token(leftOffset, rightOffset, TK_Invalid, getInputChars());
tokenList.add(token);
}
public int getKind(int i) {
return C99LexerKind.getKind(this, i);
}
public void ruleAction( int ruleNumber)
{
switch(ruleNumber)
{
//
// Rule 1: Token ::= identifier
//
case 1: { makeToken(TK_identifier); break;
}
//
// Rule 2: Token ::= integer-constant
//
case 2: { makeToken(TK_integer); break;
}
//
// Rule 3: Token ::= floating-constant
//
case 3: { makeToken(TK_floating); break;
}
//
// Rule 4: Token ::= character-constant
//
case 4: { makeToken(TK_charconst); break;
}
//
// Rule 5: Token ::= string-literal
//
case 5: { makeToken(TK_stringlit); break;
}
//
// Rule 6: Token ::= [
//
case 6: { makeToken(TK_LeftBracket); break;
}
//
// Rule 7: Token ::= ]
//
case 7: { makeToken(TK_RightBracket); break;
}
//
// Rule 8: Token ::= (
//
case 8: { makeToken(TK_LeftParen); break;
}
//
// Rule 9: Token ::= )
//
case 9: { makeToken(TK_RightParen); break;
}
//
// Rule 10: Token ::= {
//
case 10: { makeToken(TK_LeftBrace); break;
}
//
// Rule 11: Token ::= }
//
case 11: { makeToken(TK_RightBrace); break;
}
//
// Rule 12: Token ::= .
//
case 12: { makeToken(TK_Dot); break;
}
//
// Rule 13: Token ::= - >
//
case 13: { makeToken(TK_Arrow); break;
}
//
// Rule 14: Token ::= + +
//
case 14: { makeToken(TK_PlusPlus); break;
}
//
// Rule 15: Token ::= - -
//
case 15: { makeToken(TK_MinusMinus); break;
}
//
// Rule 16: Token ::= &
//
case 16: { makeToken(TK_And); break;
}
//
// Rule 17: Token ::= *
//
case 17: { makeToken(TK_Star); break;
}
//
// Rule 18: Token ::= +
//
case 18: { makeToken(TK_Plus); break;
}
//
// Rule 19: Token ::= -
//
case 19: { makeToken(TK_Minus); break;
}
//
// Rule 20: Token ::= ~
//
case 20: { makeToken(TK_Tilde); break;
}
//
// Rule 21: Token ::= !
//
case 21: { makeToken(TK_Bang); break;
}
//
// Rule 22: Token ::= /
//
case 22: { makeToken(TK_Slash); break;
}
//
// Rule 23: Token ::= %
//
case 23: { makeToken(TK_Percent); break;
}
//
// Rule 24: Token ::= < <
//
case 24: { makeToken(TK_LeftShift); break;
}
//
// Rule 25: Token ::= > >
//
case 25: { makeToken(TK_RightShift); break;
}
//
// Rule 26: Token ::= <
//
case 26: { makeToken(TK_LT); break;
}
//
// Rule 27: Token ::= >
//
case 27: { makeToken(TK_GT); break;
}
//
// Rule 28: Token ::= < =
//
case 28: { makeToken(TK_LE); break;
}
//
// Rule 29: Token ::= > =
//
case 29: { makeToken(TK_GE); break;
}
//
// Rule 30: Token ::= = =
//
case 30: { makeToken(TK_EQ); break;
}
//
// Rule 31: Token ::= ! =
//
case 31: { makeToken(TK_NE); break;
}
//
// Rule 32: Token ::= ^
//
case 32: { makeToken(TK_Caret); break;
}
//
// Rule 33: Token ::= |
//
case 33: { makeToken(TK_Or); break;
}
//
// Rule 34: Token ::= & &
//
case 34: { makeToken(TK_AndAnd); break;
}
//
// Rule 35: Token ::= | |
//
case 35: { makeToken(TK_OrOr); break;
}
//
// Rule 36: Token ::= ?
//
case 36: { makeToken(TK_Question); break;
}
//
// Rule 37: Token ::= :
//
case 37: { makeToken(TK_Colon); break;
}
//
// Rule 38: Token ::= ;
//
case 38: { makeToken(TK_SemiColon); break;
}
//
// Rule 39: Token ::= . . .
//
case 39: { makeToken(TK_DotDotDot); break;
}
//
// Rule 40: Token ::= =
//
case 40: { makeToken(TK_Assign); break;
}
//
// Rule 41: Token ::= * =
//
case 41: { makeToken(TK_StarAssign); break;
}
//
// Rule 42: Token ::= / =
//
case 42: { makeToken(TK_SlashAssign); break;
}
//
// Rule 43: Token ::= % =
//
case 43: { makeToken(TK_PercentAssign); break;
}
//
// Rule 44: Token ::= + =
//
case 44: { makeToken(TK_PlusAssign); break;
}
//
// Rule 45: Token ::= - =
//
case 45: { makeToken(TK_MinusAssign); break;
}
//
// Rule 46: Token ::= < < =
//
case 46: { makeToken(TK_LeftShiftAssign); break;
}
//
// Rule 47: Token ::= > > =
//
case 47: { makeToken(TK_RightShiftAssign); break;
}
//
// Rule 48: Token ::= & =
//
case 48: { makeToken(TK_AndAssign); break;
}
//
// Rule 49: Token ::= ^ =
//
case 49: { makeToken(TK_CaretAssign); break;
}
//
// Rule 50: Token ::= | =
//
case 50: { makeToken(TK_OrAssign); break;
}
//
// Rule 51: Token ::= ,
//
case 51: { makeToken(TK_Comma); break;
}
//
// Rule 52: Token ::= #
//
case 52: { makeToken(TK_Hash); break;
}
//
// Rule 53: Token ::= # #
//
case 53: { makeToken(TK_HashHash); break;
}
//
// Rule 54: Token ::= < :
//
case 54: { makeToken(TK_LeftBracket); break;
}
//
// Rule 55: Token ::= : >
//
case 55: { makeToken(TK_RightBracket); break;
}
//
// Rule 56: Token ::= < %
//
case 56: { makeToken(TK_LeftBrace); break;
}
//
// Rule 57: Token ::= % >
//
case 57: { makeToken(TK_RightBrace); break;
}
//
// Rule 58: Token ::= % :
//
case 58: { makeToken(TK_Hash); break;
}
//
// Rule 59: Token ::= % : % :
//
case 59: { makeToken(TK_HashHash); break;
}
//
// Rule 217: Token ::= NewLine
//
case 217: { makeToken(TK_NewLine); break;
}
//
// Rule 219: Token ::= SLC
//
case 219: { makeToken(TK_SingleLineComment); break;
}
//
// Rule 220: Token ::= MLC
//
case 220: { makeToken(TK_MultiLineComment); break;
}
default:
break;
}
return;
}
}

580
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/UPCLexerprs.java
View file

@ -1,580 +0,0 @@
/*******************************************************************************
* Copyright (c) 2006, 2007 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
// This file was generated by LPG
package org.eclipse.cdt.internal.core.dom.parser.upc;
public class UPCLexerprs implements lpg.lpgjavaruntime.ParseTable, UPCLexersym {
public interface IsKeyword {
public final static byte isKeyword[] = {0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0
};
};
public final static byte isKeyword[] = IsKeyword.isKeyword;
public final boolean isKeyword(int index) { return isKeyword[index] != 0; }
public interface BaseCheck {
public final static byte baseCheck[] = {0,
1,1,1,1,1,1,1,1,1,1,
1,1,2,2,2,1,1,1,1,1,
1,1,1,2,2,1,1,2,2,2,
2,1,1,2,2,1,1,1,3,1,
2,2,2,2,2,3,3,2,2,2,
1,1,2,2,2,2,2,2,4,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,
1,2,2,2,5,1,2,3,2,2,
0,1,2,2,1,1,3,4,4,1,
2,1,2,1,2,2,2,1,2,2,
1,2,1,2,1,1,1,1,2,2,
1,1,1,2,3,2,2,3,3,4,
3,4,1,2,2,2,3,3,2,3,
2,1,1,2,2,3,3,2,3,2,
1,2,1,1,1,1,3,4,1,2,
1,1,1,1,1,1,2,2,2,2,
2,2,2,2,2,2,2,2,3,2,
3,3,4,1,2,1,1
};
};
public final static byte baseCheck[] = BaseCheck.baseCheck;
public final int baseCheck(int index) { return baseCheck[index]; }
public final static byte rhs[] = baseCheck;
public final int rhs(int index) { return rhs[index]; };
public interface BaseAction {
public final static char baseAction[] = {
31,31,31,31,31,31,31,31,31,31,
31,31,31,31,31,31,31,31,31,31,
31,31,31,31,31,31,31,31,31,31,
31,31,31,31,31,31,31,31,31,31,
31,31,31,31,31,31,31,31,31,31,
31,31,31,31,31,31,31,31,31,31,
2,2,2,2,2,2,2,2,2,2,
2,2,2,2,2,2,2,2,2,2,
2,2,2,2,2,2,2,2,2,2,
2,2,2,2,2,2,2,2,2,2,
2,2,2,2,2,2,2,2,2,2,
2,2,23,23,23,1,1,1,1,1,
1,1,1,1,1,37,37,37,37,37,
37,37,37,3,3,3,3,3,3,3,
3,3,3,3,3,3,4,4,4,4,
4,4,4,4,4,4,4,4,4,4,
4,4,4,4,4,4,4,4,4,4,
4,38,38,38,38,38,38,12,12,12,
12,12,12,12,12,12,12,13,13,13,
13,13,13,13,13,13,13,14,14,14,
14,39,39,39,39,39,39,39,24,24,
24,24,24,24,24,24,24,31,31,31,
31,40,40,41,41,42,44,44,43,43,
43,43,32,32,32,25,25,6,6,19,
33,33,33,33,45,46,47,47,26,26,
26,26,26,26,26,15,15,21,21,22,
22,34,34,48,48,48,48,48,48,49,
49,49,49,5,5,50,50,50,27,27,
27,27,16,16,51,51,51,28,28,28,
28,20,20,11,11,11,11,35,35,29,
29,17,17,7,7,7,7,8,8,8,
8,8,8,8,8,8,8,8,9,10,
36,36,36,36,30,30,18,18,201,578,
112,1422,365,357,236,1212,365,398,177,178,
1577,179,583,306,326,303,304,305,99,327,
199,235,1116,232,222,324,1088,1380,274,350,
501,2,3,4,5,1433,274,426,340,493,
220,1222,318,521,519,513,261,262,371,980,
187,188,266,189,437,306,301,303,304,305,
1170,486,302,689,177,178,299,179,404,306,
326,303,304,305,1391,327,1256,133,445,319,
1240,324,980,187,188,265,189,1276,306,301,
303,304,305,459,1613,302,495,177,178,299,
179,1573,306,326,303,304,305,1585,327,1324,
133,472,292,1601,325,592,187,188,268,189,
1616,306,301,303,304,305,1197,1617,302,786,
177,178,300,179,1590,306,326,303,304,305,
1614,327,883,187,188,270,189,325,306,301,
303,304,305,1372,464,302,1,208,209,300,
210,1451,626,301,201,202,626,171,254,1277,
211,1077,234,112,101,208,209,236,210,1607,
230,1473,274,1183,133,1580,291,1307,211,1270,
1400,1574,1409,511,235,1221,233,511,228,1228,
504,204,224,552,574,252,574,1596,593,1620,
520,483,520,483,1621,243,1203,241,272,1409,
624,1226,1150,133,624,292,1256,133,1164,291,
1256,133,1619,602,456,599,1256,133,1171,602,
1409,632,1409,634,1105,632,439,634,1572,589,
537,1296,133,1194,291,237,606,642,609,1256,
133,642,602,1462,628,249,250,642,628,1462,
630,612,1256,133,630,616,1462,636,238,1462,
638,636,1352,133,638,292,1256,133,642,620,
1256,133,642,239,1484,274,1495,274,1506,274,
1517,274,1528,274,1539,274,1550,274,1561,274,
642,642
};
};
public final static char baseAction[] = BaseAction.baseAction;
public final int baseAction(int index) { return baseAction[index]; }
public final static char lhs[] = baseAction;
public final int lhs(int index) { return lhs[index]; };
public interface TermCheck {
public final static byte termCheck[] = {0,
0,1,2,3,4,5,6,7,8,9,
10,11,12,13,14,15,16,17,18,19,
20,21,22,23,24,25,26,27,28,29,
30,31,32,33,34,35,36,37,38,39,
40,41,42,43,44,45,46,47,48,49,
50,51,52,53,54,55,56,57,58,59,
60,61,62,63,64,65,66,67,68,69,
70,71,72,73,74,75,76,77,78,79,
80,81,82,83,84,85,86,87,88,89,
90,91,92,93,94,95,96,97,0,99,
0,1,2,3,4,5,6,7,8,9,
10,11,12,13,14,15,16,17,18,19,
20,21,22,23,24,25,26,27,28,29,
30,31,32,33,34,35,36,37,38,39,
40,41,42,43,44,45,46,47,48,49,
50,51,52,53,54,55,56,57,58,59,
60,61,62,63,64,65,66,67,68,69,
70,71,72,73,74,75,76,77,78,79,
80,81,82,83,84,85,86,87,88,89,
90,91,92,93,94,95,96,97,0,99,
0,1,2,3,4,5,6,7,8,9,
10,11,12,13,14,15,16,17,18,19,
20,21,22,23,24,25,26,27,28,29,
30,31,32,33,34,35,36,37,38,39,
40,41,42,43,44,45,46,47,48,49,
50,51,52,53,54,55,56,57,58,59,
60,61,62,63,64,65,66,67,68,69,
70,71,72,73,74,75,76,77,78,79,
80,81,82,83,84,85,86,87,88,89,
90,91,92,93,94,95,98,97,0,99,
0,1,2,3,4,5,6,7,8,9,
10,11,12,13,14,15,16,17,18,19,
20,21,22,23,24,25,26,27,28,29,
30,31,32,33,34,35,36,37,38,39,
40,41,42,43,44,45,46,47,48,49,
50,51,52,53,54,55,56,57,58,59,
60,61,62,63,64,65,66,67,68,69,
70,71,72,73,74,75,76,77,78,79,
80,81,82,83,84,85,86,87,88,89,
90,91,92,93,94,95,96,0,1,2,
3,4,5,6,7,8,9,10,11,12,
13,14,15,16,17,18,19,20,21,22,
23,24,25,26,27,28,29,30,31,32,
33,34,35,36,37,38,39,40,41,42,
43,44,45,46,47,48,49,50,51,52,
53,54,55,56,57,58,59,60,61,62,
63,64,65,66,67,68,69,70,71,72,
73,74,75,76,77,78,79,80,81,82,
83,84,85,86,87,88,89,90,91,92,
93,94,95,96,0,1,2,3,4,5,
6,7,8,9,10,11,12,13,14,15,
16,17,18,19,20,21,22,23,24,25,
26,27,28,29,30,31,32,33,34,35,
36,37,38,39,40,41,42,43,44,45,
46,47,48,49,50,51,52,53,54,55,
56,57,58,59,60,61,62,63,64,65,
66,67,68,69,70,71,72,73,74,75,
76,77,78,79,80,81,82,83,84,85,
86,87,88,89,90,91,92,93,94,95,
96,0,1,2,3,4,5,6,7,8,
9,10,11,12,13,14,15,16,17,18,
19,20,21,22,23,24,25,26,27,28,
29,30,31,32,33,34,35,36,37,38,
39,40,41,42,43,44,45,46,47,48,
49,50,51,52,53,54,55,56,57,58,
59,60,61,62,63,64,65,66,67,68,
69,70,71,72,73,74,75,76,77,78,
79,80,81,82,83,84,85,86,87,88,
89,90,91,92,93,94,95,96,0,1,
2,3,4,5,6,7,8,9,10,11,
12,13,14,15,16,17,18,19,20,21,
22,23,24,25,26,27,28,29,30,31,
32,33,34,35,36,37,38,39,40,41,
42,43,44,45,46,47,48,49,50,51,
52,53,54,55,56,57,58,59,60,61,
62,63,64,65,66,67,68,69,70,71,
72,73,74,75,76,77,78,79,80,81,
82,83,84,85,86,87,88,89,90,91,
92,93,94,95,96,0,1,2,3,4,
5,6,7,8,9,10,11,12,13,14,
15,16,17,18,19,20,21,22,23,24,
25,26,27,28,29,30,31,32,33,34,
35,36,37,38,39,40,41,42,43,44,
45,46,47,48,49,50,51,52,53,54,
55,56,57,58,59,60,61,62,63,64,
65,66,67,68,69,70,71,72,73,74,
75,76,77,78,79,80,81,82,83,84,
85,86,87,88,89,90,91,92,93,94,
95,96,0,1,2,3,4,5,6,7,
8,9,10,11,12,13,14,15,16,17,
18,19,20,21,22,23,24,25,26,27,
28,29,30,31,32,33,34,35,36,37,
38,39,40,41,42,43,44,45,46,47,
48,49,50,51,52,53,54,55,56,57,
58,59,60,61,62,63,64,65,66,67,
68,69,70,71,72,73,74,75,76,77,
78,79,80,81,82,83,84,85,86,87,
88,89,90,91,92,93,94,95,96,0,
1,2,3,4,5,6,7,8,9,10,
11,12,13,14,15,16,17,18,19,20,
21,22,23,24,25,26,27,28,29,30,
31,32,33,34,35,36,37,38,39,40,
41,42,43,44,45,46,47,48,49,50,
51,52,53,54,55,56,57,58,59,60,
61,62,63,64,65,66,67,68,69,70,
71,72,73,74,75,76,77,78,79,80,
81,82,0,84,85,86,87,88,89,90,
91,92,93,94,95,96,0,1,2,3,
4,5,6,7,8,9,10,0,12,13,
14,15,16,17,18,19,20,21,22,23,
24,25,26,27,0,0,30,31,32,0,
34,35,36,37,38,0,29,41,14,15,
44,45,46,47,48,49,50,51,52,53,
54,55,56,57,58,59,60,61,62,63,
64,65,66,67,68,69,70,71,72,0,
1,2,3,4,5,6,7,8,9,10,
84,12,13,0,0,16,17,18,19,0,
0,22,23,24,25,26,27,28,15,30,
11,32,0,1,2,3,4,5,6,7,
8,9,10,0,12,13,0,82,16,17,
18,19,0,33,22,23,24,25,26,27,
28,0,1,2,3,4,5,6,7,8,
0,0,0,12,0,0,30,0,32,18,
19,20,21,12,13,14,15,16,17,0,
20,21,31,0,42,34,35,36,37,80,
11,0,41,28,43,0,1,2,3,4,
5,6,7,8,9,10,0,12,13,0,
43,16,17,18,19,0,0,22,23,24,
25,26,27,14,15,0,11,11,0,20,
21,98,81,0,83,0,1,2,3,4,
5,6,7,8,9,10,0,12,13,0,
83,16,17,18,19,39,0,22,23,24,
25,26,27,0,1,2,3,4,5,6,
7,8,9,10,0,12,13,31,0,16,
17,18,19,0,38,22,23,24,25,26,
27,0,1,2,3,4,5,6,7,8,
9,10,0,12,13,0,0,16,17,18,
19,0,0,22,23,24,25,26,27,0,
1,2,3,4,5,6,7,8,9,10,
0,20,21,0,0,16,17,0,0,0,
0,0,12,13,14,15,0,28,0,1,
2,3,4,5,6,7,8,9,10,20,
21,0,1,2,3,4,5,6,7,8,
9,10,0,1,2,3,4,5,6,7,
8,9,10,0,0,0,0,39,40,28,
0,1,2,3,4,5,6,7,8,9,
10,0,1,2,3,4,5,6,7,8,
9,10,0,1,2,3,4,5,6,7,
8,9,10,0,1,2,3,4,5,6,
7,8,9,10,0,1,2,3,4,5,
6,7,8,9,10,0,1,2,3,4,
5,6,7,8,9,10,0,1,2,3,
4,5,6,7,8,9,10,0,1,2,
3,4,5,6,7,8,9,10,0,1,
2,3,4,5,6,7,8,9,10,0,
1,2,3,4,5,6,7,8,9,10,
0,1,2,3,4,5,6,7,8,9,
10,0,0,0,0,0,0,0,0,0,
0,0,0,11,0,14,15,14,15,0,
11,20,21,20,21,0,12,13,14,15,
0,12,13,14,15,33,0,12,13,14,
15,11,0,0,42,0,0,11,0,0,
0,0,0,11,11,0,11,11,0,29,
11,11,14,33,0,29,0,0,0,0,
0,29,0,0,0,0,40,0,76,73,
74,75,0,0,0,0,77,78,0,0,
0,0,0,0,0,0,0,0,0,98,
0,0,0,97,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,79,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0
};
};
public final static byte termCheck[] = TermCheck.termCheck;
public final int termCheck(int index) { return termCheck[index]; }
public interface TermAction {
public final static char termAction[] = {0,
642,757,758,759,760,761,762,763,764,765,
766,801,707,733,713,739,706,732,702,703,
722,748,704,705,728,729,730,731,797,802,
717,725,743,798,715,719,721,723,751,794,
796,857,790,856,708,709,710,711,712,714,
716,718,720,724,726,727,734,735,736,737,
738,740,741,742,744,745,746,747,749,750,
752,753,807,839,841,842,800,871,504,791,
809,803,789,855,812,792,793,804,805,808,
810,811,788,806,799,795,854,840,231,858,
642,757,758,759,760,761,762,763,764,765,
766,801,707,733,713,739,706,732,702,703,
722,748,704,705,728,729,730,731,797,802,
717,725,743,798,715,719,721,723,751,794,
796,857,790,856,708,709,710,711,712,714,
716,718,720,724,726,727,734,735,736,737,
738,740,741,742,744,745,746,747,749,750,
752,753,807,839,841,842,800,867,869,791,
809,803,789,855,812,792,793,804,805,808,
810,811,788,806,799,795,854,840,642,858,
642,517,758,759,760,761,762,763,764,765,
766,417,707,733,713,529,706,732,702,703,
722,748,704,705,728,729,730,731,331,424,
717,725,743,356,715,719,721,723,751,499,
509,525,443,337,708,709,710,711,712,714,
716,718,720,724,726,727,734,735,736,737,
738,740,741,742,744,745,746,747,749,750,
752,753,755,839,841,842,431,515,457,470,
390,678,352,379,756,650,651,648,649,652,
653,662,450,410,680,693,641,840,642,859,
219,757,758,759,760,761,762,763,764,765,
766,801,707,733,713,739,706,732,702,703,
722,748,704,705,728,729,730,731,797,802,
717,725,743,798,715,719,721,723,751,794,
796,816,790,815,708,709,710,711,712,714,
716,718,720,724,726,727,734,735,736,737,
738,740,741,742,744,745,746,747,749,750,
752,753,807,849,847,848,800,817,818,791,
809,803,789,814,812,792,793,804,805,808,
810,811,788,806,799,795,845,642,757,758,
759,760,761,762,763,764,765,766,801,707,
733,713,739,706,732,702,703,722,748,704,
705,728,729,730,731,797,802,717,725,743,
798,715,719,721,723,751,794,796,335,790,
962,708,709,710,711,712,714,716,718,720,
724,726,727,734,735,736,737,738,740,741,
742,744,745,746,747,749,750,752,753,807,
828,826,827,800,824,825,791,809,803,789,
823,812,792,793,804,805,808,810,811,788,
806,799,795,822,642,757,758,759,760,761,
762,763,764,765,766,801,707,733,713,739,
706,732,702,703,722,748,704,705,728,729,
730,731,797,802,717,725,743,798,715,719,
721,723,751,794,796,335,790,963,708,709,
710,711,712,714,716,718,720,724,726,727,
734,735,736,737,738,740,741,742,744,745,
746,747,749,750,752,753,807,828,826,827,
800,824,825,791,809,803,789,823,812,792,
793,804,805,808,810,811,788,806,799,795,
822,642,757,758,759,760,761,762,763,764,
765,766,801,707,733,713,739,706,732,702,
703,722,748,704,705,728,729,730,731,797,
802,717,725,743,798,715,719,721,723,751,
794,796,335,790,833,708,709,710,711,712,
714,716,718,720,724,726,727,734,735,736,
737,738,740,741,742,744,745,746,747,749,
750,752,753,807,838,836,837,800,834,835,
791,809,803,789,939,812,792,793,804,805,
808,810,811,788,806,799,795,832,642,757,
758,759,760,761,762,763,764,765,766,801,
707,733,713,739,706,732,702,703,722,748,
704,705,728,729,730,731,797,802,717,725,
743,798,715,719,721,723,751,794,796,335,
790,964,708,709,710,711,712,714,716,718,
720,724,726,727,734,735,736,737,738,740,
741,742,744,745,746,747,749,750,752,753,
807,828,826,827,800,824,825,791,809,803,
789,823,812,792,793,804,805,808,810,811,
788,806,799,795,822,642,757,758,759,760,
761,762,763,764,765,766,801,707,733,713,
739,706,732,702,703,722,748,704,705,728,
729,730,731,797,802,717,725,743,798,715,
719,721,723,751,794,796,335,790,965,708,
709,710,711,712,714,716,718,720,724,726,
727,734,735,736,737,738,740,741,742,744,
745,746,747,749,750,752,753,807,828,826,
827,800,824,825,791,809,803,789,823,812,
792,793,804,805,808,810,811,788,806,799,
795,822,642,757,758,759,760,761,762,763,
764,765,766,801,707,733,713,739,706,732,
702,703,722,748,704,705,728,729,730,731,
797,802,717,725,743,798,715,719,721,723,
751,794,796,335,790,833,708,709,710,711,
712,714,716,718,720,724,726,727,734,735,
736,737,738,740,741,742,744,745,746,747,
749,750,752,753,807,838,836,837,800,834,
835,791,809,803,789,940,812,792,793,804,
805,808,810,811,788,806,799,795,832,642,
757,758,759,760,761,762,763,764,765,766,
801,707,733,713,739,706,732,702,703,722,
748,704,705,728,729,730,731,797,802,717,
725,743,798,715,719,721,723,751,794,796,
335,790,833,708,709,710,711,712,714,716,
718,720,724,726,727,734,735,736,737,738,
740,741,742,744,745,746,747,749,750,752,
753,807,838,836,837,800,834,835,791,809,
803,789,642,812,792,793,804,805,808,810,
811,788,806,799,795,832,1,757,758,759,
760,761,762,763,764,765,766,37,707,733,
713,739,706,732,702,703,722,748,704,705,
728,729,730,731,248,642,717,725,743,642,
715,719,721,723,751,52,697,525,562,558,
708,709,710,711,712,714,716,718,720,724,
726,727,734,735,736,737,738,740,741,742,
744,745,746,747,749,750,752,753,755,245,
757,758,759,760,761,762,763,764,765,766,
756,781,787,258,642,780,786,776,777,33,
642,778,779,782,783,784,785,581,902,572,
692,570,642,757,758,759,760,761,762,763,
764,765,766,221,781,787,642,695,780,786,
776,777,58,701,778,779,782,783,784,785,
556,642,767,768,769,770,771,772,773,774,
642,263,642,955,642,642,572,97,570,953,
954,566,560,935,937,936,938,549,522,32,
566,560,406,642,568,956,957,958,959,677,
691,642,952,681,950,642,757,758,759,760,
761,762,763,764,765,766,642,781,787,242,
393,780,786,776,777,40,18,778,779,782,
783,784,785,562,558,642,672,686,642,897,
898,218,951,642,949,285,757,758,759,760,
761,762,763,764,765,766,115,781,787,642,
412,780,786,776,777,656,642,778,779,782,
783,784,785,284,757,758,759,760,761,762,
763,764,765,766,642,781,787,888,642,780,
786,776,777,642,889,778,779,782,783,784,
785,286,757,758,759,760,761,762,763,764,
765,766,642,781,787,642,642,780,786,776,
777,253,642,778,779,782,783,784,785,244,
757,758,759,760,761,762,763,764,765,766,
264,897,898,642,642,549,522,642,642,251,
642,642,935,937,936,938,642,491,642,757,
758,759,760,761,762,763,764,765,766,897,
898,12,757,758,759,760,761,762,763,764,
765,766,275,757,758,759,760,761,762,763,
764,765,766,642,642,642,642,924,925,551,
276,757,758,759,760,761,762,763,764,765,
766,642,757,758,759,760,761,762,763,764,
765,766,281,757,758,759,760,761,762,763,
764,765,766,279,757,758,759,760,761,762,
763,764,765,766,277,757,758,759,760,761,
762,763,764,765,766,280,757,758,759,760,
761,762,763,764,765,766,278,757,758,759,
760,761,762,763,764,765,766,290,757,758,
759,760,761,762,763,764,765,766,288,757,
758,759,760,761,762,763,764,765,766,289,
757,758,759,760,761,762,763,764,765,766,
287,757,758,759,760,761,762,763,764,765,
766,273,26,240,642,642,218,642,642,22,
642,642,642,670,267,244,244,562,558,269,
684,244,244,897,898,271,935,937,936,938,
23,935,937,936,938,696,19,935,937,936,
938,685,27,16,698,21,17,687,257,25,
24,642,642,671,690,642,673,683,642,699,
689,688,901,546,642,655,642,642,642,642,
642,539,642,642,642,642,657,642,544,839,
841,842,642,642,642,642,865,348,642,642,
642,642,642,642,642,642,642,642,642,244,
642,642,642,840,642,642,642,642,642,642,
642,642,642,642,642,642,642,642,642,642,
642,642,676
};
};
public final static char termAction[] = TermAction.termAction;
public final int termAction(int index) { return termAction[index]; }
public final int asb(int index) { return 0; }
public final int asr(int index) { return 0; }
public final int nasb(int index) { return 0; }
public final int nasr(int index) { return 0; }
public final int terminalIndex(int index) { return 0; }
public final int nonterminalIndex(int index) { return 0; }
public final int scopePrefix(int index) { return 0;}
public final int scopeSuffix(int index) { return 0;}
public final int scopeLhs(int index) { return 0;}
public final int scopeLa(int index) { return 0;}
public final int scopeStateSet(int index) { return 0;}
public final int scopeRhs(int index) { return 0;}
public final int scopeState(int index) { return 0;}
public final int inSymb(int index) { return 0;}
public final String name(int index) { return null; }
public final int getErrorSymbol() { return 0; }
public final int getScopeUbound() { return 0; }
public final int getScopeSize() { return 0; }
public final int getMaxNameLength() { return 0; }
public final static int
NUM_STATES = 88,
NT_OFFSET = 99,
LA_STATE_OFFSET = 969,
MAX_LA = 1,
NUM_RULES = 327,
NUM_NONTERMINALS = 52,
NUM_SYMBOLS = 151,
SEGMENT_SIZE = 8192,
START_STATE = 328,
IDENTIFIER_SYMBOL = 0,
EOFT_SYMBOL = 98,
EOLT_SYMBOL = 65,
ACCEPT_ACTION = 641,
ERROR_ACTION = 642;
public final static boolean BACKTRACK = false;
public final int getNumStates() { return NUM_STATES; }
public final int getNtOffset() { return NT_OFFSET; }
public final int getLaStateOffset() { return LA_STATE_OFFSET; }
public final int getMaxLa() { return MAX_LA; }
public final int getNumRules() { return NUM_RULES; }
public final int getNumNonterminals() { return NUM_NONTERMINALS; }
public final int getNumSymbols() { return NUM_SYMBOLS; }
public final int getSegmentSize() { return SEGMENT_SIZE; }
public final int getStartState() { return START_STATE; }
public final int getStartSymbol() { return lhs[0]; }
public final int getIdentifierSymbol() { return IDENTIFIER_SYMBOL; }
public final int getEoftSymbol() { return EOFT_SYMBOL; }
public final int getEoltSymbol() { return EOLT_SYMBOL; }
public final int getAcceptAction() { return ACCEPT_ACTION; }
public final int getErrorAction() { return ERROR_ACTION; }
public final boolean isValidForParser() { return isValidForParser; }
public final boolean getBacktrack() { return BACKTRACK; }
public final int originalState(int state) { return 0; }
public final int asi(int state) { return 0; }
public final int nasi(int state) { return 0; }
public final int inSymbol(int state) { return 0; }
public final int ntAction(int state, int sym) {
return baseAction[state + sym];
}
public final int tAction(int state, int sym) {
int i = baseAction[state],
k = i + sym;
return termAction[termCheck[k] == sym ? k : i];
}
public final int lookAhead(int la_state, int sym) {
int k = la_state + sym;
return termAction[termCheck[k] == sym ? k : la_state];
}
}

222
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/UPCLexersym.java
View file

@ -1,222 +0,0 @@
/*******************************************************************************
* Copyright (c) 2006, 2007 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
// This file was generated by LPG
package org.eclipse.cdt.internal.core.dom.parser.upc;
public interface UPCLexersym {
public final static int
Char_a = 18,
Char_b = 19,
Char_c = 22,
Char_d = 23,
Char_e = 16,
Char_f = 12,
Char_g = 44,
Char_h = 45,
Char_i = 46,
Char_j = 47,
Char_k = 48,
Char_l = 14,
Char_m = 49,
Char_n = 34,
Char_o = 50,
Char_p = 30,
Char_q = 51,
Char_r = 35,
Char_s = 52,
Char_t = 36,
Char_u = 20,
Char_v = 37,
Char_w = 53,
Char_x = 31,
Char_y = 54,
Char_z = 55,
Char_A = 24,
Char_B = 25,
Char_C = 26,
Char_D = 27,
Char_E = 17,
Char_F = 13,
Char_G = 56,
Char_H = 57,
Char_I = 58,
Char_J = 59,
Char_K = 60,
Char_L = 15,
Char_M = 61,
Char_N = 62,
Char_O = 63,
Char_P = 32,
Char_Q = 64,
Char_R = 65,
Char_S = 66,
Char_T = 67,
Char_U = 21,
Char_V = 68,
Char_W = 69,
Char_X = 38,
Char_Y = 70,
Char_Z = 71,
Char__ = 72,
Char_0 = 1,
Char_1 = 2,
Char_2 = 3,
Char_3 = 4,
Char_4 = 5,
Char_5 = 6,
Char_6 = 7,
Char_7 = 8,
Char_8 = 9,
Char_9 = 10,
Char_EOF = 98,
Char_Space = 73,
Char_Unused = 96,
Char_LF = 99,
Char_CR = 97,
Char_HT = 74,
Char_FF = 75,
Char_Dot = 28,
Char_LessThan = 76,
Char_GreaterThan = 29,
Char_Plus = 39,
Char_Minus = 40,
Char_Slash = 77,
Char_BackSlash = 41,
Char_Star = 78,
Char_LeftParen = 85,
Char_RightParen = 86,
Char_Equal = 11,
Char_LeftBracket = 87,
Char_RightBracket = 88,
Char_LeftBrace = 89,
Char_RightBrace = 90,
Char_Ampersand = 79,
Char_Tilde = 91,
Char_Bang = 92,
Char_Percent = 42,
Char_Caret = 93,
Char_Bar = 80,
Char_Question = 81,
Char_Colon = 33,
Char_SemiColon = 94,
Char_Comma = 95,
Char_Hash = 82,
Char_SingleQuote = 83,
Char_DoubleQuote = 43,
Char_DollarSign = 84;
public final static String orderedTerminalSymbols[] = {
"",//$NON-NLS-1$
"0",//$NON-NLS-1$
"1",//$NON-NLS-1$
"2",//$NON-NLS-1$
"3",//$NON-NLS-1$
"4",//$NON-NLS-1$
"5",//$NON-NLS-1$
"6",//$NON-NLS-1$
"7",//$NON-NLS-1$
"8",//$NON-NLS-1$
"9",//$NON-NLS-1$
"Equal",//$NON-NLS-1$
"f",//$NON-NLS-1$
"F",//$NON-NLS-1$
"l",//$NON-NLS-1$
"L",//$NON-NLS-1$
"e",//$NON-NLS-1$
"E",//$NON-NLS-1$
"a",//$NON-NLS-1$
"b",//$NON-NLS-1$
"u",//$NON-NLS-1$
"U",//$NON-NLS-1$
"c",//$NON-NLS-1$
"d",//$NON-NLS-1$
"A",//$NON-NLS-1$
"B",//$NON-NLS-1$
"C",//$NON-NLS-1$
"D",//$NON-NLS-1$
"Dot",//$NON-NLS-1$
"GreaterThan",//$NON-NLS-1$
"p",//$NON-NLS-1$
"x",//$NON-NLS-1$
"P",//$NON-NLS-1$
"Colon",//$NON-NLS-1$
"n",//$NON-NLS-1$
"r",//$NON-NLS-1$
"t",//$NON-NLS-1$
"v",//$NON-NLS-1$
"X",//$NON-NLS-1$
"Plus",//$NON-NLS-1$
"Minus",//$NON-NLS-1$
"BackSlash",//$NON-NLS-1$
"Percent",//$NON-NLS-1$
"DoubleQuote",//$NON-NLS-1$
"g",//$NON-NLS-1$
"h",//$NON-NLS-1$
"i",//$NON-NLS-1$
"j",//$NON-NLS-1$
"k",//$NON-NLS-1$
"m",//$NON-NLS-1$
"o",//$NON-NLS-1$
"q",//$NON-NLS-1$
"s",//$NON-NLS-1$
"w",//$NON-NLS-1$
"y",//$NON-NLS-1$
"z",//$NON-NLS-1$
"G",//$NON-NLS-1$
"H",//$NON-NLS-1$
"I",//$NON-NLS-1$
"J",//$NON-NLS-1$
"K",//$NON-NLS-1$
"M",//$NON-NLS-1$
"N",//$NON-NLS-1$
"O",//$NON-NLS-1$
"Q",//$NON-NLS-1$
"R",//$NON-NLS-1$
"S",//$NON-NLS-1$
"T",//$NON-NLS-1$
"V",//$NON-NLS-1$
"W",//$NON-NLS-1$
"Y",//$NON-NLS-1$
"Z",//$NON-NLS-1$
"_",//$NON-NLS-1$
"Space",//$NON-NLS-1$
"HT",//$NON-NLS-1$
"FF",//$NON-NLS-1$
"LessThan",//$NON-NLS-1$
"Slash",//$NON-NLS-1$
"Star",//$NON-NLS-1$
"Ampersand",//$NON-NLS-1$
"Bar",//$NON-NLS-1$
"Question",//$NON-NLS-1$
"Hash",//$NON-NLS-1$
"SingleQuote",//$NON-NLS-1$
"DollarSign",//$NON-NLS-1$
"LeftParen",//$NON-NLS-1$
"RightParen",//$NON-NLS-1$
"LeftBracket",//$NON-NLS-1$
"RightBracket",//$NON-NLS-1$
"LeftBrace",//$NON-NLS-1$
"RightBrace",//$NON-NLS-1$
"Tilde",//$NON-NLS-1$
"Bang",//$NON-NLS-1$
"Caret",//$NON-NLS-1$
"SemiColon",//$NON-NLS-1$
"Comma",//$NON-NLS-1$
"Unused",//$NON-NLS-1$
"CR",//$NON-NLS-1$
"EOF",//$NON-NLS-1$
"LF"//$NON-NLS-1$
};
public final static boolean isValidForParser = true;
}

153
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/UPCPPTokenComparator.java
View file

@ -1,153 +0,0 @@
/*******************************************************************************
* Copyright (c) 2006, 2007 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*********************************************************************************/
package org.eclipse.cdt.internal.core.dom.parser.upc;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.AND;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.ANDAND;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.BANG;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.CARET;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.CHARCONST;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.COLON;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.COMMA;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.DOTDOTDOT;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.EOF;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.EQ;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.GE;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.GT;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.HASH;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.HASHHASH;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.IDENT;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.INTEGER;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.LE;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.LEFTSHIFT;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.LPAREN;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.LT;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.MINUS;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.MULTI_LINE_COMMENT;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.NE;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.NEWLINE;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.OR;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.OROR;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.PERCENT;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.PLACEMARKER;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.PLUS;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.QUESTION;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.RIGHTSHIFT;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.RPAREN;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.SINGLE_LINE_COMMENT;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.SLASH;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.STAR;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.STRINGLIT;
import static org.eclipse.cdt.core.dom.parser.c99.PPToken.TILDE;
import lpg.lpgjavaruntime.IToken;
import org.eclipse.cdt.core.dom.c99.IPPTokenComparator;
import org.eclipse.cdt.core.dom.parser.c99.PPToken;
import org.eclipse.cdt.internal.core.dom.parser.c99.preprocessor.SynthesizedToken;
import org.eclipse.cdt.internal.core.dom.parser.c99.preprocessor.Token;
public class UPCPPTokenComparator implements IPPTokenComparator<IToken> {
private static final int PLACEMARKER_VALUE = Integer.MAX_VALUE;
public PPToken getKind(IToken token) {
if(token == null)
return null;
switch(token.getKind()) {
case UPCParsersym.TK_Hash : return HASH;
case UPCParsersym.TK_HashHash : return HASHHASH;
case UPCParsersym.TK_LeftParen : return LPAREN;
case UPCParsersym.TK_NewLine : return NEWLINE;
case UPCParsersym.TK_Comma : return COMMA;
case UPCParsersym.TK_RightParen : return RPAREN;
case UPCParsersym.TK_DotDotDot : return DOTDOTDOT;
case UPCParsersym.TK_EOF_TOKEN : return EOF;
case UPCParsersym.TK_stringlit : return STRINGLIT;
case UPCParsersym.TK_integer : return INTEGER;
case UPCParsersym.TK_SingleLineComment : return SINGLE_LINE_COMMENT;
case UPCParsersym.TK_MultiLineComment : return MULTI_LINE_COMMENT;
case UPCParsersym.TK_identifier : return IDENT;
case UPCParsersym.TK_charconst : return CHARCONST;
case UPCParsersym.TK_And : return AND;
case UPCParsersym.TK_Star : return STAR;
case UPCParsersym.TK_Plus : return PLUS;
case UPCParsersym.TK_Minus : return MINUS;
case UPCParsersym.TK_Tilde : return TILDE;
case UPCParsersym.TK_Bang : return BANG;
case UPCParsersym.TK_Slash : return SLASH;
case UPCParsersym.TK_Percent : return PERCENT;
case UPCParsersym.TK_RightShift : return RIGHTSHIFT;
case UPCParsersym.TK_LeftShift : return LEFTSHIFT;
case UPCParsersym.TK_LT : return LT;
case UPCParsersym.TK_GT : return GT;
case UPCParsersym.TK_LE : return LE;
case UPCParsersym.TK_GE : return GE;
case UPCParsersym.TK_EQ : return EQ;
case UPCParsersym.TK_NE : return NE;
case UPCParsersym.TK_Caret : return CARET;
case UPCParsersym.TK_Or : return OR;
case UPCParsersym.TK_AndAnd : return ANDAND;
case UPCParsersym.TK_OrOr : return OROR;
case UPCParsersym.TK_Question : return QUESTION;
case UPCParsersym.TK_Colon : return COLON;
// TODO: will removing this case cause the switch to compile into a tableswitch bytecode?
// tableswitch is faster than lookupswitch
case PLACEMARKER_VALUE : return PLACEMARKER;
}
return null;
}
public IToken createToken(int tokenToMake, int startOffset, int endOffset, String image) {
int kind;
switch(tokenToMake) {
case KIND_IDENTIFIER : kind = UPCParsersym.TK_identifier; break;
case KIND_COMPLETION : kind = UPCParsersym.TK_Completion; break;
case KIND_END_OF_COMPLETION : kind = UPCParsersym.TK_EndOfCompletion; break;
case KIND_INTEGER : kind = UPCParsersym.TK_integer; break;
case KIND_STRINGLIT : kind = UPCParsersym.TK_stringlit; break;
case KIND_INVALID : kind = UPCParsersym.TK_Invalid; break;
case KIND_PLACEMARKER : kind = PLACEMARKER_VALUE; break;
default : kind = UPCParsersym.TK_Invalid; break;
}
return new SynthesizedToken(startOffset, endOffset, kind, image);
}
public IToken cloneToken(IToken token) {
if(token instanceof Token) {
return (IToken)((Token)token).clone();
}
throw new RuntimeException("don't know what kind of token that is"); //$NON-NLS-1$
}
public int getEndOffset(IToken token) {
return token.getEndOffset();
}
public int getStartOffset(IToken token) {
return token.getStartOffset();
}
public void setEndOffset(IToken token, int offset) {
token.setEndOffset(offset);
}
public void setStartOffset(IToken token, int offset) {
token.setStartOffset(offset);
}
}

65
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/UPCParser.java
View file

@ -13,28 +13,43 @@
package org.eclipse.cdt.internal.core.dom.parser.upc;
import lpg.lpgjavaruntime.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.*;
import lpg.lpgjavaruntime.BacktrackingParser;
import lpg.lpgjavaruntime.BadParseException;
import lpg.lpgjavaruntime.BadParseSymFileException;
import lpg.lpgjavaruntime.DiagnoseParser;
import lpg.lpgjavaruntime.ErrorToken;
import lpg.lpgjavaruntime.IToken;
import lpg.lpgjavaruntime.LexStream;
import lpg.lpgjavaruntime.Monitor;
import lpg.lpgjavaruntime.NotBacktrackParseTableException;
import lpg.lpgjavaruntime.NullExportedSymbolsException;
import lpg.lpgjavaruntime.NullTerminalSymbolsException;
import lpg.lpgjavaruntime.ParseErrorCodes;
import lpg.lpgjavaruntime.ParseTable;
import lpg.lpgjavaruntime.PrsStream;
import lpg.lpgjavaruntime.RuleAction;
import lpg.lpgjavaruntime.TokenStream;
import lpg.lpgjavaruntime.UndefinedEofSymbolException;
import lpg.lpgjavaruntime.UnimplementedTerminalsException;
import org.eclipse.cdt.core.dom.ast.*;
import org.eclipse.cdt.core.dom.c99.IParserActionTokenProvider;
import org.eclipse.cdt.core.dom.c99.IParser;
import org.eclipse.cdt.core.dom.c99.IParseResult;
import org.eclipse.cdt.core.dom.c99.IPreprocessorTokenCollector;
import org.eclipse.cdt.core.dom.parser.c99.C99ParseResult;
import org.eclipse.cdt.core.dom.parser.c99.C99ParserAction;
import org.eclipse.cdt.core.dom.ast.IASTBinaryExpression;
import org.eclipse.cdt.core.dom.ast.IASTCompletionNode;
import org.eclipse.cdt.core.dom.c99.IKeywordMap;
import org.eclipse.cdt.core.dom.parser.c99.C99KeywordMap;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTKeywordExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSizeofExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSynchronizationStatement;
import org.eclipse.cdt.internal.core.dom.parser.c99.C99Lexer;
import org.eclipse.cdt.internal.core.dom.parser.c99.C99Parsersym;
import org.eclipse.cdt.core.dom.parser.upc.UPCKeywordMap;
import org.eclipse.cdt.core.dom.ast.IASTCompositeTypeSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTElaboratedTypeSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTLiteralExpression;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression;
import org.eclipse.cdt.core.dom.lrparser.IParser;
import org.eclipse.cdt.core.dom.lrparser.IParserActionTokenProvider;
import org.eclipse.cdt.core.dom.parser.upc.DOMToUPCTokenMap;
import org.eclipse.cdt.core.dom.parser.upc.UPCParserAction;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTKeywordExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSynchronizationStatement;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTUnaryExpression;
public class UPCParser extends PrsStream implements RuleAction , IParserActionTokenProvider, IParser, IPreprocessorTokenCollector<IToken>
{
@ -175,7 +190,7 @@ public class UPCParser extends PrsStream implements RuleAction , IParserActionTo
private UPCParserAction action = new UPCParserAction (this);
private List commentTokens = new ArrayList();
private IKeywordMap keywordMap = new UPCKeywordMap ();
private IKeywordMap keywordMap = new DOMToUPCTokenMap ();
public UPCParser() { // constructor
this(new UPCLexer ());
@ -1455,37 +1470,37 @@ public List getRuleTokens() {
//
// Rule 295: unary_expression ::= upc_localsizeof unary_expression
//
case 295: { action.beforeConsume(); action. consumeExpressionUpcSizeofOperator(IUPCASTSizeofExpression.op_upc_localsizeof); break;
case 295: { action.beforeConsume(); action. consumeExpressionUpcSizeofOperator(IUPCASTUnaryExpression.op_upc_localsizeof); break;
}
//
// Rule 296: unary_expression ::= upc_localsizeof ( type_name )
//
case 296: { action.beforeConsume(); action. consumeExpressionUpcSizeofTypeName(IUPCASTSizeofExpression.op_upc_localsizeof); break;
case 296: { action.beforeConsume(); action. consumeExpressionUpcSizeofTypeName(IUPCASTUnaryExpression.op_upc_localsizeof); break;
}
//
// Rule 297: unary_expression ::= upc_blocksizeof unary_expression
//
case 297: { action.beforeConsume(); action. consumeExpressionUpcSizeofOperator(IUPCASTSizeofExpression.op_upc_blocksizeof); break;
case 297: { action.beforeConsume(); action. consumeExpressionUpcSizeofOperator(IUPCASTUnaryExpression.op_upc_blocksizeof); break;
}
//
// Rule 298: unary_expression ::= upc_blocksizeof ( type_name )
//
case 298: { action.beforeConsume(); action. consumeExpressionUpcSizeofTypeName(IUPCASTSizeofExpression.op_upc_blocksizeof); break;
case 298: { action.beforeConsume(); action. consumeExpressionUpcSizeofTypeName(IUPCASTUnaryExpression.op_upc_blocksizeof); break;
}
//
// Rule 299: unary_expression ::= upc_elemsizeof unary_expression
//
case 299: { action.beforeConsume(); action. consumeExpressionUpcSizeofOperator(IUPCASTSizeofExpression.op_upc_elemsizeof); break;
case 299: { action.beforeConsume(); action. consumeExpressionUpcSizeofOperator(IUPCASTUnaryExpression.op_upc_elemsizeof); break;
}
//
// Rule 300: unary_expression ::= upc_elemsizeof ( type_name )
//
case 300: { action.beforeConsume(); action. consumeExpressionUpcSizeofTypeName(IUPCASTSizeofExpression.op_upc_elemsizeof); break;
case 300: { action.beforeConsume(); action. consumeExpressionUpcSizeofTypeName(IUPCASTUnaryExpression.op_upc_elemsizeof); break;
}
//

39
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/UPCTokenCollector.java
View file

@ -1,39 +0,0 @@
package org.eclipse.cdt.internal.core.dom.parser.upc;
import lpg.lpgjavaruntime.IToken;
import org.eclipse.cdt.core.dom.c99.IC99TokenCollector;
import org.eclipse.cdt.core.dom.c99.IParser;
import org.eclipse.cdt.core.dom.c99.IPreprocessorTokenCollector;
import org.eclipse.cdt.internal.core.dom.parser.c99.C99Parser;
import org.eclipse.cdt.internal.core.dom.parser.c99.preprocessor.SynthesizedToken;
import org.eclipse.cdt.internal.core.dom.parser.c99.preprocessor.Token;
/**
* An LPG token stream must start with a dummy token and end with an EOF token.
* @author Mike
*
*/
public class UPCTokenCollector implements IC99TokenCollector {
private IPreprocessorTokenCollector<IToken> parser;
public void setParser(IParser parser) {
this.parser = (IPreprocessorTokenCollector<IToken>) parser; // Total HACK!
this.parser.addToken(Token.DUMMY_TOKEN);
}
public void addCommentToken(IToken token) {
parser.addCommentToken(token);
}
public void addToken(IToken token) {
parser.addToken(token);
}
public void done(int translationUnitSize) {
parser.addToken(new SynthesizedToken(translationUnitSize, translationUnitSize, UPCParsersym.TK_EOF_TOKEN, ""));
}
}

20
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/ast/UPCASTCompositeTypeSpecifier.java
View file

@ -13,9 +13,11 @@ package org.eclipse.cdt.internal.core.dom.parser.upc.ast;
import org.eclipse.cdt.core.dom.ast.ASTVisitor;
import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTCompositeTypeSpecifier;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTCompositeTypeSpecifier;
@SuppressWarnings("restriction")
public class UPCASTCompositeTypeSpecifier extends CASTCompositeTypeSpecifier implements
IUPCASTCompositeTypeSpecifier {
@ -24,7 +26,18 @@ public class UPCASTCompositeTypeSpecifier extends CASTCompositeTypeSpecifier imp
private int sharedQualifier;
private IASTExpression blockSizeExpression;
public UPCASTCompositeTypeSpecifier() {
}
public UPCASTCompositeTypeSpecifier(int key, IASTName name) {
super(key, name);
}
public UPCASTCompositeTypeSpecifier(int key, IASTName name, IASTExpression blockSizeExpression) {
super(key, name);
setBlockSizeExpression(blockSizeExpression);
}
public IASTExpression getBlockSizeExpression() {
return blockSizeExpression;
}
@ -39,6 +52,11 @@ public class UPCASTCompositeTypeSpecifier extends CASTCompositeTypeSpecifier imp
public void setBlockSizeExpression(IASTExpression expr) {
this.blockSizeExpression = expr;
if(expr != null) {
expr.setParent(this);
expr.setPropertyInParent(BLOCK_SIZE_EXPRESSION);
}
}
public void setReferenceType(int referenceType) {
@ -50,7 +68,7 @@ public class UPCASTCompositeTypeSpecifier extends CASTCompositeTypeSpecifier imp
}
@Override
public boolean accept( ASTVisitor action ){
if( action.shouldVisitDeclSpecifiers ){
switch( action.visit( this ) ){

19
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/ast/UPCASTElaboratedTypeSpecifier.java
View file

@ -12,9 +12,11 @@ package org.eclipse.cdt.internal.core.dom.parser.upc.ast;
import org.eclipse.cdt.core.dom.ast.ASTVisitor;
import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTElaboratedTypeSpecifier;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTElaboratedTypeSpecifier;
@SuppressWarnings("restriction")
public class UPCASTElaboratedTypeSpecifier extends CASTElaboratedTypeSpecifier implements IUPCASTElaboratedTypeSpecifier {
private int referenceType;
@ -22,6 +24,18 @@ public class UPCASTElaboratedTypeSpecifier extends CASTElaboratedTypeSpecifier i
private IASTExpression blockSizeExpression;
public UPCASTElaboratedTypeSpecifier() {
}
public UPCASTElaboratedTypeSpecifier(int kind, IASTName name) {
super(kind, name);
}
public UPCASTElaboratedTypeSpecifier(int kind, IASTName name, IASTExpression blockSizeExpression) {
super(kind, name);
setBlockSizeExpression(blockSizeExpression);
}
public IASTExpression getBlockSizeExpression() {
return blockSizeExpression;
}
@ -36,6 +50,10 @@ public class UPCASTElaboratedTypeSpecifier extends CASTElaboratedTypeSpecifier i
public void setBlockSizeExpression(IASTExpression expr) {
this.blockSizeExpression = expr;
if(expr != null) {
expr.setParent(this);
expr.setPropertyInParent(BLOCK_SIZE_EXPRESSION);
}
}
public void setReferenceType(int referenceType) {
@ -47,6 +65,7 @@ public class UPCASTElaboratedTypeSpecifier extends CASTElaboratedTypeSpecifier i
}
@Override
public boolean accept( ASTVisitor action ){
if( action.shouldVisitDeclSpecifiers ){
switch( action.visit( this ) ){

19
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/ast/UPCASTEnumerationSpecifier.java
View file

@ -12,9 +12,11 @@ package org.eclipse.cdt.internal.core.dom.parser.upc.ast;
import org.eclipse.cdt.core.dom.ast.ASTVisitor;
import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTEnumerationSpecifier;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTEnumerationSpecifier;
@SuppressWarnings("restriction")
public class UPCASTEnumerationSpecifier extends CASTEnumerationSpecifier
implements IUPCASTEnumerationSpecifier {
@ -23,6 +25,18 @@ public class UPCASTEnumerationSpecifier extends CASTEnumerationSpecifier
private IASTExpression blockSizeExpression;
public UPCASTEnumerationSpecifier() {
}
public UPCASTEnumerationSpecifier(IASTName name) {
super(name);
}
public UPCASTEnumerationSpecifier(IASTName name, IASTExpression blockSizeExpression) {
super(name);
setBlockSizeExpression(blockSizeExpression);
}
public IASTExpression getBlockSizeExpression() {
return blockSizeExpression;
}
@ -37,6 +51,10 @@ public class UPCASTEnumerationSpecifier extends CASTEnumerationSpecifier
public void setBlockSizeExpression(IASTExpression expr) {
this.blockSizeExpression = expr;
if(expr != null) {
expr.setParent(this);
expr.setPropertyInParent(BLOCK_SIZE_EXPRESSION);
}
}
public void setReferenceType(int referenceType) {
@ -47,6 +65,7 @@ public class UPCASTEnumerationSpecifier extends CASTEnumerationSpecifier
this.sharedQualifier = shared;
}
@Override
public boolean accept( ASTVisitor action ){
if( action.shouldVisitDeclSpecifiers ){
switch( action.visit( this ) ){

15
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/ast/UPCASTForallStatement.java
View file

@ -16,12 +16,22 @@ import org.eclipse.cdt.core.dom.ast.IASTStatement;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTForallStatement;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTForStatement;
@SuppressWarnings("restriction")
public class UPCASTForallStatement extends CASTForStatement implements IUPCASTForallStatement {
private IASTExpression affinity;
private boolean affinityContinue;
public UPCASTForallStatement() {
}
public UPCASTForallStatement(IASTStatement init, IASTExpression condition,
IASTExpression iterationExpression, IASTStatement body, IASTExpression affinity) {
super(init, condition, iterationExpression, body);
setAffinityExpression(affinity);
}
public boolean isAffinityContinue() {
return affinityContinue;
}
@ -34,6 +44,10 @@ public class UPCASTForallStatement extends CASTForStatement implements IUPCASTFo
if(affinity != null)
this.affinityContinue = false;
this.affinity = affinity;
if(affinity != null) {
affinity.setParent(this);
affinity.setPropertyInParent(AFFINITY);
}
}
public void setAffinityContinue(boolean affinityContinue) {
@ -43,6 +57,7 @@ public class UPCASTForallStatement extends CASTForStatement implements IUPCASTFo
}
@Override
public boolean accept(ASTVisitor visitor) {
if(visitor.shouldVisitStatements) {
switch(visitor.visit(this)){

9
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/ast/UPCASTKeywordExpression.java
View file

@ -17,11 +17,19 @@ import org.eclipse.cdt.core.dom.upc.ast.IUPCASTKeywordExpression;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTNode;
import org.eclipse.cdt.internal.core.dom.parser.c.CBasicType;
@SuppressWarnings("restriction")
public class UPCASTKeywordExpression extends CASTNode implements IUPCASTKeywordExpression {
private int keywordKind;
public UPCASTKeywordExpression() {
}
public UPCASTKeywordExpression(int keywordKind) {
this.keywordKind = keywordKind;
}
public int getKeywordKind() {
return keywordKind;
}
@ -36,6 +44,7 @@ public class UPCASTKeywordExpression extends CASTNode implements IUPCASTKeywordE
}
@Override
public boolean accept(ASTVisitor visitor) {
if(visitor.shouldVisitExpressions) {
switch(visitor.visit(this)) {

15
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/ast/UPCASTSimpleDeclSpecifier.java
View file

@ -15,6 +15,7 @@ import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSimpleDeclSpecifier;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTSimpleDeclSpecifier;
@SuppressWarnings("restriction")
public class UPCASTSimpleDeclSpecifier extends CASTSimpleDeclSpecifier
implements IUPCASTSimpleDeclSpecifier {
@ -23,6 +24,13 @@ public class UPCASTSimpleDeclSpecifier extends CASTSimpleDeclSpecifier
private IASTExpression blockSizeExpression;
public UPCASTSimpleDeclSpecifier() {
}
public UPCASTSimpleDeclSpecifier(IASTExpression blockSizeExpression) {
setBlockSizeExpression(blockSizeExpression);
}
public IASTExpression getBlockSizeExpression() {
return blockSizeExpression;
}
@ -37,6 +45,10 @@ public class UPCASTSimpleDeclSpecifier extends CASTSimpleDeclSpecifier
public void setBlockSizeExpression(IASTExpression expr) {
this.blockSizeExpression = expr;
if(expr != null) {
expr.setParent(this);
expr.setPropertyInParent(BLOCK_SIZE_EXPRESSION);
}
}
public void setReferenceType(int referenceType) {
@ -48,7 +60,8 @@ public class UPCASTSimpleDeclSpecifier extends CASTSimpleDeclSpecifier
}
public boolean accept( ASTVisitor action ){
@Override
public boolean accept(ASTVisitor action) {
if( action.shouldVisitDeclSpecifiers ){
switch( action.visit( this ) ){
case ASTVisitor.PROCESS_ABORT : return false;

16
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/ast/UPCASTSynchronizationStatement.java
View file

@ -15,11 +15,21 @@ import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSynchronizationStatement;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTNode;
@SuppressWarnings("restriction")
public class UPCASTSynchronizationStatement extends CASTNode implements IUPCASTSynchronizationStatement {
private int statmentKind;
private IASTExpression barrierExpression = null;
public UPCASTSynchronizationStatement() {
}
public UPCASTSynchronizationStatement(IASTExpression barrierExpression, int statmentKind) {
setBarrierExpression(barrierExpression);
this.statmentKind = statmentKind;
}
public IASTExpression getBarrierExpression() {
return barrierExpression;
}
@ -30,7 +40,10 @@ public class UPCASTSynchronizationStatement extends CASTNode implements IUPCASTS
public void setBarrierExpression(IASTExpression expr) {
this.barrierExpression = expr;
if(expr != null) {
expr.setParent(this);
expr.setPropertyInParent(BARRIER_EXPRESSION);
}
}
public void setStatementKind(int kind) {
@ -38,6 +51,7 @@ public class UPCASTSynchronizationStatement extends CASTNode implements IUPCASTS
}
@Override
public boolean accept(ASTVisitor visitor) {
if(visitor.shouldVisitStatements) {
switch(visitor.visit(this)) {

18
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/ast/UPCASTTypeIdExpression.java Normal file
View file

@ -0,0 +1,18 @@
package org.eclipse.cdt.internal.core.dom.parser.upc.ast;
import org.eclipse.cdt.core.dom.ast.IASTTypeId;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTTypeIdExpression;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTTypeIdExpression;
@SuppressWarnings("restriction")
public class UPCASTTypeIdExpression extends CASTTypeIdExpression implements
IUPCASTTypeIdExpression {
public UPCASTTypeIdExpression() {
}
public UPCASTTypeIdExpression(int op, IASTTypeId typeId) {
super(op, typeId);
}
}

15
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/ast/UPCASTTypedefNameSpecifier.java
View file

@ -12,9 +12,11 @@ package org.eclipse.cdt.internal.core.dom.parser.upc.ast;
import org.eclipse.cdt.core.dom.ast.ASTVisitor;
import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTTypedefNameSpecifier;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTTypedefNameSpecifier;
@SuppressWarnings("restriction")
public class UPCASTTypedefNameSpecifier extends CASTTypedefNameSpecifier
implements IUPCASTTypedefNameSpecifier {
@ -24,6 +26,14 @@ public class UPCASTTypedefNameSpecifier extends CASTTypedefNameSpecifier
private IASTExpression blockSizeExpression;
public UPCASTTypedefNameSpecifier() {
}
public UPCASTTypedefNameSpecifier(IASTName name, IASTExpression blockSizeExpression) {
super(name);
setBlockSizeExpression(blockSizeExpression);
}
public IASTExpression getBlockSizeExpression() {
return blockSizeExpression;
}
@ -38,6 +48,10 @@ public class UPCASTTypedefNameSpecifier extends CASTTypedefNameSpecifier
public void setBlockSizeExpression(IASTExpression expr) {
this.blockSizeExpression = expr;
if(expr != null) {
expr.setParent(this);
expr.setPropertyInParent(BLOCK_SIZE_EXPRESSION);
}
}
public void setReferenceType(int referenceType) {
@ -49,6 +63,7 @@ public class UPCASTTypedefNameSpecifier extends CASTTypedefNameSpecifier
}
@Override
public boolean accept( ASTVisitor action ){
if( action.shouldVisitDeclSpecifiers ){
switch( action.visit( this ) ){

28
upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/ast/UPCASTSizeofExpression.java → upc/org.eclipse.cdt.core.parser.upc/src/org/eclipse/cdt/internal/core/dom/parser/upc/ast/UPCASTUnaryExpression.java
View file

@ -10,29 +10,17 @@
*******************************************************************************/
package org.eclipse.cdt.internal.core.dom.parser.upc.ast;
import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTSizeofExpression;
import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.upc.ast.IUPCASTUnaryExpression;
import org.eclipse.cdt.internal.core.dom.parser.c.CASTUnaryExpression;
public class UPCASTSizeofExpression extends CASTUnaryExpression implements IUPCASTSizeofExpression {
@SuppressWarnings("restriction")
public class UPCASTUnaryExpression extends CASTUnaryExpression implements IUPCASTUnaryExpression {
// TODO: don't really know if extending CASTUnaryExpression is the right thing to do
private int upcSizeofOperator;
public int getOperator() {
return IASTUnaryExpression.op_sizeof;
}
public void setUPCSizeofOperator(int upcSizeofOperator) {
this.upcSizeofOperator = upcSizeofOperator;
}
public int getUPCSizeofOperator() {
return upcSizeofOperator;
public UPCASTUnaryExpression() {
}
public UPCASTUnaryExpression(int operator, IASTExpression operand) {
super(operator, operand);
}
}