240 ...cess.tests/src-gen/at/jku/weiner/c/preprocess/xtexttests/Test0115_StupidReplacements.java
View file
@@ -0,0 +1,240 @@
package at.jku.weiner.c.preprocess.xtexttests;

import com.google.inject.Inject;
import com.google.inject.Provider;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

import org.antlr.runtime.Token;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EDataTypeEList;
import org.eclipse.emf.ecore.EObject;

import org.eclipse.xtext.generator.IFileSystemAccess;
import org.eclipse.xtext.generator.IGenerator;
import org.eclipse.xtext.generator.JavaIoFileSystemAccess;
import org.eclipse.xtext.junit4.InjectWith;
import org.eclipse.xtext.junit4.util.ParseHelper;
import org.eclipse.xtext.junit4.validation.ValidationTestHelper;
import org.eclipse.xtext.junit4.XtextRunner;
import org.eclipse.xtext.parser.antlr.ITokenDefProvider;
import org.eclipse.xtext.resource.IResourceFactory;
import org.eclipse.xtext.util.CancelIndicator;
import org.eclipse.xtext.validation.CheckMode;
import org.eclipse.xtext.validation.IResourceValidator;
import org.eclipse.xtext.validation.Issue;

import org.junit.Assert;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import at.jku.weiner.c.preprocess.tests.PreprocessInjectorProvider;
import at.jku.weiner.c.preprocess.parser.antlr.PreprocessParser;
import at.jku.weiner.c.preprocess.parser.antlr.internal.InternalPreprocessLexer;
import at.jku.weiner.c.preprocess.xtexttests.LexerAndParserTest;

import at.jku.weiner.c.preprocess.preprocess.Preprocess;
import at.jku.weiner.c.preprocess.preprocess.GroupOpt;
import at.jku.weiner.c.preprocess.preprocess.PreprocessorDirectives;
import at.jku.weiner.c.preprocess.preprocess.DefineObjectMacro;
import at.jku.weiner.c.preprocess.preprocess.PreprocessorDirectives;
import at.jku.weiner.c.preprocess.preprocess.DefineObjectMacro;
import at.jku.weiner.c.preprocess.preprocess.Code;
@SuppressWarnings("unused")
@RunWith(XtextRunner.class)
@InjectWith(PreprocessInjectorProvider.class)
public class Test0115_StupidReplacements {
@Inject
private ParseHelper<Preprocess> parseHelper;
@Inject
private ValidationTestHelper valHelper;
@Inject
private InternalPreprocessLexer lexer;
@Inject
private PreprocessParser parser;
@Inject
private ITokenDefProvider tokenDefProvider;
//@Inject
private LexerAndParserTest testHelper;
@Inject
private IGenerator generator;
@Inject
private Provider<ResourceSet> resourceSetProvider;
@Inject
private IResourceValidator validator;
@Inject
private JavaIoFileSystemAccess fileAccessSystem;
@Inject
private IResourceFactory resourceFactory;

@Before
public void initialize(){
this.testHelper = new LexerAndParserTest(lexer,
parser, tokenDefProvider);
Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("c",
this.resourceFactory);
}

@After
public void cleanUp() {
}

private String getTextFromFile(final String fileName)
throws Exception{
final Path path = Paths.get(fileName);
final String content = new String(Files.readAllBytes(path));
return content;
}

@Test (timeout=1000)
public void checkLexerTokens() throws Exception{
final String text = this.getTextFromFile(
"res/Test0115_StupidReplacements.c");
//System.out.println(text);
final String[] expected = new String[] {
"RULE_HASH",
"RULE_DEFINE",
"RULE_WHITESPACE",
"RULE_ID",
"RULE_WHITESPACE",
"RULE_DECIMAL_LITERAL",
"RULE_NEWLINE",
"RULE_HASH",
"RULE_DEFINE",
"RULE_WHITESPACE",
"RULE_ID",
"RULE_WHITESPACE",
"RULE_ID",
"RULE_WHITESPACE",
"RULE_ID",
"RULE_NEWLINE",
"RULE_ID",
"RULE_NEWLINE",
};
//final List<Token> actual = testHelper.getTokens(text);
//testHelper.outputTokens(text);
testHelper.checkTokenisation(text, expected);
}

@Test (timeout=1000)
public void checkParserResult() throws Exception {
final String text = this.getTextFromFile(
"res/Test0115_StupidReplacements.c");
final Preprocess Preprocess_0_Var
=
this.parseHelper.parse(text);
this.valHelper.assertNoErrors(Preprocess_0_Var
);

Assert.assertNotNull(Preprocess_0_Var
);
//0
final GroupOpt GroupOpt_1_Var
= (GroupOpt)Preprocess_0_Var
.getGroup();
Assert.assertNotNull(GroupOpt_1_Var
);
final EList<? extends EObject> Lines_1_list = GroupOpt_1_Var
.getLines();
Assert.assertNotNull(Lines_1_list);
Assert.assertEquals(3, Lines_1_list.size());
//1
final PreprocessorDirectives PreprocessorDirectives_2_Var
= (PreprocessorDirectives)Lines_1_list.get(0);
Assert.assertNotNull(PreprocessorDirectives_2_Var
);
//2
final DefineObjectMacro DefineObjectMacro_3_Var
= (DefineObjectMacro)PreprocessorDirectives_2_Var
.getDirective();
Assert.assertNotNull(DefineObjectMacro_3_Var
);
Assert.assertEquals("bar", DefineObjectMacro_3_Var
.getId());
Assert.assertEquals("1", DefineObjectMacro_3_Var
.getString());
//3
final PreprocessorDirectives PreprocessorDirectives_4_Var
= (PreprocessorDirectives)Lines_1_list.get(1);
Assert.assertNotNull(PreprocessorDirectives_4_Var
);
//4
final DefineObjectMacro DefineObjectMacro_5_Var
= (DefineObjectMacro)PreprocessorDirectives_4_Var
.getDirective();
Assert.assertNotNull(DefineObjectMacro_5_Var
);
Assert.assertEquals("FOO", DefineObjectMacro_5_Var
.getId());
Assert.assertEquals("FOO bar", DefineObjectMacro_5_Var
.getString());
//5
final Code Code_6_Var
= (Code)Lines_1_list.get(2);
Assert.assertNotNull(Code_6_Var
);
Assert.assertEquals("FOO", Code_6_Var
.getCode());
}

@Test
(timeout=1000
)
public void testGenerator() throws Exception {
// load the resource
ResourceSet set = this.resourceSetProvider.get();
URI uri = URI.createURI(
"res/Test0115_StupidReplacements.c");
Resource resource = set.getResource(uri, true);
// validate the resource
List<Issue> list = this.validator.validate(resource,
CheckMode.ALL,CancelIndicator.NullImpl);
Assert.assertTrue(list.isEmpty());

// configure and start the generator
this.fileAccessSystem.setOutputPath("bin");
final Class<?> clazz = this.generator.getClass();
try {
final Method method = clazz.getMethod("setFileName",
String.class);
if (method != null) {
method.invoke(this.generator, "Test0115_StupidReplacements.c.i");
}
} catch (NoSuchMethodException | SecurityException
| IllegalAccessException | IllegalArgumentException
| InvocationTargetException e) {
// do nothing
// System.out.println("do nothing!");
}
this.generator.doGenerate(resource, this.fileAccessSystem);
final String actual = this.getTextFromFile("bin/Test0115_StupidReplacements.c.i");
final String expected = this.getTextFromFile(
"expected/Test0115_StupidReplacements.c"
);
Assert.assertEquals(preprocess(expected), preprocess(actual));
// System.out.println("Code generation finished.");
}

private String preprocess(String string) throws Exception {
string = preprocessForPatterns(string);
return string;
}


private String preprocessForPatterns(String string) {
return string;
}

}


74 ....c.preprocess.tests/src/at/jku/weiner/c/preprocess/mytests/TestMacroParentheseHelper.java
View file
@@ -13,36 +13,36 @@
import at.jku.weiner.c.preprocess.utils.macros.MacroParentheseNotClosedYetException;

public class TestMacroParentheseHelper {

private final static String MACRO_NAME = "foo";
private final static String VALUE = "X Y Z";
private final static PreprocessFactory factory = PreprocessFactory.eINSTANCE;
private EList<ReplaceLine> replaceLines;

@Before
public void setUp() {
this.replaceLines = new BasicEList<ReplaceLine>();
final ReplaceLine line1 = TestMacroParentheseHelper.factory
.createReplaceLine();
line1.setString(TestMacroParentheseHelper.VALUE);
this.replaceLines.add(line1);

}

@Test
public void test00() {
final IdentifierList params = TestMacroParentheseHelper.factory
.createIdentifierList();
final DefinitionFunctionMacro macro = new DefinitionFunctionMacro(
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);

final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "();post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;X Y Z;post";
Assert.assertEquals(expected, actual);
}

@Test
public void test01() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -52,11 +52,11 @@ public void test01() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "(55);post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;55 Y Z;post";
Assert.assertEquals(expected, actual);
}

@Test
public void test02() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -67,11 +67,11 @@ public void test02() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "(3, (5));post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;3 (5) Z;post";
Assert.assertEquals(expected, actual);
}

@Test
public void test03Params() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -83,11 +83,11 @@ public void test03Params() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "((3), ((5), (3)), (3, (3), ((5))) );post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;(3) ((5), (3)) (3, (3), ((5)));post";
Assert.assertEquals(expected, actual);
}

@Test(expected = MacroParentheseNotClosedYetException.class)
public void test03() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -97,9 +97,9 @@ public void test03() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "(;post";
macro.resolve(code);
macro.resolve(code, code);
}

@Test
public void test04() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -110,11 +110,11 @@ public void test04() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "(A,());post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;A () Z;post";
Assert.assertEquals(expected, actual);
}

@Test
public void testA() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -124,11 +124,11 @@ public void testA() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "(bar);post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;bar Y Z;post";
Assert.assertEquals(expected, actual);
}

@Test
public void testB() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -139,11 +139,11 @@ public void testB() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "(0,bar);post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;0 bar Z;post";
Assert.assertEquals(expected, actual);
}

@Test
public void testC() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -153,11 +153,11 @@ public void testC() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "(((bar)));post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;((bar)) Y Z;post";
Assert.assertEquals(expected, actual);
}

@Test
public void testD() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -168,11 +168,11 @@ public void testD() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "((0),(bar));post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;(0) (bar) Z;post";
Assert.assertEquals(expected, actual);
}

@Test
public void testE() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -183,11 +183,11 @@ public void testE() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "(0,bar)(1);post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;0 bar Z(1);post";
Assert.assertEquals(expected, actual);
}

@Test
public void testF() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -197,11 +197,11 @@ public void testF() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "(0)(1);post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;0 Y Z(1);post";
Assert.assertEquals(expected, actual);
}

@Test
public void testG() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -212,11 +212,11 @@ public void testG() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ " (a,b);post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;a b Z;post";
Assert.assertEquals(expected, actual);
}

@Test
public void testH() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -227,11 +227,11 @@ public void testH() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ " ((0,b),bar);post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;(0,b) bar Z;post";
Assert.assertEquals(expected, actual);
}

@Test
public void testI() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -242,11 +242,11 @@ public void testI() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "(1,(bar,b));post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;1 (bar,b) Z;post";
Assert.assertEquals(expected, actual);
}

@Test
public void testJ() {
final IdentifierList params = TestMacroParentheseHelper.factory
@@ -258,9 +258,9 @@ public void testJ() {
TestMacroParentheseHelper.MACRO_NAME, params, this.replaceLines);
final String code = "pre;" + TestMacroParentheseHelper.MACRO_NAME
+ "(foobar1,(foo1,bar2),(foobar2)) (foo2,bar2);post";
final String actual = macro.resolve(code);
final String actual = macro.resolve(code, code);
final String expected = "pre;foobar1 (foo1,bar2) (foobar2) (foo2,bar2);post";
Assert.assertEquals(expected, actual);
}

}
25 ....jku.weiner.c.preprocess.tests/src/at/jku/weiner/c/preprocess/mytests/TestPredefined.java
View file
@@ -53,7 +53,7 @@ public class TestPredefined {
private IResourceFactory resourceFactory;
@Inject
private ValidationTestHelper valHelper;

@Test(timeout = 1000)
public void loadPredefined() throws Exception {
// load the resource
@@ -67,12 +67,12 @@ public void loadPredefined() throws Exception {
// parse helper
final String text = this.getTextFromFile("res/predefined/gcc_4.8.4.h");
final Preprocess preprocess = this.parseHelper.parse(text);

this.parseHelper.parse(text);
this.valHelper.assertNoErrors(preprocess);
Assert.assertNotNull(preprocess);
}

@Test(timeout = 1000)
public void testGenerator() throws Exception {
// load the resource
@@ -83,7 +83,7 @@ public void testGenerator() throws Exception {
final List<Issue> list = this.validator.validate(resource,
CheckMode.ALL, CancelIndicator.NullImpl);
Assert.assertTrue(list.isEmpty());

// configure and start the generator
this.fileAccessSystem.setOutputPath("bin");
this.generator.setFileName("Test0000_Empty.c.i");
@@ -97,7 +97,7 @@ public void testGenerator() throws Exception {
true, true);
Assert.assertNotNull(predefined);
Assert.assertNotNull(predefined.getGroup());

unitPredefined.setPreprocess(predefined);
model.getUnits().add(unitPredefined);
Assert.assertNotNull(predefined);
@@ -114,9 +114,10 @@ public void testGenerator() throws Exception {
Assert.assertEquals(this.preprocess(expected), this.preprocess(actual));
// System.out.println("Code generation finished.");
Assert.assertTrue(DefinitionTable.size() > 0);
Assert.assertTrue(DefinitionTable.containsAKey("__STDC__"));
final String text = "__STDC__";
Assert.assertTrue(DefinitionTable.containsAKey(text, text));
}

@Before
public void initialize() {
Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("c",
@@ -125,25 +126,25 @@ public void initialize() {
this.resourceFactory);
DefinitionTable.reset();
}

@After
public void cleanUp() {
DefinitionTable.reset();
}

private String getTextFromFile(final String fileName) throws Exception {
final Path path = Paths.get(fileName);
final String content = new String(Files.readAllBytes(path));
return content;
}

private String preprocess(String string) throws Exception {
string = this.preprocessForPatterns(string);
return string;
}

private String preprocessForPatterns(final String string) {
return string;
}

}
46 ...eprocess.tests/src/at/jku/weiner/c/preprocess/mytests/TestStringReplaceSymbolsHelper.java
View file
@@ -9,7 +9,7 @@
import at.jku.weiner.c.preprocess.utils.macros.DefinitionObjectMacro;

public class TestStringReplaceSymbolsHelper {

@Test
public void testSimplePattern() {
final String text = "FOO \"FOO\" FOO \"FOO\" FOO";
@@ -33,120 +33,120 @@ public void testSimplePattern() {
Assert.assertEquals(20, index);
Assert.assertFalse(matcher.find(21));
}

@Test
public void test00() {
final String text = "A little penguin looks at you!";
final String symbol = "penguin";
final String replacement = "red fox";
final DefinitionObjectMacro macro = new DefinitionObjectMacro(symbol,
replacement);
final String actual = macro.resolve(text);
final String actual = macro.resolve(text, text);
Assert.assertEquals("A little red fox looks at you!", actual);
}

@Test
public void test01() {
final String text = "\"A little penguin looks at you!\", said a penguin researcher.";
final String symbol = "penguin";
final String replacement = "red fox";

final DefinitionObjectMacro macro = new DefinitionObjectMacro(symbol,
replacement);
final String actual = macro.resolve(text);
final String actual = macro.resolve(text, text);
Assert.assertEquals(
"\"A little penguin looks at you!\", said a red fox researcher.",
actual);
}

@Test
public void test02() {
final String text = "Foo bar, \"\\\"Foo bar\\\"\", \\Foo bar";
final String symbol = "Foo";
final String replacement = "Bar";
final DefinitionObjectMacro macro = new DefinitionObjectMacro(symbol,
replacement);
final String actual = macro.resolve(text);
final String actual = macro.resolve(text, text);
Assert.assertEquals("Bar bar, \"\\\"Foo bar\\\"\", \\Bar bar", actual);
}

@Test
public void test04() {
final String text = "Foo bar, \"\"Foo bar\"\", \\\\Foo bar";
final String symbol = "Foo";
final String replacement = "Bar";
final DefinitionObjectMacro macro = new DefinitionObjectMacro(symbol,
replacement);
final String actual = macro.resolve(text);
final String actual = macro.resolve(text, text);
Assert.assertEquals("Bar bar, \"\"Bar bar\"\", \\\\Bar bar", actual);
}

@Test
public void test05() {
final String text = "foo = \"foo\" + \"with \\\"escaped foo\" + \"foo\" and foo;";
final String symbol = "foo";
final String replacement = "Bar";
final DefinitionObjectMacro macro = new DefinitionObjectMacro(symbol,
replacement);
final String actual = macro.resolve(text);
final String actual = macro.resolve(text, text);
Assert.assertEquals(
"Bar = \"foo\" + \"with \\\"escaped foo\" + \"foo\" and Bar;",
actual);
}

@Test
public void test06() {
final String text = "A little penguin looks at äöüÄÖÜß?!";
final String symbol = "äöüÄÖÜß";
final String replacement = "you";
final DefinitionObjectMacro macro = new DefinitionObjectMacro(symbol,
replacement);
final String actual = macro.resolve(text);
final String actual = macro.resolve(text, text);
Assert.assertEquals("A little penguin looks at you?!", actual);
}

@Test
public void test07() {
final String text = "A little penguin2 looks at you!";
final String symbol = "penguin";
final String replacement = "red fox";
final DefinitionObjectMacro macro = new DefinitionObjectMacro(symbol,
replacement);
final String actual = macro.resolve(text);
final String actual = macro.resolve(text, text);
Assert.assertEquals("A little penguin2 looks at you!", actual);
}

@Test
public void test08() {
final String text = "A little penguin looks at you!";
final String symbol = "penguin2";
final String replacement = "red fox";
final DefinitionObjectMacro macro = new DefinitionObjectMacro(symbol,
replacement);
final String actual = macro.resolve(text);
final String actual = macro.resolve(text, text);
Assert.assertEquals("A little penguin looks at you!", actual);
}

@Test
public void test09() {
final String text = "A little penguin looks at äöüÄÖÜ_ß1!";
final String symbol = "äöüÄÖÜ_ß1";
final String replacement = "you";
final DefinitionObjectMacro macro = new DefinitionObjectMacro(symbol,
replacement);
final String actual = macro.resolve(text);
final String actual = macro.resolve(text, text);
Assert.assertEquals("A little penguin looks at you!", actual);
}

@Test
public void test10() {
final String text = "A little penguin2 looks at you!";
final String symbol = "penguin2";
final String replacement = "red fox";
final DefinitionObjectMacro macro = new DefinitionObjectMacro(symbol,
replacement);
final String actual = macro.resolve(text);
final String actual = macro.resolve(text, text);
Assert.assertEquals("A little red fox looks at you!", actual);
}

}
278 ...eprocess/mytests/TestDefinitionTable.java → ...ess/utils/macros/TestDefinitionTable.java
View file

Large diffs are not rendered by default.

10 ...eprocess/mytests/TestStringification.java → ...ess/utils/macros/TestStringification.java
View file
@@ -1,4 +1,4 @@
package at.jku.weiner.c.preprocess.mytests;
package at.jku.weiner.c.preprocess.utils.macros;

import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
@@ -39,7 +39,7 @@ public void testStringification1() {
this.replaceLines.add(line);
DefinitionTable.addFunctionMacro("FOO", list, this.replaceLines);
final String code = "FOO(5)";
final String replace = DefinitionTable.resolve(code);
final String replace = DefinitionTable.fullResolve(code);
Assert.assertEquals("5 \"5\"", replace);
}

@@ -63,7 +63,7 @@ public void testStringification2() {
this.replaceLines.add(line3);
DefinitionTable.addFunctionMacro("FOO", list, this.replaceLines);
final String code = "FOO( 56 )";
final String replace = DefinitionTable.resolve(code);
final String replace = DefinitionTable.fullResolve(code);
Assert.assertEquals("56 \"56\" 56 \"56\" 56 \"56\"", replace);
}

@@ -83,7 +83,7 @@ public void testStringification3() {
this.replaceLines.add(line2);
DefinitionTable.addFunctionMacro("FOO", list, this.replaceLines);
final String code = "FOO(57)";
final String replace = DefinitionTable.resolve(code);
final String replace = DefinitionTable.fullResolve(code);
Assert.assertEquals("57 \"57\" 57 \"57\"", replace);
}

@@ -130,7 +130,7 @@ public void testStringification4() {
this.replaceLines.add(line7);
// ...
final String code = "FOO(57)";
final String replace = DefinitionTable.resolve(code);
final String replace = DefinitionTable.fullResolve(code);
Assert.assertEquals(
"5757, 57-\"57\" (5757), \"57\", \"# AB, AB ## AB\", 57 \"57\", 5757",
replace);
40 ...ess.tests/src/at/jku/weiner/c/preprocess/xtexttests/Test0114_StupidReplacements.xtexttest
View file
@@ -0,0 +1,40 @@
//----------------------------------------------------------------------
//----------------------------------------------------------------------
package at.jku.weiner.c.preprocess
language preprocess
imports at.jku.weiner.c.common.common
//----------------------------------------------------------------------
split-lexer=false
source file="res/Test0114_StupidReplacements.c"
//----------------------------------------------------------------------
lexer-tokens
HASH DEFINE WHITESPACE ID WHITESPACE ID WHITESPACE ID NEWLINE
ID NEWLINE
//----------------------------------------------------------------------
//(common::Model
//units+=
//(common::TranslationUnit
(Preprocess
group=
(GroupOpt
lines+=
(PreprocessorDirectives
directive=
(DefineObjectMacro
id++"FOO",
string++"FOO bar"
)
),
(Code
code++"FOO"
)
)
)
//)
//)
//----------------------------------------------------------------------
output file="bin/Test0114_StupidReplacements.c.i"
expected file="expected/Test0114_StupidReplacements.c"
//replacePatterns file="res/Patterns.txt"
//----------------------------------------------------------------------
//----------------------------------------------------------------------
48 ...ess.tests/src/at/jku/weiner/c/preprocess/xtexttests/Test0115_StupidReplacements.xtexttest
View file
@@ -0,0 +1,48 @@
//----------------------------------------------------------------------
//----------------------------------------------------------------------
package at.jku.weiner.c.preprocess
language preprocess
imports at.jku.weiner.c.common.common
//----------------------------------------------------------------------
split-lexer=false
source file="res/Test0115_StupidReplacements.c"
//----------------------------------------------------------------------
lexer-tokens
HASH DEFINE WHITESPACE ID WHITESPACE DECIMAL_LITERAL NEWLINE
HASH DEFINE WHITESPACE ID WHITESPACE ID WHITESPACE ID NEWLINE
ID NEWLINE
//----------------------------------------------------------------------
//(common::Model
//units+=
//(common::TranslationUnit
(Preprocess
group=
(GroupOpt
lines+=
(PreprocessorDirectives
directive=
(DefineObjectMacro
id++"bar",
string++"1"
)
),
(PreprocessorDirectives
directive=
(DefineObjectMacro
id++"FOO",
string++"FOO bar"
)
),
(Code
code++"FOO"
)
)
)
//)
//)
//----------------------------------------------------------------------
output file="bin/Test0115_StupidReplacements.c.i"
expected file="expected/Test0115_StupidReplacements.c"
//replacePatterns file="res/Patterns.txt"
//----------------------------------------------------------------------
//----------------------------------------------------------------------
5 ....c.preprocess/src/at/jku/weiner/c/preprocess/utils/expressions/ExpressionLongVisitor.java
View file
@@ -225,10 +225,7 @@ public Long evaluateForId(final boolean isDefined, final String id,
private Long evaluateForString(final String macroName,
final boolean isConst, final PostfixExpression postfix) {
final String code = this.getCode(macroName, postfix);
String macro = code;
while (DefinitionTable.containsAKey(macro)) {
macro = DefinitionTable.resolve(macro);
}
final String macro = DefinitionTable.fullResolve(code);
try {
if (macro.matches(".*[+\\-*/%><|&^]+.*")) {
final ExpressionParser parser = new ExpressionParser(
8 ....jku.weiner.c.preprocess/src/at/jku/weiner/c/preprocess/utils/macros/DefinitionEntry.java
View file
@@ -18,12 +18,12 @@ public boolean equalsMacro(final DefinitionMacro newMacro) {
return this.macro.equals(newMacro);
}

public String resolve(final String text) {
return this.macro.resolve(text);
public String resolve(final String originalText, final String text) {
return this.macro.resolve(originalText, text);
}

public boolean matches(final String text) {
return this.macro.matches(text);
public boolean matches(final String originalText, final String text) {
return this.macro.matches(originalText, text);
}

public DefinitionMacro getMacro() {
86 ...ner.c.preprocess/src/at/jku/weiner/c/preprocess/utils/macros/DefinitionFunctionMacro.java
View file
@@ -11,19 +11,19 @@
import at.jku.weiner.c.preprocess.preprocess.ReplaceLine;

public final class DefinitionFunctionMacro implements DefinitionMacro {

private static final String REGEX = "\\s*\\(";

private final String key;
private final List<String> list;
private final Pattern pattern;
private int openParens = 0;
private final boolean isVariadic;
private final String varID;

private final EList<ReplaceLine> replacements;
private final String defaultValue;

public DefinitionFunctionMacro(final String key,
final IdentifierList idList, final EList<ReplaceLine> replacements) {
if (idList == null) {
@@ -41,7 +41,7 @@ public DefinitionFunctionMacro(final String key,
+ DefinitionFunctionMacro.REGEX);
this.defaultValue = this.getDefaultValue();
}

private String getDefaultValue() {
if (this.replacements == null) {
return "";
@@ -52,12 +52,12 @@ private String getDefaultValue() {
}
return buffer.toString().trim();
}

@Override
public String getName() {
return this.key;
}

@Override
public boolean equals(final Object obj) {
if (!(obj instanceof DefinitionFunctionMacro)) {
@@ -115,14 +115,14 @@ public boolean equals(final Object obj) {
}
return true;
}

@Override
public boolean matches(final String code) {
public boolean matches(final String originalText, final String code) {
return MatchUtils.matches(code, this.pattern);
}

@Override
public String resolve(final String code) {
public String resolve(final String originalText, final String code) {
final Matcher matcher = this.pattern.matcher(code);
if (!matcher.find()) {
return code;
@@ -137,7 +137,8 @@ public String resolve(final String code) {
state = MatchUtils.calculateNextState(c, state);
if ((state == MatchState.Normal) && (i == nextMatchStartIndex)) {
this.openParens++;
i = this.searchForClosingParen(code, result, nextMatchEndIndex);
i = this.searchForClosingParen(originalText, code, result,
nextMatchEndIndex);
} else if (!matcher.find(i)) {
result.append(code.substring(i));
return result.toString();
@@ -149,9 +150,9 @@ public String resolve(final String code) {
}
return result.toString();
}
private int searchForClosingParen(final String code,
final StringBuffer result, int i) {

private int searchForClosingParen(final String originalText,
final String code, final StringBuffer result, int i) {
MatchState state = MatchState.Normal;
final List<String> params = new ArrayList<String>();
StringBuffer param = new StringBuffer("");
@@ -164,7 +165,7 @@ private int searchForClosingParen(final String code,
if ((c == ')') && (this.openParens == 0)) {
final String paramStr = param.toString();
params.add(paramStr);
this.startReplacement(result, params);
this.startReplacement(originalText, result, params);
return i;
}
param.append(c);
@@ -186,9 +187,9 @@ private int searchForClosingParen(final String code,
// should never get here
throw new MacroParentheseNotClosedYetException(code, i);
}
private void startReplacement(final StringBuffer result,
final List<String> params) {

private void startReplacement(final String originalText,
final StringBuffer result, final List<String> params) {
if (this.list == null) {
result.append(this.defaultValue);
return;
@@ -197,7 +198,7 @@ private void startReplacement(final StringBuffer result,
result.append(this.defaultValue);
return;
}

final StringBuffer temp = new StringBuffer("");
boolean concatenate = false;
for (int i = 0; i < this.replacements.size(); i++) {
@@ -207,19 +208,19 @@ private void startReplacement(final StringBuffer result,
// "', string=' "
// + string + "', temp='" + temp.toString() + "'");
String id = line.getId();

int j;
for (j = 0; j < this.list.size(); j++) {
final String key = this.list.get(j).trim();
final String orig = params.get(j).trim();
final String val = DefinitionTable.resolve(orig);
final String val = DefinitionTable.fullResolve(orig);
final DefinitionObjectMacro macro = new DefinitionObjectMacro(
key, val);
// System.out.println("key='" + key + "', orig='" + orig
// + "', val='" + val + "'");
// string = macro.resolve(string);
string = this.resolveWithRespectToConcate(macro, string,
line.isConcatenate(), concatenate, orig);
string = this.resolveWithRespectToConcate(originalText, macro,
string, line.isConcatenate(), concatenate, orig);
// System.out.println("id='" + this.key + "' i='" + i
// + "', string-after-resolve=' " + string + "', temp='"
// + temp.toString() + "'");
@@ -230,7 +231,7 @@ private void startReplacement(final StringBuffer result,
// id = macro.resolve(id);
}
}

if (this.isVariadic) {
String key = null;
if (this.varID == null) {
@@ -247,16 +248,17 @@ private void startReplacement(final StringBuffer result,
variadic.append(", ");
}
final String origVal = params.get(j).trim();
final String val = DefinitionTable.resolve(origVal);
final String val = DefinitionTable.fullResolve(origVal);
variadic.append(val);
orig.append(origVal);
isFirst = false;
}
final DefinitionObjectMacro macro = new DefinitionObjectMacro(
key, variadic.toString());
// string = macro.resolve(string);
string = this.resolveWithRespectToConcate(macro, string,
line.isConcatenate(), concatenate, orig.toString());
string = this.resolveWithRespectToConcate(originalText, macro,
string, line.isConcatenate(), concatenate,
orig.toString());
if (id != null) {
if (id.equals(key)) {
id = orig.toString();
@@ -285,15 +287,15 @@ private void startReplacement(final StringBuffer result,
}
}
final String myTemp = temp.toString().trim();
final String temp2 = DefinitionTable.resolve(myTemp);
final String temp2 = DefinitionTable.fullResolve(myTemp);
result.append(temp2);
}
private String resolveWithRespectToConcate(

private String resolveWithRespectToConcate(final String original,
final DefinitionObjectMacro macro, final String string,
final boolean concatFirst, final boolean concatSecond,
final String orig) {
String result = macro.resolve(string);
String result = macro.resolve(original, string);
if (!concatFirst && !concatSecond) {
return result;
}
@@ -308,18 +310,18 @@ private String resolveWithRespectToConcate(
if (!matcher.find()) {
return result;
}
final String string1 = macro.resolve(string.substring(0,
matcher.start()));
final String string1 = macro.resolve(original,
string.substring(0, matcher.start()));
String string2 = string.substring(matcher.start(), matcher.end());
string2 = macro2.resolve(string2);
string2 = macro2.resolve(original, string2);
result = string1 + string2;
// System.out.println("key='" + this.key + "', orig='" + orig +
// "'");
// System.out.println("string1='" + string1 + "'");
// System.out.println("string2='" + string2 + "'");
// System.out.println("result='" + result + "'");
}

if (concatSecond) {
// System.out.println("concatSecond!");
// System.out.println("string='" + string + "'");
@@ -330,16 +332,16 @@ private String resolveWithRespectToConcate(
return result;
}
String string1 = string.substring(matcher.start(), matcher.end());
string1 = macro2.resolve(string1);
string1 = macro2.resolve(original, string1);
// System.out.println("matcher.end()='" + matcher.end() + "'");
// System.out.println("string.length()='" + string.length() + "'");
final String string2 = macro.resolve(string.substring(
matcher.end(), string.length()));
final String string2 = macro.resolve(original,
string.substring(matcher.end(), string.length()));
result = string1 + string2;
}
return result;
}

private String resolveConcatenationAndStringification(final String temp) {
if (!temp.contains("#")) {
return temp;
@@ -358,7 +360,7 @@ private String resolveConcatenationAndStringification(final String temp) {
int nextStrMatchEndIndex = -1;
int nextConMatchStartIndex = -1;
int nextConMatchEndIndex = -1;

if (strMatcher.find(0)) {
nextStrMatchStartIndex = strMatcher.start();
nextStrMatchEndIndex = strMatcher.end();
@@ -395,7 +397,7 @@ private String resolveConcatenationAndStringification(final String temp) {
} else {
result.append(c);
}

if (strMatcher.find(i)) {
nextStrMatchStartIndex = strMatcher.start();
nextStrMatchEndIndex = strMatcher.end();
4 ....jku.weiner.c.preprocess/src/at/jku/weiner/c/preprocess/utils/macros/DefinitionMacro.java
View file
@@ -4,8 +4,8 @@ interface DefinitionMacro {

public String getName();

public boolean matches(String code);
public boolean matches(String originalText, String code);

public String resolve(String code);
public String resolve(String originalText, String code);

}
34 ...einer.c.preprocess/src/at/jku/weiner/c/preprocess/utils/macros/DefinitionObjectMacro.java
View file
@@ -10,6 +10,9 @@ public final class DefinitionObjectMacro implements DefinitionMacro {
private final String regex;
private final Pattern pattern;
private final boolean isIdentical;
private final boolean valueContainsKey;
private String lastExpansion = null;
private String lastOriginal = null;

public DefinitionObjectMacro(final String key, final String value) {
this.macroID = key;
@@ -21,6 +24,11 @@ public DefinitionObjectMacro(final String key, final String value) {
} else {
this.isIdentical = false;
}
if (this.replacement.contains(key)) {
this.valueContainsKey = true;
} else {
this.valueContainsKey = false;
}
}

@Override
@@ -43,15 +51,31 @@ private String getValue(String value2) {
}

@Override
public boolean matches(final String code) {
if (this.isIdentical) {
public boolean matches(final String originalText, final String code) {
if (!this.preCheck(originalText, code)) {
return false;
}
return MatchUtils.matches(code, this.pattern);
}

private boolean preCheck(final String originalText, final String code) {
if (this.isIdentical) {
return false;
}
if ((this.valueContainsKey) && code.equals(this.lastExpansion)) {
return false;
}
if ((this.valueContainsKey) && originalText.equals(this.lastOriginal)) {
return false;
}
return true;
}

@Override
public String resolve(final String code) {
public String resolve(final String originalText, final String code) {
if (!this.preCheck(originalText, code)) {
return code;
}
final Matcher matcher = this.pattern.matcher(code);
if (!matcher.find()) {
return code;
@@ -76,7 +100,9 @@ public String resolve(final String code) {
nextMatchStartIndex = matcher.start();
nextMatchEndIndex = matcher.end();
}
return result.toString();
this.lastExpansion = result.toString();
this.lastOriginal = originalText;
return this.lastExpansion;
}

@Override
18 ....jku.weiner.c.preprocess/src/at/jku/weiner/c/preprocess/utils/macros/DefinitionTable.java
View file
@@ -24,16 +24,17 @@ public static int size() {
return DefinitionTable.macros.size();
}

public static String resolve(String code) {
protected static String resolve(final String originalText, final String code) {
String result = code;
for (int i = 0; i < DefinitionTable.funcMacros.size(); i++) {
final DefinitionEntry entry = DefinitionTable.funcMacros.get(i);
code = entry.resolve(code);
result = entry.resolve(originalText, result);
}
for (int i = 0; i < DefinitionTable.objMacros.size(); i++) {
final DefinitionEntry entry = DefinitionTable.objMacros.get(i);
code = entry.resolve(code);
result = entry.resolve(originalText, result);
}
return code;
return result;
}

public static boolean isDefined(final String macroName) {
@@ -47,9 +48,10 @@ public static boolean isDefined(final String macroName) {
return result;
}

public static boolean containsAKey(final String code) {
public static boolean containsAKey(final String originalText,
final String code) {
for (final DefinitionEntry entry : DefinitionTable.macros) {
if (entry.matches(code)) {
if (entry.matches(originalText, code)) {
return true;
}
}
@@ -113,8 +115,8 @@ public static void remove(final String key) {

public static String fullResolve(final String code) {
String result = code;
while (DefinitionTable.containsAKey(result)) {
result = DefinitionTable.resolve(result);
while (DefinitionTable.containsAKey(code, result)) {
result = DefinitionTable.resolve(code, result);
}
return result;
}