public void TestOperators()
{
CParser testparser = new CParser();
String[] ExpressionsUse = {"12+5","{1,2,3}","14-12+5*Sqr(64)"};
Object[] Expectedresults = {(object)17,(object)(new object[] {1f,2f,3f}).ToList(),14-12+5*8};
int failcount=0;
for (int i = 0; i < ExpressionsUse.Length; i++)
{
Object tempobject = testparser.Execute(ExpressionsUse[i]);
if (Convert.ChangeType(tempobject, Expectedresults[i].GetType()).Equals( Expectedresults[i])
|| (testparser.ResultToString(tempobject).Equals(testparser.ResultToString(Expectedresults[i])))
)
//if (tempobject == Expectedresults[i])
{
Debug.Print(ExpressionsUse[i] + " success. Result was " + testparser.ResultToString(tempobject));
}
else
{
Debug.Print(ExpressionsUse[i] + " failed. Result was " + testparser.ResultToString(tempobject) + "Expected result was " + testparser.ResultToString(Expectedresults[i]));
failcount++;
}
}
if (failcount > 0)
Assert.Fail(failcount.ToString() + "/" + ExpressionsUse.Length + " tests failed.");
}
public void ArrayAccessExpression(CParser.ArrayAccessExpression ArrayAccessExpression)
{
var LeftExpression = ArrayAccessExpression.Left;
var LeftCType = (LeftExpression.GetCachedCType(this) as CBasePointerType);
var LeftType = ConvertCTypeToType(LeftCType);
var ElementCType = LeftCType.ElementCType;
var ElementType = ConvertCTypeToType(ElementCType);
var IndexExpression = ArrayAccessExpression.Index;
DoGenerateAddress(false, () =>
{
Traverse(LeftExpression);
});
DoGenerateAddress(false, () =>
{
Traverse(new CParser.BinaryExpression(IndexExpression, "*", new CParser.SizeofTypeExpression(ElementCType)));
//Traverse(IndexExpression);
});
//SafeILGenerator.Sizeof(ElementType);
//SafeILGenerator.BinaryOperation(SafeBinaryOperator.MultiplySigned);
SafeILGenerator.BinaryOperation(SafeBinaryOperator.AdditionSigned);
// For fixed array types, get always the address?
if (ElementCType is CArrayType && (ElementCType as CArrayType).Size != 0)
{
}
else if (!GenerateAddress)
{
SafeILGenerator.LoadIndirect(ConvertCTypeToType(ElementCType));
}
}
public void Convert()
{
var lexer = new CLexer(rdr);
var parser = new CParser(parserState, lexer);
var declarations = parser.Parse();
var symbolTable = new SymbolTable(platform)
{
NamedTypes = {
{ "off_t", new PrimitiveType_v1 { Domain = Domain.SignedInt, ByteSize = 4 } }, //$BUGBUG: arch-dependent!
{ "ssize_t", new PrimitiveType_v1 { Domain = Domain.SignedInt, ByteSize = 4 } }, //$BUGBUG: arch-dependent!
{ "size_t", new PrimitiveType_v1 { Domain = Domain.UnsignedInt, ByteSize = 4 } }, //$BUGBUG: arch-dependent!
{ "va_list", new PrimitiveType_v1 { Domain = Domain.Pointer, ByteSize = platform.PointerType.Size } }
}
};
foreach (var decl in declarations)
{
symbolTable.AddDeclaration(decl);
}
var lib = new SerializedLibrary
{
Types = symbolTable.Types.ToArray(),
Procedures = symbolTable.Procedures.ToList(),
};
var ser = SerializedLibrary.CreateSerializer();
ser.Serialize(writer, lib);
}
public void TypeDeclaration(CParser.TypeDeclaration TypeDeclaration)
{
var CStructType = TypeDeclaration.Symbol.CType.GetCUnionStructType();
if (CStructType != null)
{
Console.WriteLine("");
Console.WriteLine("\t/// <summary>");
Console.WriteLine("\t/// </summary>");
Console.WriteLine("\tpublic struct {0}", TypeDeclaration.Symbol.Name);
Console.WriteLine("\t{");
{
for (int n = 0; n < CStructType.Items.Count; n++)
{
var Item = CStructType.Items[n];
if (n != 0)
{
Console.WriteLine("");
}
Console.WriteLine("\t\t/// <summary>");
Console.WriteLine("\t\t/// </summary>");
Console.WriteLine("\t\tpublic {0} {1};", ConvertCTypeToTypeString(Item.CType), Item.Name);
}
}
Console.WriteLine("\t}");
}
}
public void FunctionDeclaration(CParser.FunctionDeclaration FunctionDeclaration)
{
if (FunctionDeclaration.FunctionBody != null)
{
//Console.WriteLine(FunctionDeclaration.FunctionBody);
Console.WriteLine("");
Console.WriteLine("\t/// <summary>");
Console.WriteLine("\t/// </summary>");
foreach (var Parameter in FunctionDeclaration.CFunctionType.Parameters)
{
Console.WriteLine("\t/// <param name=\"{0}\"></param>", Parameter.Name);
}
if (ConvertCTypeToType(FunctionDeclaration.CFunctionType.Return) != typeof(void))
{
Console.WriteLine("\t/// <returns></returns>");
}
Console.WriteLine("\t[DllImport(DllName)]");
string FunctionHeader = "";
FunctionHeader += "static public";
FunctionHeader += " " + ConvertCTypeToTypeString(FunctionDeclaration.CFunctionType.Return);
FunctionHeader += " " + FunctionDeclaration.CFunctionType.Name;
FunctionHeader += "(";
FunctionHeader += String.Join(", ", FunctionDeclaration.CFunctionType.Parameters.Select(Item =>
{
return ConvertCTypeToTypeString(Item.CType) + " " + Item.Name;
}));
FunctionHeader += ")";
Console.WriteLine("\t{0};", FunctionHeader);
//ConvertCTypeToType(FunctionDeclaration.CFunctionType.Return);
}
}
public void ParseTypedef()
{
CreateLexer("typedef int GOO;");
CParser parser = new CParser(parserState, lexer);
var decl = parser.Parse();
//Assert.AreEqual("int", td.TypeSpecifier.ToString());
//Assert.AreEqual("GOO", td.Declarators[0]);
}
public override CParser CreateCParser(TextReader rdr, ParserState?state)
{
state ??= new ParserState();
var lexer = new CLexer(rdr, CLexer.MsvcCeKeywords);
var parser = new CParser(state, lexer);
return(parser);
}
public void ParseTypedef()
{
CreateLexer("typedef int GOO;");
CParser parser = new CParser(parserState, lexer);
var decl = parser.Parse();
//Assert.AreEqual("int", td.TypeSpecifier.ToString());
//Assert.AreEqual("GOO", td.Declarators[0]);
}
public CLogicNodeList(CParser _parent)
{
m_Parent = _parent;
m_OWS = new CLogicNode(this);
int a = -1;
m_OWS.m_NodeNo = (byte)a;
}
private void Given_Parser(string cText)
{
var state = new ParserState();
var lexer = new CLexer(new StringReader(cText), CLexer.MsvcKeywords);
var cparser = new CParser(state, lexer);
var attr = cparser.Parse_AttributeSpecifier();
this.sap = new ServiceAttributeParser(attr);
}
public void TestParsingEmptyLexer()
{
var m = SetupMock(new Stack <Token <CTokenType> >());
var p = new CParser(m.Object);
var sf = p.PerformParse();
Assert.That(sf, Is.Not.Null);
}
public CFunction(CParser ParentParser, String Functionname, String expression)
{
eventfunction = ParentParser.FunctionEvent;
Name = Functionname;
VariableList newvariables = ParentParser.Variables;
newvariables.Add("P", new object[] { });
mParser = new CParser(expression, ParentParser, newvariables);
}
public void TestParserThrowsExceptionIfLexerThrowsException()
{
var m = new Mock<ICLexer>();
m.SetupGet(l => l.HasMoreTokens).Returns(true);
m.Setup(l => l.GetNextToken(It.IsAny<bool>())).Throws(new Exception());
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void Program(CParser.TranslationUnit Program)
{
Console.WriteLine("using System");
Console.WriteLine("");
Console.WriteLine("static public class Invoke");
Console.WriteLine("{");
Console.WriteLine("\tconst string DllName = \"mydll.dll\";");
Traverse(Program.Declarations);
Console.WriteLine("}");
}
public void AddCode(string name, string code)
{
var pp = new Preprocessor(context.Report);
pp.AddCode("machine.h", context.MachineInfo.HeaderCode);
pp.AddCode(name, code);
var lexer = new Lexer(pp);
var parser = new CParser();
Add(parser.ParseTranslationUnit(lexer));
}
private static DeclarationListener GetDeclarationListener(CommonTokenStream commonTokenStream)
{
CParser parser = new CParser(commonTokenStream);
parser.RemoveParseListeners();
var declarationListener = new DeclarationListener();
parser.AddParseListener(declarationListener);
parser.blockItemList();
return(declarationListener);
}
TranslationUnit Parse(string code)
{
var report = new Report(new TestPrinter());
var pp = new Preprocessor(report);
pp.AddCode("stdin", code);
var lexer = new Lexer(pp);
var parser = new CParser();
return(parser.ParseTranslationUnit(lexer, report));
}
public void TestParserThrowsExceptionIfLexerThrowsException()
{
var m = new Mock <ICLexer>();
m.SetupGet(l => l.HasMoreTokens).Returns(true);
m.Setup(l => l.GetNextToken(It.IsAny <bool>())).Throws(new Exception());
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void TestMethod8()
{
var Node = CParser.StaticParseBlock(@"
{
int a = 0, b = 1;
if (a == 0 && b == 1) {
printf(""Hello World!"");
} else {
int c = 7 + atoi(""8"");
}
}
" );
Console.WriteLine(Node.ToYaml());
CollectionAssert.AreEqual(
new string[] {
"- CompoundStatement:",
" - DeclarationList:",
" - VariableDeclaration: int a",
" - BinaryExpression: =",
" - IdentifierExpression: a",
" - IntegerExpression: 0",
" - VariableDeclaration: int b",
" - BinaryExpression: =",
" - IdentifierExpression: b",
" - IntegerExpression: 1",
" - IfElseStatement:",
" - BinaryExpression: &&",
" - BinaryExpression: ==",
" - IdentifierExpression: a",
" - IntegerExpression: 0",
" - BinaryExpression: ==",
" - IdentifierExpression: b",
" - IntegerExpression: 1",
" - ExpressionStatement:",
" - FunctionCallExpression:",
" - IdentifierExpression: printf",
" - ExpressionCommaList:",
" - StringExpression: Hello World!",
" - VariableDeclaration: int c",
" - BinaryExpression: =",
" - IdentifierExpression: c",
" - BinaryExpression: +",
" - IntegerExpression: 7",
" - FunctionCallExpression:",
" - IdentifierExpression: atoi",
" - ExpressionCommaList:",
" - StringExpression: 8",
},
Node.ToYamlLines().ToArray()
);
}
CType ParseType(string code)
{
var report = new Report(new TestPrinter());
var pp = new Preprocessor(report);
pp.AddCode("stdin", code);
var lexer = new Lexer(pp);
var parser = new CParser();
var tu = parser.ParseTranslationUnit(lexer, report);
return(tu.Variables[0].VariableType);
}
public void TestParsingInvalidFirstToken()
{
Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.TERMINATOR));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void TestStringConcatTest()
{
var Node = CParser.StaticParseExpression(@" ""a"" ""b"" ");
Console.WriteLine(Node.ToYaml());
CollectionAssert.AreEqual(
new string[] {
"- StringExpression: ab",
},
Node.ToYamlLines().ToArray()
);
}
public void TestCast()
{
var Node = CParser.StaticParseExpression("(unsigned int *)a");
Console.WriteLine(Node.ToYaml());
CollectionAssert.AreEqual(
new string[] {
"- CastExpression: unsigned int *",
},
Node.ToYamlLines().ToArray()
);
}
public void TestParsingUnterminatedPPDefinition()
{
Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void TestParsingElseWithNoStartingIf()
{
Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "else"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void TestParsingInvalidPPDirectiveVerb()
{
Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.KEYWORD));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void ParseC() {
var inputStream = new AntlrInputStream(@"
int main(int argc, char **args) {
printf(args[0]);
return 0;
}");
var lexer = new CLexer(inputStream);
var commonTokenStream = new CommonTokenStream(lexer);
var parser = new CParser(commonTokenStream);
var visitor = new CstBuilderForAntlr4(parser);
visitor.Visit(parser.compilationUnit());
Console.WriteLine(visitor.FinishParsing());
}
public void TestMethod9()
{
var Node = CParser.StaticParseTranslationUnit(@"
int n = 5;
typedef unsigned int uint;
uint m;
void main(int argc, char** argv) {
if (n < 10) {
printf(""Hello World!: %d"", n);
} else {
prrintf(""Test!"");
}
}
" );
Console.WriteLine(Node.ToYaml());
CollectionAssert.AreEqual(
new string[] {
"- TranslationUnit:",
" - VariableDeclaration: int n",
" - BinaryExpression: =",
" - IdentifierExpression: n",
" - IntegerExpression: 5",
" - TypeDeclaration: typedef unsigned int uint",
" - VariableDeclaration: typedef unsigned int m",
" - (null)",
" - FunctionDeclaration: void main (int argc, char * * argv)",
" - CompoundStatement:",
" - IfElseStatement:",
" - BinaryExpression: <",
" - IdentifierExpression: n",
" - IntegerExpression: 10",
" - ExpressionStatement:",
" - FunctionCallExpression:",
" - IdentifierExpression: printf",
" - ExpressionCommaList:",
" - StringExpression: Hello World!: %d",
" - IdentifierExpression: n",
" - ExpressionStatement:",
" - FunctionCallExpression:",
" - IdentifierExpression: prrintf",
" - ExpressionCommaList:",
" - StringExpression: Test!",
},
Node.ToYamlLines().ToArray()
);
}
public CParser CreateParser(string code)
{
ICharStream stream = CharStreams.fromstring(code);
var lexer = new CLexer(stream);
lexer.AddErrorListener(new ThrowExceptionErrorListener());
ITokenStream tokens = new CommonTokenStream(lexer);
var parser = new CParser(tokens);
parser.BuildParseTree = true;
parser.RemoveErrorListeners();
parser.AddErrorListener(new ThrowExceptionErrorListener());
return(parser);
}
public void TestEmptyFunctionCall()
{
var Node = CParser.StaticParseExpression("func()");
Console.WriteLine(Node.ToYaml());
CollectionAssert.AreEqual(
new string[] {
"- FunctionCallExpression:",
" - IdentifierExpression: func",
" - ExpressionCommaList:",
},
Node.ToYamlLines().ToArray()
);
}
public void TestParsingInvalidInclude2()
{
Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "."));
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "include"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void ParseC()
{
var inputStream = new AntlrInputStream(@"
int main(int argc, char **args) {
printf(args[0]);
return 0;
}");
var lexer = new CLexer(inputStream);
var commonTokenStream = new CommonTokenStream(lexer);
var parser = new CParser(commonTokenStream);
var visitor = new CstBuilderForAntlr4(parser);
visitor.Visit(parser.compilationUnit());
Console.WriteLine(visitor.FinishParsing());
}
public void TestSimpleCompound()
{
var Node = CParser.StaticParseBlock("{ ; ; ; }");
Console.WriteLine(Node.ToYaml());
CollectionAssert.AreEqual(
new string[] {
"- CompoundStatement:",
" - CompoundStatement:",
" - CompoundStatement:",
" - CompoundStatement:",
},
Node.ToYamlLines().ToArray()
);
}
public void TestIncrementDereference2()
{
var Node = CParser.StaticParseExpression("**ptr++");
Console.WriteLine(Node.ToYaml());
CollectionAssert.AreEqual(
new string[] {
"- DereferenceExpression: *",
" - DereferenceExpression: *",
" - UnaryExpression: ++ (Right)",
" - IdentifierExpression: ptr",
},
Node.ToYamlLines().ToArray()
);
}
public void TestParsingUnknownPPDirective()
{
Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "pragma"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
var sf = p.PerformParse();
Assert.That(sf, Is.Not.Null);
m.Verify(l => l.SkipToNextLine());
}
void ProcessDocument(Document document)
{
var lexed = new LexedDocument(document, options.Report);
lexedDocuments[document.Path] = lexed;
if (document.IsCompilable)
{
var parser = new CParser();
var name = System.IO.Path.GetFileNameWithoutExtension(document.Path);
Add(parser.ParseTranslationUnit(options.Report, name, Include, lexedDocuments["_machine.h"].Tokens, lexed.Tokens));
}
}
public void TestParsingInvalidPPFunctionDefinitionWithParameters5()
{
Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "("));
tokens.Push(GenerateToken(CTokenType.SYMBOL, "CTokenType"));
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
{
var rdr = new StreamReader(new MemoryStream(bytes));
var lexer = new CLexer(rdr);
var state = new ParserState();
var parser = new CParser(state, lexer);
var symbolTable = new SymbolTable(platform);
var declarations = parser.Parse();
var tldser = new TypeLibraryDeserializer(platform, true, dstLib);
foreach (var decl in declarations)
{
ProcessDeclaration(decl, platform, tldser, symbolTable);
}
return(dstLib);
}
public static Type CompileProgram(string CProgram, bool SaveTemp = false)
{
var CILConverter = new CILConverter(SaveAssembly: SaveTemp);
CILConverter.Initialize("Program" + UniqueCounter++ + ".exe");
var CPreprocessor = new CPreprocessor();
CPreprocessor.PreprocessString(CProgram);
var PreprocessedCProgram = CPreprocessor.TextWriter.ToString();
var CCompiler = new CCompiler();
var TranslationUnit = CParser.StaticParseTranslationUnit(PreprocessedCProgram);
(CILConverter as ICConverter).ConvertTranslationUnit(CCompiler, TranslationUnit);
return(CILConverter.RootTypeBuilder);
}
public static void Main(string[] args)
{
if (args.Length > 0)
{
string inputFileName = args[0];
if (!Path.IsPathRooted(inputFileName))
{
inputFileName = Path.Combine(Environment.CurrentDirectory, inputFileName);
}
ICharStream input = new ANTLRFileStream(inputFileName);
CLexer lex = new CLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
CParser parser = new CParser(tokens);
try {
parser.translation_unit();
}
catch(RecognitionException re) {
Console.Out.WriteLine(re.StackTrace);
}
}
else
Console.Error.WriteLine("Usage: cparse <input-file>");
}
public void TestParsingBasicPPDefinition()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.SYMBOL, "FDSA"));
tokens.Push(GenerateToken(CTokenType.SYMBOL, "CTokenType"));
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
var c = p.PerformParse();
Assert.That(c, Is.Not.Null);
Assert.That(c.PreProcessorDefinitions, Is.Not.Empty);
var pp = c.PreProcessorDefinitions.First();
Assert.That(pp, Is.Not.Null);
Assert.That(pp.Identifier, Is.EqualTo("CTokenType"));
Assert.That(pp.Arguments, Is.Null);
Assert.That(pp.Replacement, Is.EqualTo("FDSA"));
}
public void TestParsingElifWithNoStartingIf()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "elif"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void TestParsingValidIfndefCondition()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.NUMERIC_LITERAL, "TEST"));
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "ifndef"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
var sf = p.PerformParse();
Assert.That(sf, Is.Not.Null);
var str = sf.PopIfCond();
Assert.That(str, Is.Not.Null);
Assert.That(str, Is.EqualTo("!defined(TEST)"));
}
public void TestParsingUnterminatedStandardInclude()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.SYMBOL, "h"));
tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "."));
tokens.Push(GenerateToken(CTokenType.SYMBOL, "test"));
tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "<"));
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "include"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void TestParsingValidEndif()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "endif"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL, "", 1));
tokens.Push(GenerateToken(CTokenType.NUMERIC_LITERAL, "1"));
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "if"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
var sf = p.PerformParse();
Assert.That(() => sf.PopIfCond(), Throws.TypeOf(typeof(InvalidOperationException)));
}
public void TestParsingIncludeStandard()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, ">"));
tokens.Push(GenerateToken(CTokenType.SYMBOL, "h"));
tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "."));
tokens.Push(GenerateToken(CTokenType.SYMBOL, "test"));
tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "<"));
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "include"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
var sf = p.PerformParse();
Assert.That(sf, Is.Not.Null);
Assert.That(sf.IncludeList.Count, Is.EqualTo(1));
Assert.That(sf.IncludeList.ElementAt(0).File, Is.EqualTo("test.h"));
Assert.That(sf.IncludeList.ElementAt(0).IsStandard, Is.True);
}
public void TestParsingUnterminatedPPDefinition()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
/// <summary>
///
/// </summary>
/// <param name="Operator"></param>
/// <param name="Left"></param>
/// <param name="Right"></param>
private void DoBinaryOperation(string Operator, CParser.Expression Left, CParser.Expression Right)
{
bool EmitConstantValue = true;
DoGenerateAddress(false, () =>
{
var LeftConstant = Left.GetCachedConstantValue(null);
var RightConstant = Right.GetCachedConstantValue(null);
// Optimization.
if ((LeftConstant != null) && (RightConstant != null))
{
//Console.WriteLine("{0} {1} {2}", LeftConstant, Operator, RightConstant);
if (LeftConstant.GetType() == typeof(int) && RightConstant.GetType() == typeof(int))
{
int LeftConstantValue = (int)LeftConstant;
int RightConstantValue = (int)RightConstant;
switch (Operator)
{
case "+": SafeILGenerator.Push(LeftConstantValue + RightConstantValue); return;
case "-": SafeILGenerator.Push(LeftConstantValue - RightConstantValue); return;
case "*": SafeILGenerator.Push(LeftConstantValue * RightConstantValue); return;
case "/": SafeILGenerator.Push(LeftConstantValue / RightConstantValue); return;
default:
Console.Error.WriteLine("Unoptimized binary operator {0}", Operator);
break;
}
}
}
Traverse(Left);
_DoBinaryLeftRightPost(Operator);
Traverse(Right);
_DoBinaryLeftRightPost(Operator);
EmitConstantValue = false;
});
if (!EmitConstantValue)
{
var LeftCType = Left.GetCachedCType(this).GetCSimpleType();
var RightCType = Right.GetCachedCType(this).GetCSimpleType();
_DoBinaryOperation(Operator, LeftCType.Sign);
}
}
public void ConvertTranslationUnit(CCompiler CCompiler, CParser.TranslationUnit Program)
{
Console.WriteLine(Program.ToYaml());
}
public void TestParsingInvalidPPDirectiveVerb()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.KEYWORD));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void TestParsingInvalidPPFunctionDefinitionWithParameters5()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "("));
tokens.Push(GenerateToken(CTokenType.SYMBOL, "CTokenType"));
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void TestParsingInvalidInclude()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.INVALID));
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "include"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void TestParsingInvalidFirstToken()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.TERMINATOR));
var p = new CParser(m.Object);
Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
}
public void TestParsingIncludeStringLiteral()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.STRING_LITERAL, "\"test.h\""));
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "include"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
var sf = p.PerformParse();
Assert.That(sf, Is.Not.Null);
Assert.That(sf.IncludeList.Count, Is.EqualTo(1));
Assert.That(sf.IncludeList.ElementAt(0).File, Is.EqualTo("test.h"));
Assert.That(sf.IncludeList.ElementAt(0).IsStandard, Is.False);
}
/// <summary>
///
/// </summary>
/// <param name="CCompiler"></param>
/// <param name="TranslationUnit"></param>
void ICConverter.ConvertTranslationUnit(CCompiler CCompiler, CParser.TranslationUnit TranslationUnit)
{
this.CCompiler = CCompiler;
Traverse(TranslationUnit);
}
protected virtual void TraverseHook(Action Action, CParser.Node ParentNode, CParser.Node Node)
{
Action();
}
public void TestParsingPPFunctionDefinitionWithParameters()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.SYMBOL, "FDSA"));
tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, ")"));
tokens.Push(GenerateToken(CTokenType.SYMBOL, "b"));
tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, ","));
tokens.Push(GenerateToken(CTokenType.SYMBOL, "a"));
tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "("));
tokens.Push(GenerateToken(CTokenType.SYMBOL, "CTokenType"));
tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
var c = p.PerformParse();
Assert.That(c, Is.Not.Null);
Assert.That(c.PreProcessorDefinitions, Is.Not.Empty);
var pp = c.PreProcessorDefinitions.First();
Assert.That(pp, Is.Not.Null);
Assert.That(pp.Identifier, Is.EqualTo("CTokenType"));
Assert.That(pp.Arguments, Is.Not.Null);
Assert.That(pp.Arguments, Is.Not.Empty);
var a = pp.Arguments.First();
Assert.That(a, Is.Not.Null);
Assert.That(a, Is.EqualTo("a"));
var b = pp.Arguments.ElementAt(1);
Assert.That(b, Is.Not.Null);
Assert.That(b, Is.EqualTo("b"));
Assert.That(pp.Replacement, Is.EqualTo("FDSA"));
}
public void TestParsingEmptyLexer()
{
var m = SetupMock(new Stack<Token<CTokenType>>());
var p = new CParser(m.Object);
var sf = p.PerformParse();
Assert.That(sf, Is.Not.Null);
}
public void TestParsingUnknownPPDirectiveSymbol()
{
Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();
var m = SetupMock(tokens);
tokens.Push(GenerateToken(CTokenType.SYMBOL));
tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));
var p = new CParser(m.Object);
var sf = p.PerformParse();
Assert.That(sf, Is.Not.Null);
m.Verify(l => l.SkipToNextLine());
}
private void Lex(string str)
{
lexer = new CLexer(new StringReader(str));
parser = new CParser(parserState, lexer);
}
