The trufflepascal from aspect26

JUnitTest class failures

Since the class contains no actual JUnit tests, it shall be marked with @Ignore.

Compare subroutine headers upon forwarding

Readln and Writeln

Readln and Writeln buitin subroutines are a TP extension. They are not supported by wirth's standard

Reference passing is supported in TP but not in Wirth's Pascal

When the two parsers and grammar files (for Wirth and TP) are separated, move reference passing to TP only

Numeric literal

Rename numericLiteral to integerLiteral in pascal.atg

Unit: graph

Implement Graph unit:

Arc - Draw part of a circle
Bar - Draw filled rectangle
Bar3D - Draw filled 3-dimensional rectangle
ClearDevice - Clear the complete screen
Closegraph - Close graphical system.
DetectGraph - Detect correct graphical driver to use
DrawPoly - Draw a polygone
Ellipse - Draw an ellipse
FillEllipse - Draw and fill an ellipse
FillPoly - Draw, close and fill a polygone
FloodFill - Fill an area with a given color
GetArcCoords - Return coordinates of last drawn arc or ellipse.
GetAspectRatio - Return screen resolution
GetColor - Return current drawing color
GetDefaultPalette - Return default palette
GetDirectVideo - Determine whether direct video mode is active.
GetDriverName - Return current driver name
GetFillPattern - Return current fill pattern
GetFillSettings - Return current fill settings
GetGraphMode - Get current graphical modus
GetLineSettings - Get current line drawing settings
GetMaxColor - return maximum number of colors
GetMaxMode - Return biggest mode for the current driver
GetMaxX - Return maximal X coordinate
GetMaxY - Return maximal Y coordinate
GetModeName - Return description a modus
GetModeRange - Return lowest and highest modus of current driver
GetPalette - Return current palette
GetPaletteSize - Return maximal number of entries in current palette
GetTextSettings - Return current text style
GetViewSettings - Return current viewport
GetX - Return current cursor X position
GetY - Return current cursor Y position
GraphDefaults - Reset graphical mode to defaults
GraphErrorMsg - Return a description of an error
GraphResult - Result of last graphical operation
InitGraph - Initialize grpahical system
InstallUserDriver - Install a user driver
InstallUserFont - Install a user-defined font
LineRel - Draw a line starting from current position in given direction
LineTo - Draw a line starting from current position to a given point
MoveRel - Move cursor relative to current position
MoveTo - Move cursor to absolute position.
OutText - Write text on the screen at the current location.
PieSlice - Draw a pie-slice
queryadapterinfo - Function called to retrieve the current video adapter settings.
Rectangle - Draw a rectangle on the screen.
RegisterBGIDriver - Register a new BGI driver.
RegisterBGIfont - Register a new BGI font
RestoreCrtMode - Restore text screen
Sector - Draw and fill a sector of an ellipse
SetAspectRatio - Set aspect ration of the screen
SetColor - Set foreground drawing color
SetDirectVideo - Attempt to enter direct video mode.
SetFillPattern - Set drawing fill pattern
SetFillStyle - Set drawing fill style
SetGraphMode - Set graphical mode
SetLineStyle - Set line drawing style
SetPalette - Set palette entry using color constant
SetTextJustify - Set text placement style
SetTextStyle - Set text style
SetUserCharSize - Set user character size for vector font
SetViewPort - Set the graphical drawing window
SetWriteMode - Specify binary operation to perform when drawing on screen
TextHeight - Return height (in pixels) of the given string
TextWidth - Return width (in pixels) of the given string

PrimitiveDescriptors

move primitive descriptors to its own file
the same with builtin procedure descriptors (even enums maybe)

The simpleMultipleRead test suggests that only new-line character is a separator for multiple arguments in the readln() procedure. However, the code readln(i, j); for two integers shall read two numbers on both inputs: 42 24 and 42\n24.

Unit: string

Implement string unit:

Sets

Implement Pascal sets and set operations.

Passing by reference

Implement passing subroutine arguments by reference.

Support program parameters

from wirth's standard:

program = program-heading ';' program-block '.'.
program-block = block.
program-heading = 'program' identifier [ '(' program-parameter-list ')' ] .
program-parameter-list = identifier-list.

EDIT:
this includes binding of file names/paths to file type variables, example:

program copy (f, g);
var f, g : file of char;
    c: char;
begin
  reset(f) ; rewrite(g);
  while not eof(f) do begin
    read(f, c); write(g, c);
  end;
end.

execution:
trupple copy.pas alpha.txt bravo.txt

+ operator for strings and chars in TP

Comments

Wirth's pascal:
Where a commentary shall be any sequence of characters and separations of lines, containing neither } nor *), the construct

( '{' | '(' ) commentary ( ')' | '}' )

shall be a comment if neither the { nor the (* occurs within a character-string or within a commentary.

NOTES

1 A comment may thus commence with { and end with ), or commence with ( and end with }.

2 The sequence (*) cannot occur in a commentary even though the sequence {) can.

Turbo Pascal:
comment beginnig with { must end with } and comment beginnig with (* must end with *).

Compilation time checking

Implement type checking during compilation time:

Support all ordinal types in for cycle

Refactor Random and Randomize node

Remove them from grammar file
only in TP

Pointers

Implement pointers

Record

defining custom record type
using variable of record type
with statement

Refactor NodeFactory source file

this.lexicalScope
shorten the file

LessThanOrEqualNode does not implement variant for all possible operands

Custom subrange type

It is not possible to define a custom type which is a subrange

Negative array indexing

There is currently a problem with negative array idnexing.

Quote parsing broken

@Test
public void stringDoubleQuotesTwoTimes() {
    test("program quoting; begin writeln('''', '''') end.", "''");
}

The test program prints '', '' instead of ''.

Second parser

Create two separate parsers: one for wirth's pascal and the second one for turbo pascal

Type

Implement Type statements.

Global defined types cannot be used in subroutines

LocalIdentifiersTable of subroutines doesn't contain types defined in the parent lexical scope

TP constants

TP has extended constants

Symmetric difference of sets

Implement >< operator for sets for TP extension

End-of-line handling

Currently, the unit tests expects CR-LF line endings for input. The standard does not explicitly state that there is only one kind of line ending. It would be nice if all CR, LF and CR+LF would be supported (as in FreePascal).

Trupple.jar does not contain any Trupple classes (Ant)

The generated build/Trupple.jar shall be a standalone JAR, i.e. there ought to be packaged all the cz.cuni.mff.d3s.trupple classes. On the other hand, the JUnit related JARs are not really necessary there.

Fix ' in string

Character sequence '' in string shall represent ' character in string.

Block in wirth's pascal

block = label-declaration-part constant-definition-part type-definition-part
variable-declaration-part procedure-and-function-declaration-part
statement-part.

    label-declaration-part = [ 'label' label { ',' label } ' ;' ].

    constant-definition-part = [ 'const' constant-definition ' ;' { constant-definition ';' } ].

    type-definition-part = [ 'type' type-definition ' ;' { type-definition ';' } ].

    variable-declaration-part = [ 'var' variable-declaration ' ;' { variable-declaration ';' } ].

    procedure-and-function-declaration-part = { ( procedure-declaration
                                                | function-declaration ) ';' }.

Create missing tests for builtin nodes

random, randomize
succ, pred

Source code organization

It would be nice if the project would follow a more standardized source code organization.

The src should be split into src and src-test: that would simplify compilation of Trupple with and without tests (alternative naming is src/java and src/test-java, or src/main and src/test). And the lib folder can be a top-level one.

Unable to run JUnit from Ant

Classpath is missing in the <junit> task:

diff --git a/build.xml b/build.xml
index 3be40df..e265e95 100644
--- a/build.xml
+++ b/build.xml
@@ -67,6 +67,7 @@
                 <fileset dir="${lib.dir}">
                     <include name="**/*.jar"/>
                 </fileset>
+                <pathelement location="${build.dir}"/>
             </classpath>
 
             <batchtest todir="${reports.dir}">

Unit: crt

Implement crt unit:

Support required subroutines

File handling procedures (Pre-requisite: #4 ):

Dynamic allocation procedures (Pre-requisite: #5 ):

new(p)
new(p,c l ,...,cn)
dispose(q)
dispose(q,kl ,...,km)

Arithmetic functions (Pre-requisite: none ):

abs(x) absolute value of x
sqr(x) square of x, It shall be an error if such a value does not exist.
sin(x) sine of x, where x is in radians
cos(x) cosine of x, where x is in radians
exp(x) base of natural logarithms raised to the power x
ln(x) natural logarithm of x, if x is greater than zero, It shall be an error if x is not greater than zero.
sqrt(x) non-negative square root of x, if x is not negative, It shall be an error if x is negative.
arctan(x)

Transfer functions (Pre-requisite: none ):

trunc(x)
round(x)

Ordinal functions (Pre-requisite: none ):

ord(x)
chr(x)
succ(x)
pred(x)

Boolean functions (Pre-requisite: #4 ):

odd(x)
eof(f)
eol(f)

LessThanNode does not implement variant for all possible operands

Remove expression from the list of statements

expression is not a statement duh...

program main;
begin
 5;
end.

is not supported in wirth's pascal nor turbo pascal

Support for `program' keyword

The simplest program in standard Pascal is not runnable:

program Hello;
begin
	writeln('Hello, World!');
end.

$ java -cp build/:Trupple.jar cz.cuni.mff.d3s.trupple.compiler.CompilerMain Hello.pas
-- line 1 col 1: invalid Pascal
Errors while parsing source file, the code cannot be interpreted...

Idea: a bit more readable unit tests

The current unit tests force the developer to inherit from JUnitTest and then uses an overloaded method to actually execute the test.

Following snippet builds the test a bit more slowly but it clearly states what are the individual strings (note that newlines are added automatically to individual arguments of the setSource to decrease occurrences of the escape sequences). The first test uses fluent interface to make the code more compact.

@Test
public void copy() {
    TruppleTest
        .create()
        .setSource(
            "program copy;",
            "var i : integer;",
            "begin readln(i); writeln(i); end."
        )
        .setInput("42");
        .expectsOutput("42");
        .run();
}

@Test
public void simpleUnit() {
    TruppleTest test = new TruppleTest();
    test.addImport(
        "UNIT math;",
        "",
        "INTERFACE",
        "",
        "function add(a,b:integer): integer;",
        /* etc. */
    );
    test.setStandard("tp6");
    test.setSource(
        "uses math;",
        "begin",
        "    write(add(3,5));",
        "end."
    );
    test.expectsOutput("8");
    test.run();
}

Standard flag

The compiler shall support flag which specifies the Pascal standard that will be used during the interpretation (e.g.: --std=turbo)

NOTE: break is not supported by original standard

flag
break statement

Required constants

from standard:

The required constant-identifiers shall be as specified in 6.4.2.2 and 6.7.2.2.
http://www.pascal-central.com/iso7185.html#6.4.2.2 Required simple-types
http://www.pascal-central.com/iso7185.html#6.7.2.2 Arithmetic operators

Unit bugs

Fix bugs in custom units:

private/global variables
custom types

Support all subrange types

subrange-type = constant '..' constant.

Examples:
1..100
-10..+10
red..green
'0'..'9'

donst forget to upgrade tests for Sets

aspect26 / trufflepascal Goto Github PK

trufflepascal's People

Contributors

Stargazers

Watchers

Forkers

trufflepascal's Issues

Recommend Projects

Recommend Topics

Recommend Org