public static List<Error> Translate(Source source)
{
var err = new List<Error>();
var prg = new Program();
try
{
var input = new ANTLRStringStream(source.GetSourceData());
var lexer = new PascalLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new PascalParser(tokens);
prg = parser.program();
prg.SetSourceIdentifier(source.GetSourceIdentifier());
}
catch (RecognitionException e)
{
err.Add(new Error(FormatRecognitionException(e, source.GetSourceIdentifier())));
}
if (err.Count != 0)
return err;
var val = new Validator();
err = val.Validate(prg);
Root = prg;
return err;
}
public void ParseCondition()
{
lexer.CharStream = new ANTLRStringStream("(9*(1-a))-4*(a.bc+3*4) <= 0");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.condition();
Assert.AreEqual(res.Eq, EqType.Le);
}
public void ParseExpression()
{
lexer.CharStream = new ANTLRStringStream("(9*(1-a))-4*(a.bc+3*4)");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.expression();
Assert.AreEqual(res.List[8].Text, ")");
}
public void ParseFactor()
{
lexer.CharStream = new ANTLRStringStream("34557");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.factor();
Assert.AreEqual(res.List.First().Text, "34557");
}
public void ParseForStatement()
{
lexer.CharStream = new ANTLRStringStream("for a=1 to N do begin end;");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.forStatement();
Assert.True(res.Fs.To);
}
public void Parse(string file_path)
{
Source source = new Source(file_path);
var scanner = new PascalScanner(source);
var parser = new PascalParser(scanner);
parser.Parse();
}
public void ParseAssignStatement()
{
lexer.CharStream = new ANTLRStringStream("s := name(a.b.c, a);");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.assignStatement();
Assert.AreEqual(res.Invoke.Name.Text, "name");
}
public void ParseDottedIdentifier()
{
lexer.CharStream = new ANTLRStringStream("ID1.ID2");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var actual = new[] { "ID1", "ID2" };
var res = parser.dottedIdentifier();
CollectionAssert.AreEqual(res.Select(x => x.Text), actual);
}
static void Main(string[] args)
{
//Path to file should be in args
if (args.Length != 0)
{
var parser = new PascalParser(args[0]);
parser.Parse();
}
}
public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
{
var rdr = new StreamReader(new MemoryStream(bytes));
var lexer = new PascalLexer(rdr, false); // It seems MPW pascal doesn't allow nesting comments.
var parser = new PascalParser(lexer);
var symbolTable = new SymbolTable(platform);
var declarations = parser.Parse();
var tldser = new TypeLibraryDeserializer(platform, true, dstLib);
var constants = EvaluateConstants(declarations);
var typeImporter = new TypeImporter(platform, tldser, constants, dstLib);
typeImporter.LoadTypes(declarations);
LoadServices(declarations, typeImporter, constants, platform, dstLib);
return(dstLib);
}
static string TranslatePascalToCSharp(string pascal)
{
ICharStream input = new AntlrInputStream(pascal);
PascalLexer pascalLexer = new PascalLexer(input);
ITokenStream tokenStream = new CommonTokenStream(pascalLexer);
PascalParser pascalParser = new PascalParser(tokenStream)
{
ErrorHandler = new BailErrorStrategy()
};
var listener = new PascalParser.PascalListener();
pascalParser.AddParseListener(listener);
pascalParser.program();
return(listener.Code);
}
public void ParseType()
{
lexer.CharStream = new ANTLRStringStream("integer");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.type();
Assert.AreEqual(res.ToString(), "integer");
}
public void ParseIdentifierListParam()
{
lexer.CharStream = new ANTLRStringStream("a.b.c, d.ef.dsf");
tokens.TokenSource = lexer;
var actual = new []{"d", "ef", "dsf"};
parser = new PascalParser(tokens);
var res = parser.identifierListParam();
CollectionAssert.AreEqual(res[1].Select(x=>x.Text), actual);
}
public void ParseIdentifier()
{
lexer.CharStream = new ANTLRStringStream("ID1");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
const string actual = "ID1";
var res = parser.identifier();
Assert.AreEqual(res.Text, actual);
}
public void ParseFuncDef()
{
lexer.CharStream = new ANTLRStringStream("function A(a:integer; b,c:Z):F;var h:integer; begin end;");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.funcDef();
Assert.AreEqual(res.ReturnType.ToString(), "F");
}
public void ParseIfStatement()
{
lexer.CharStream = new ANTLRStringStream("if( a.d.c>d.as.s) then begin end;");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.ifStatement();
Assert.AreEqual(res.Cond.Eq, EqType.Gt);
}
public void ParseParameterList()
{
lexer.CharStream = new ANTLRStringStream("a:integer; b,c:F;");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.parameterList();
Assert.AreEqual(res[1].Name.Text, "b");
}
public void ParseProcDef()
{
lexer.CharStream = new ANTLRStringStream("procedure A(a:integer; b,c:Z);begin end;");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.procDef();
Assert.AreEqual(res.Name.Text, "A");
}
public void ParseProgram()
{
// в качестве аргумента в функцию могу передавать только dottedNames
const string input =
@"
program Hello;
type a = record
a : integer;
b : B;
end;
type B = record
a : integer;
end;
procedure print(a:integer);
begin
writeln(a);
end;
function sum(a:integer; b:integer):integer;
var
c : integer;
begin
c := a + b;
sum := c;
end;
var
c:a;
d:integer;
begin
c.b.a := 5;
d:=5;
c.a := sum(c.b.a, d);
for c=1 to c.a do
begin
print(c);
end;
end.
";
lexer.CharStream = new ANTLRStringStream(input);
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.program();
Assert.AreEqual(res.GetChildren().Count, 7);
}
public void ParseSimpleFunc()
{
lexer.CharStream = new ANTLRStringStream("name(a.b.c, a);");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.simpleFunc();
Assert.AreEqual(res.Name.Text, "name");
}
public void RecordDef()
{
lexer.CharStream = new ANTLRStringStream("type A = record a : integer; b,c : L end;");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.recordDef();
Assert.AreEqual(res.GetChildren().Count, 3);
}
private void Given_Parser(string src)
{
var lexer = new PascalLexer(new StringReader(src));
this.parser = new PascalParser(lexer);
}
public void ParseTerm()
{
lexer.CharStream = new ANTLRStringStream("+34557*5");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.term();
Assert.AreEqual(res.List[3].Text, "5");
}
public void ParseStdProc()
{
lexer.CharStream = new ANTLRStringStream("writeln(a.b.c, a);");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.stdProc();
Assert.AreEqual(res.Args[0].Select(x => x.Text).First(), "a");
}
public void ParseWhileStatement()
{
lexer.CharStream = new ANTLRStringStream("while ( a.d.c>1) do begin end;");
tokens.TokenSource = lexer;
parser = new PascalParser(tokens);
var res = parser.whileStatement();
Assert.AreEqual(res.Cond.Eq, EqType.Gt);
}
public static bool IsPascal(string text) => PascalParser.IsMatching(text);
