Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Sign in
Toggle navigation
Menu
Open sidebar
TASTE
OpenGEODE
Commits
3f45f64e
Commit
3f45f64e
authored
Aug 06, 2014
by
dbarbera
Browse files
Added support for Implies operator
parent
56885c2f
Changes
4
Hide whitespace changes
Inline
Side-by-side
AdaGenerator.py
View file @
3f45f64e
...
...
@@ -951,6 +951,7 @@ def _assign_expression(expr):
@
expression
.
register
(
ogAST
.
ExprOr
)
@
expression
.
register
(
ogAST
.
ExprAnd
)
@
expression
.
register
(
ogAST
.
ExprXor
)
@
expression
.
register
(
ogAST
.
ExprImplies
)
def
_bitwise_operators
(
expr
):
''' Logical operators '''
code
,
local_decl
=
[],
[]
...
...
@@ -973,11 +974,19 @@ def _bitwise_operators(expr):
else
:
right_payload
=
right_str
+
string_payload
(
expr
.
right
,
right_str
)
left_payload
=
left_str
+
string_payload
(
expr
.
left
,
left_str
)
ada_string
=
u
'(Data => ({left} {op} {right})'
.
format
(
if
isinstance
(
expr
,
ogAST
.
ExprImplies
):
ada_string
=
u
'(Data => (({left} and {right}) or not {left}))'
\
.
format
(
left
=
left_payload
,
right
=
right_payload
)
else
:
ada_string
=
u
'(Data => ({left} {op} {right}))'
.
format
(
left
=
left_payload
,
op
=
expr
.
operand
,
right
=
right_payload
)
if
basic_type
.
Min
!=
basic_type
.
Max
:
ada_string
+=
u
", Length => {left}.Length"
.
format
(
left
=
left_str
)
ada_string
+=
u
')'
elif
isinstance
(
expr
,
ogAST
.
ExprImplies
):
ada_string
=
u
'(({left} and {right}) or not {left})'
.
format
(
left
=
left_str
,
right
=
right_str
)
else
:
ada_string
=
u
'({left} {op}{short} {right})'
.
format
(
left
=
left_str
,
...
...
ogParser.py
View file @
3f45f64e
...
...
@@ -999,7 +999,7 @@ def unary_expression(root, context):
def
expression
(
root
,
context
):
''' Expression analysis (e.g. 5+5*hello(world)!foo) '''
logic
=
(
lexer
.
OR
,
lexer
.
AND
,
lexer
.
XOR
)
logic
=
(
lexer
.
OR
,
lexer
.
AND
,
lexer
.
XOR
,
lexer
.
IMPLIES
)
arithmetic
=
(
lexer
.
PLUS
,
lexer
.
ASTERISK
,
lexer
.
DASH
,
lexer
.
DIV
,
lexer
.
MOD
,
lexer
.
REM
)
relational
=
(
lexer
.
EQ
,
lexer
.
NEQ
,
lexer
.
GT
,
lexer
.
GE
,
lexer
.
LT
,
lexer
.
LE
)
...
...
tests/regression/test-expressions/dataview-uniq.asn
View file @
3f45f64e
...
...
@@ -26,6 +26,6 @@ NestedSeq ::= SEQUENCE {
}
}
BoolSeqOf ::= SEQUENCE (SIZE(
2
)) OF Boolean
BoolSeqOf ::= SEQUENCE (SIZE(
4
)) OF Boolean
END
tests/regression/test-expressions/expressions.pr
View file @
3f45f64e
/* CIF PROCESS (14
5
, 15
8
), (150, 75) */
/* CIF PROCESS (14
4
, 15
9
), (150, 75) */
PROCESS expressions;
/* CIF TEXT (350, 175), (303, 2
16
) */
/* CIF TEXT (350, 175), (303, 2
32
) */
DCL i Integer;
DCL f Real;
DCL b Boolean;
...
...
@@ -11,9 +11,9 @@ DCL varSeqOf1 VarSeqof;
DCL varSeqOf2 VarSeqof;
DCL seq Seq;
DCL nestedSeq NestedSeq;
DCL b
oolSeqOf
1 BoolSeqOf;
DCL b
oolSeqOf
2 BoolSeqOf;
DCL b
oolSeqOf
3 BoolSeqOf;
DCL b
s
1 BoolSeqOf;
DCL b
s
2 BoolSeqOf;
DCL b
s
3 BoolSeqOf;
/* CIF ENDTEXT */
/* CIF START (0, 0), (100, 50) */
START;
...
...
@@ -25,140 +25,140 @@ DCL boolSeqOf3 BoolSeqOf;
INPUT run;
/* CIF TASK (-150, 200), (402, 35) */
TASK '------------------------------- Binary expressions -------------------------------';
/* CIF TASK (
5
, 250), (
90
, 35) */
/* CIF TASK (
0
, 250), (
102
, 35) */
TASK b := true;
/* CIF PROCEDURECALL (-
75
, 300), (2
5
3, 35) */
/* CIF PROCEDURECALL (-
60
, 300), (2
2
3, 35) */
CALL assert(b and true, 'b and true');
/* CIF PROCEDURECALL (-
7
5, 350), (2
53
, 35) */
/* CIF PROCEDURECALL (-5
3
, 350), (2
09
, 35) */
CALL assert(b or false, 'b or false');
/* CIF PROCEDURECALL (-
75
, 400), (2
53
, 35) */
/* CIF PROCEDURECALL (-
60
, 400), (2
22
, 35) */
CALL assert(b xor false, 'b xor false');
/* CIF TASK (14, 450), (73, 35) */
/* CIF PROCEDURECALL (-52, 450), (206, 35) */
CALL assert(b => true, 'b => true');
/* CIF TASK (14, 500), (73, 35) */
TASK i := 10;
/* CIF PROCEDURECALL (-50, 5
0
0), (203, 35) */
/* CIF PROCEDURECALL (-50, 5
5
0), (203, 35) */
CALL assert(i + 1 = 11, 'i + 1 = 11');
/* CIF PROCEDURECALL (-43,
55
0), (188, 35) */
/* CIF PROCEDURECALL (-43,
60
0), (188, 35) */
CALL assert(i - 1 = 9, 'i - 1 = 9');
/* CIF PROCEDURECALL (-49, 6
0
0), (201, 35) */
/* CIF PROCEDURECALL (-49, 6
5
0), (201, 35) */
CALL assert(i * 2 = 20, 'i * 2 = 20');
/* CIF PROCEDURECALL (-43,
65
0), (188, 35) */
/* CIF PROCEDURECALL (-43,
70
0), (188, 35) */
CALL assert(i / 2 = 5, 'i / 2 = 5');
/* CIF PROCEDURECALL (-64, 7
0
0), (230, 35) */
/* CIF PROCEDURECALL (-64, 7
5
0), (230, 35) */
CALL assert(i mod 2 = 0, 'i mod 2 = 0');
/* CIF PROCEDURECALL (-61,
75
0), (224, 35) */
/* CIF PROCEDURECALL (-61,
80
0), (224, 35) */
CALL assert(i rem 2 = 0, 'i rem 2 = 0');
/* CIF PROCEDURECALL (-29, 8
0
0), (161, 35) */
/* CIF PROCEDURECALL (-29, 8
5
0), (161, 35) */
CALL assert(i < 20, 'i < 20');
/* CIF PROCEDURECALL (-37, 850), (176, 35) */
CALL assert(i <= 10, 'i <= 10');
/* CIF PROCEDURECALL (-37, 900), (176, 35) */
CALL assert(i
>
= 10, 'i
>
= 10');
CALL assert(i
<
= 10, 'i
<
= 10');
/* CIF PROCEDURECALL (-37, 950), (176, 35) */
CALL assert(i >= 10, 'i >= 10');
/* CIF PROCEDURECALL (-37, 1000), (176, 35) */
CALL assert(i > 5, 'i > 5');
/* CIF PROCEDURECALL (-29, 10
0
0), (161, 35) */
/* CIF PROCEDURECALL (-29, 10
5
0), (161, 35) */
CALL assert(i = 10, 'i = 10');
/* CIF PROCEDURECALL (-27, 10
5
0), (156, 35) */
/* CIF PROCEDURECALL (-27, 1
1
00), (156, 35) */
CALL assert(i /= 9, 'i /= 9');
/* CIF TASK (8, 11
0
0), (85, 35) */
/* CIF TASK (8, 11
5
0), (85, 35) */
TASK f := 10.0;
/* CIF PROCEDURECALL (-74, 1
15
0), (250, 35) */
/* CIF PROCEDURECALL (-74, 1
20
0), (250, 35) */
CALL assert(f + 1.0 = 11.0, 'f + 1.0 = 11.0');
/* CIF PROCEDURECALL (-63, 12
0
0), (228, 35) */
/* CIF PROCEDURECALL (-63, 12
5
0), (228, 35) */
CALL assert(f - 1.0 = 9.0, 'f - 1.0 = 9.0');
/* CIF PROCEDURECALL (-73, 1
25
0), (248, 35) */
/* CIF PROCEDURECALL (-73, 1
30
0), (248, 35) */
CALL assert(f * 2.0 = 20.0, 'f * 2.0 = 20.0');
/* CIF PROCEDURECALL (-64, 13
0
0), (230, 35) */
/* CIF PROCEDURECALL (-64, 13
5
0), (230, 35) */
CALL assert(f / 2.0 = 5.0, 'f / 2.0 = 5.0');
/* CIF PROCEDURECALL (-49, 1350), (201, 35) */
CALL assert(f < 20.0, 'f < 20.0');
/* CIF PROCEDURECALL (-49, 1400), (201, 35) */
CALL assert(f <
= 1
0.0, 'f <
= 1
0.0');
CALL assert(f <
2
0.0, 'f <
2
0.0');
/* CIF PROCEDURECALL (-49, 1450), (201, 35) */
CALL assert(f
>
= 10.0, 'f
>
= 10.0');
CALL assert(f
<
= 10.0, 'f
<
= 10.0');
/* CIF PROCEDURECALL (-49, 1500), (201, 35) */
CALL assert(f >= 10.0, 'f >= 10.0');
/* CIF PROCEDURECALL (-49, 1550), (201, 35) */
CALL assert(f > 5.0, 'f > 5.0');
/* CIF PROCEDURECALL (-42, 1
55
0), (186, 35) */
/* CIF PROCEDURECALL (-42, 1
60
0), (186, 35) */
CALL assert(f = 10.0, 'f = 10.0');
/* CIF PROCEDURECALL (-44, 16
0
0), (191, 35) */
/* CIF PROCEDURECALL (-44, 16
5
0), (191, 35) */
CALL assert(f /= 9.0, 'f /= 9.0');
/* CIF TASK (-29, 1650), (160, 35) */
TASK fixSeqOf1 := {1, 2, 3};
/* CIF TASK (-29, 1700), (160, 35) */
TASK fixSeqOf1 := {1, 2, 3};
/* CIF TASK (-29, 1750), (160, 35) */
TASK fixSeqOf2 := {3, 4, 5};
/* CIF PROCEDURECALL (-82, 1
75
0), (267, 35) */
/* CIF PROCEDURECALL (-82, 1
80
0), (267, 35) */
CALL assert(2 in fixSeqOf1, '2 in fixSeqOf1');
/* CIF PROCEDURECALL (-112, 18
0
0), (326, 35) */
/* CIF PROCEDURECALL (-112, 18
5
0), (326, 35) */
CALL assert(not(4 in fixSeqOf1), 'not(4 in fixSeqOf1)');
/* CIF PROCEDURECALL (-137, 1
85
0), (377, 35) */
/* CIF PROCEDURECALL (-137, 1
90
0), (377, 35) */
CALL assert(fixSeqOf1 /= fixSeqOf2, 'fixSeqOf1 /= fixSeqOf2');
/* CIF TASK (-29, 19
0
0), (160, 35) */
/* CIF TASK (-29, 19
5
0), (160, 35) */
TASK fixSeqOf2 := {1, 2, 3};
/* CIF PROCEDURECALL (-132,
195
0), (367, 35) */
/* CIF PROCEDURECALL (-132,
200
0), (367, 35) */
CALL assert(fixSeqOf1 = fixSeqOf2, 'fixSeqOf1 = fixSeqOf2');
/* CIF TASK (-31, 2000), (164, 35) */
TASK varSeqOf1 := {1, 2, 3};
/* CIF TASK (-31, 2050), (164, 35) */
TASK varSeqOf1 := {1, 2, 3};
/* CIF TASK (-31, 2100), (164, 35) */
TASK varSeqOf2 := {4, 5, 6};
/* CIF PROCEDURECALL (-86, 21
0
0), (274, 35) */
/* CIF PROCEDURECALL (-86, 21
5
0), (274, 35) */
CALL assert(2 in varSeqOf1, '2 in varSeqOf1');
/* CIF PROCEDURECALL (-115, 2
15
0), (333, 35) */
/* CIF PROCEDURECALL (-115, 2
20
0), (333, 35) */
CALL assert(not(4 in varSeqOf1), 'not(4 in varSeqOf1)');
/* CIF PROCEDURECALL (-144, 22
0
0), (391, 35) */
/* CIF PROCEDURECALL (-144, 22
5
0), (391, 35) */
CALL assert(varSeqOf1 /= varSeqOf2, 'varSeqOf1 /= varSeqOf2');
/* CIF TASK (-80, 2
25
0), (263, 35) */
/* CIF TASK (-80, 2
30
0), (263, 35) */
TASK varSeqOf1 := varSeqOf1 // varSeqOf2;
/* CIF PROCEDURECALL (-130, 23
0
0), (363, 35) */
/* CIF PROCEDURECALL (-130, 23
5
0), (363, 35) */
CALL assert(length(varSeqOf1) = 6, 'lenght(varSeqOf1) = 6');
/* CIF PROCEDURECALL (-99, 2350), (300, 35) */
CALL assert(varSeqOf1(3) = 4, 'varSeqOf1(3) = 4');
/* CIF PROCEDURECALL (-99, 2400), (300, 35) */
CALL assert(varSeqOf1(
4
) =
5
, 'varSeqOf1(
4
) =
5
');
CALL assert(varSeqOf1(
3
) =
4
, 'varSeqOf1(
3
) =
4
');
/* CIF PROCEDURECALL (-99, 2450), (300, 35) */
CALL assert(varSeqOf1(4) = 5, 'varSeqOf1(4) = 5');
/* CIF PROCEDURECALL (-99, 2500), (300, 35) */
CALL assert(varSeqOf1(5) = 6, 'varSeqOf1(5) = 6');
/* CIF TASK (-32, 25
0
0), (166, 35) */
/* CIF TASK (-32, 25
5
0), (166, 35) */
TASK varSeqOf1 := {1, 2, 3};
/* CIF TASK (-31, 2
55
0), (164, 35) */
/* CIF TASK (-31, 2
60
0), (164, 35) */
TASK varSeqOf2 := {1, 2, 3};
/* CIF PROCEDURECALL (-139, 26
0
0), (381, 35) */
/* CIF PROCEDURECALL (-139, 26
5
0), (381, 35) */
CALL assert(varSeqOf1 = varSeqOf2, 'varSeqOf1 = varSeqOf2');
/* CIF TASK (-3, 2
65
0), (108, 35) */
/* CIF TASK (-3, 2
70
0), (108, 35) */
TASK s := 'HELLO';
/* CIF PROCEDURECALL (-19
1
, 27
0
0), (4
84
, 35) */
/* CIF PROCEDURECALL (-19
5
, 27
5
0), (4
92
, 35) */
CALL assert(s // s // s = 'HELLOHELLOHELLO', 's // s // s = "HELLOHELLOHELLO"');
/* CIF TASK (-66, 2750), (235, 35) */
TASK boolSeqOf1 := {true, false};
/* CIF TASK (-66, 2800), (235, 35) */
TASK boolSeqOf2 := {false, true};
/* CIF TASK (-99, 2850), (301, 35) */
TASK boolSeqOf3 := boolSeqOf1 and boolSeqOf2;
/* CIF PROCEDURECALL (-98, 2900), (298, 35) */
CALL assert(not boolSeqOf3(0), 'boolSeqOf3(0)');
/* CIF PROCEDURECALL (-110, 2950), (322, 35) */
CALL assert(not boolSeqOf3(1),'not boolSeqOf3(1)');
/* CIF TASK (-99, 3000), (301, 35) */
TASK boolSeqOf3 := boolSeqOf1 or boolSeqOf2;
/* CIF PROCEDURECALL (-86, 3050), (274, 35) */
CALL assert(boolSeqOf3(0), 'boolSeqOf3(0)');
/* CIF PROCEDURECALL (-86, 3100), (274, 35) */
CALL assert(boolSeqOf3(1), 'boolSeqOf3(1)');
/* CIF TASK (-99, 3150), (301, 35) */
TASK boolSeqOf3 := boolSeqOf1 xor boolSeqOf2;
/* CIF PROCEDURECALL (-86, 3200), (274, 35) */
CALL assert(boolSeqOf3(0), 'boolSeqOf3(0)');
/* CIF PROCEDURECALL (-86, 3250), (274, 35) */
CALL assert(boolSeqOf3(1), 'boolSeqOf3(1)');
/* CIF TASK (-60, 3300), (223, 35) */
TASK boolSeqOf3 := not boolSeqOf1;
/* CIF PROCEDURECALL (-110, 3350), (322, 35) */
CALL assert(not boolSeqOf3(0), 'not boolSeqOf3(0)');
/* CIF PROCEDURECALL (-86, 3400), (274, 35) */
CALL assert(boolSeqOf3(1), 'boolSeqOf3(1)');
/* CIF TASK (-148, 3450), (399, 35) */
/* CIF TASK (-85, 2800), (273, 35) */
TASK bs1 := {false, true, false, true};
/* CIF TASK (-85, 2850), (273, 35) */
TASK bs2 := {false, false, true, true};
/* CIF TASK (-99, 2900), (301, 35) */
TASK bs3 := {false, false, false, true};
/* CIF PROCEDURECALL (-108, 2950), (318, 35) */
CALL assert((bs1 and bs2) = bs3, 'bs1 and bs2 = bs3');
/* CIF TASK (-57, 3000), (217, 35) */
TASK bs3 := {false, true, true, true};
/* CIF PROCEDURECALL (-98, 3050), (299, 35) */
CALL assert((bs1 or bs2) = bs3, 'bs1 or bs2 = bs3');
/* CIF TASK (-60, 3100), (222, 35) */
TASK bs3 := {false, true, true, false};
/* CIF PROCEDURECALL (-105, 3150), (312, 35) */
CALL assert((bs1 xor bs2) = bs3, 'bs1 xor bs2 = bs3');
/* CIF TASK (-57, 3200), (217, 35) */
TASK bs3 := {true, false, true, true};
/* CIF PROCEDURECALL (-102, 3250), (306, 35) */
CALL assert((bs1 => bs2) = bs3, ' bs1 => bs2 = bs3');
/* CIF TASK (-148, 3300), (399, 35) */
TASK '------------------------------- Unary expressions -------------------------------';
/* CIF TASK (3, 35
0
0), (95, 35) */
/* CIF TASK (3, 3
3
50), (95, 35) */
TASK b := false;
/* CIF PROCEDURECALL (-29, 3
55
0), (160, 35) */
/* CIF PROCEDURECALL (-29, 3
40
0), (160, 35) */
CALL assert(not b, 'not b');
/* CIF TASK (-85, 3450), (273, 35) */
TASK bs1 := {false, true, false, true};
/* CIF TASK (-60, 3500), (222, 35) */
TASK bs3 := {true, false, true, false};
/* CIF PROCEDURECALL (-110, 3550), (322, 35) */
CALL assert(not bs1 = bs3, 'not bs1 = bs3');
/* CIF TASK (14, 3600), (73, 35) */
TASK i := 10;
/* CIF PROCEDURECALL (-37, 3650), (177, 35) */
...
...
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment