#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input("Simple: Tiny Expressions", "SAME;")
pattern_action_pair_list = [
# pre-contexted expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
('[A-Z]+":"', "LABEL"),
('"PRINT"', "KEYWORD"),
('[A-Z]+', "IDENTIFIER"),
('[ \\t]+', "WHITESPACE"),
]
test_str = "ABERHALLO: GUGU PRINT PRINT: PRINTERLEIN"
generator_test.do(pattern_action_pair_list, test_str, {}, choice)
#! /usr/bin/env python
import sys
sys.path.append("../../../../")
import generator_test
choice = generator_test.hwut_input("Simple: Maximum Length Match", "SAME;")
pattern_dict = {"DIGIT": "[0-9]"}
pattern_action_pair_list = [
# keyword (need to come before identifier, because otherwise they would be overruled by it.)
('"if"', "IF"),
('"else"', "ELSE"),
('"struct"', "STRUCT"),
('"for"', "FOR"),
('"typedef"', "TYPEDEF"),
('"typedefun"', "TYPEDEFUN"),
('"type"', "TYPE"),
('"def"', "DEF"),
('"fun"', "FUN"),
('"while"', "WHILE"),
('"return"', "RETURN"),
# identifier
('[_a-zA-Z][_a-zA-Z0-9]*', "IDENTIFIER"),
#
('"{"', "BRACKET_OPEN"),
('"}"', "BRACKET_CLOSE"),
('"("', "BRACKET_OPEN"),
('")"', "BRACKET_CLOSE"),
('";"', "SEMICOLON"),
('"="', "OP_ASSIGN"),
('"=="', "OP_COMPARISON"),
#! /usr/bin/env python
import generator_test
from generator_test import hwut_input
choice = hwut_input("Simple: Begin of Line (BOL), End of Line (EOL)", "SAME;")
pattern_action_pair_list = [
# pre-conditioned expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
('^[A-Z]+":"', "BOL-LABEL"),
('[A-Z]+":"', "LABEL"),
('"PRINT"', "KEYWORD"),
('[A-Z]+', "IDENTIFIER"),
('[A-Z]+$', "EOL-IDENTIFIER"),
('[ \\t]+', "WHITESPACE"),
('\\n', "NEWNLINE"),
]
test_str = \
"""HERE: THERE:
THIS THAT
HERE: THERE:
THIS THAT"""
generator_test.do(pattern_action_pair_list, test_str, {}, choice)
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input(
"Pre Conditions: Multiple Identical Pre-Conditions", "SAME;")
pattern_list = [
# -- pre-conditioned expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
#
# -- post-conditioned patterns do not need to appear before the same non-postconditioned
# patterns, since they are always longer.
#
# repetition of 'x' (one or more) **preceded** by 'good' + whitespace
'ABC/hello/',
'A([bB]+)C/world/',
'AB(C+)/[a-z]{5}/',
'(abc|ABC)/worldly/',
# normal repetition (one or more) of 'x'
'(X+)Y(Z+)/hello/',
'[xX][yY][zZ]/world/',
'XYZ/[a-z]{5}/',
'(X(Y)+Z)+/worldly/',
# whitespace
'[ \\t\\n]+',
'ABC|XYZ',
]
pattern_action_pair_list = map(
lambda re: (re, re.replace("\\t", "\\\\t").replace("\\n", "\\\\n")),
pattern_list)
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input(
"CONTINUE: Reentry analysis without return from function", "SAME;")
pattern_action_pair_list = [
# pre-conditioned expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
('[A-Z]+":"', "LABEL"),
('"PRINT"', "KEYWORD CONTINUE"),
('[A-Z]+', "IDENTIFIER CONTINUE"),
('[ \\t]+', "WHITESPACE CONTINUE"),
]
test_str = "ABERHALLO: GUGU PRINT PRINT: PRINTERLEIN"
generator_test.do(pattern_action_pair_list, test_str, {}, choice)
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input("Pre- and Post- Conditions: Priorities",
"SAME;")
def test(Info, PatternActionPairList, TestStr, Choice):
print "=========================================================================="
print info
generator_test.do(PatternActionPairList, TestStr, {}, Choice)
#=====================================================================================
pattern_action_pair_list = [
('"x"', "[A-Z]"),
('[A-Z]', "OTHER"),
('"x"/"Z"', "X / Z"),
('"A"/"x"/', "A / X /"),
('[ ]', "WHITESPACE"),
('"x"/[YZ]', "X / [YZ]"),
]
info = \
"""
(1) Same Length of Core Pattern
-- 'x' preceedes 'A/x/' thus 'A/x/' shall never trigger
-- 'x' preceedes 'x/Z', but 'x/Z' is a post conditioned pattern
=> 'x/Z' succeeds.
-- 'x/Z' preceeds 'x/[YZ]', thus for 'xZ' the second shall never match.
"""
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input("Pre Conditions: Part 2", "SAME;")
pattern_action_pair_list = [
# -- pre-conditioned expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
#
# -- post-conditioned patterns do not need to appear before the same non-postconditioned
# patterns, since they are always longer.
#
# repetition of 'x' (one or more) **preceded** by 'good' + whitespace
('"aber"/"x"+/', "ABER / X+ /"),
# something that catches what detect the pre-condition
('[a-u]+', "IDENITIFIER"),
#
('[ \\t]+/"x"+/', "WHITESPACE / X+ /"),
# normal repetition (one or more) of 'x'
('"x"+', "X+"),
# whitespace
('[ \\t\\n]+', "WHITESPACE")
]
test_str = "x xxxxx aberxxx x"
generator_test.do(pattern_action_pair_list, test_str, {}, choice)
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input("Pre Conditions: Multiple Identical Pre-Conditions", "SAME;")
pattern_list = [
# -- pre-conditioned expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
#
# -- post-conditioned patterns do not need to appear before the same non-postconditioned
# patterns, since they are always longer.
#
# repetition of 'x' (one or more) **preceded** by 'good' + whitespace
'ABC/hello/',
'A([bB]+)C/world/',
'AB(C+)/[a-z]{5}/',
'(abc|ABC)/worldly/',
# normal repetition (one or more) of 'x'
'(X+)Y(Z+)/hello/',
'[xX][yY][zZ]/world/',
'XYZ/[a-z]{5}/',
'(X(Y)+Z)+/worldly/',
# whitespace
'[ \\t\\n]+',
'ABC|XYZ',
]
pattern_action_pair_list = map(lambda re: (re, re.replace("\\t", "\\\\t").replace("\\n", "\\\\n")),
pattern_list)
test_str = """
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input(
"Pseudo Ambgiguous Post Condition: Part II",
"SAME;",
DeleteChoices=["Cpp-PathUniform", "Cpp-PathUniform-CG"])
pattern_list = [
# -- pre-contexted expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
#
# -- post-conditioned patterns do not need to appear before the same non-postconditioned
# patterns, since they are always longer.
#
# normal repetition (one or more) of 'x'
'hey/h',
'(hey)+/hey',
'hey',
# other characters
'[a-z]+',
# whitespace
'[ \\t\\n]+'
]
pattern_action_pair_list = map(lambda x: [x, x.replace("\\", "\\\\")],
pattern_list)
test_str = "heyheyhey hey yhey eyhey heyhey heyhe"
generator_test.do(pattern_action_pair_list,
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input("Pre- and Post- Conditions: Simple", "SAME;")
pattern_action_pair_list = [
# -- pre-contexted expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
#
# -- post-contexted patterns do not need to appear before the same non-postconditioned
# patterns, since they are always longer.
#
# other characters
('[a-wz]+', "OTHER+"),
# repetition of 'x' (one or more) **preceded** by 'good' + whitespace
('"hello"[ \\t]+/"x"+/[ \\t]+"world"', "HELLO / X+ / WORLD"),
#
('"x"+/[ \\t]+"world"', "X+ / WORLD"),
# repetition of 'x' (one or more) **preceded** by 'good' + whitespace
('"hello"[ \\t]+/"x"+/', "HELLO WSPC. / X+ /"),
# normal repetition (one or more) of 'x'
('"x"+', "X+"),
# whitespace
('[ \\t\\n]+', "WHITESPACE")
]
test_str = "x hello xxxbonjour hello xx world xx world hello xxx x x"
generator_test.do(pattern_action_pair_list, test_str, {}, choice)
#! /usr/bin/env python
import sys
sys.path.append("../../../../")
import generator_test
choice = generator_test.hwut_input(
"Buffer Reload: No Backward Reload -- Precondition at Border", "SAME;",
["Cpp-ASSERTS", "ANSI-C-ASSERTS"])
if choice.find("-ASSERTS") != -1:
choice = choice.replace("-ASSERTS", "")
ASSERT_str = "-DQUEX_OPTION_ASSERTS"
else:
ASSERT_str = ""
pattern_action_pair_list = [
# keyword (needs to come before identifier, because otherwise they would be overruled by it.)
('"0xxxxx"/"a"/', "0xxxxx / a"),
# identifier
('[0a-z]{2}', "IDENTIFIER"),
#
('[ \\t\\n]+', "WHITESPACE")
]
print "## NOTE: The following setup guides the lexer into a buffer reload right after"
print "## the pre-conditions. No buffer reload backwards is to appear!"
test_str = " 0xxxxxa lola"
generator_test.do(pattern_action_pair_list,
test_str, {},
choice,
#! /usr/bin/env python
import sys
sys.path.append("../../../../")
import generator_test
choice = generator_test.hwut_input("Buffer Reload: Forward Position Adaption",
"SAME;",
["Cpp-ASSERTS", "ANSI-C-ASSERTS"])
if choice.find("-ASSERTS") != -1:
choice = choice.replace("-ASSERTS", "")
ASSERT_str = "-DQUEX_OPTION_ASSERTS"
else:
ASSERT_str = ""
pattern_action_pair_list = [
# keyword (needs to come before identifier, because otherwise they would be overruled by it.)
('"X"/"XXXXXXXXX"', "1 X / ... X"),
('"XX"/"XXXXXXXY"', "2 X / ... Y"),
('"XXX"/"XXXXXXZ"', "3 X / ... Z"),
('"XXXX"/"XXXXXA"', "4 X / ... A"),
# identifier
('[_a-zA-Z][_a-zA-Z0-9]*', "IDENTIFIER"),
#
('[ \\t\\n]+', "WHITESPACE")
]
# NOTE: Buffer Length in generator_test.py = 15
# => number of X = 10, so that at lease one buffer load has to occur
test_str = """
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input("Simple: Keywords 'for', 'forest', 'forester', and 'formidable'", "SAME;", DeleteChoices=("Cpp-PathUniform", "Cpp-PathUniform-CG"))
pattern_action_pair_list = [
# pre-conditioned expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
('[a-eg-z]+', "IDENTIFIER"),
('" "+', "WHITESPACE"),
('for', "FOR"),
('forest', "FOREST"),
('forester', "FORESTER"),
('formidable', "FORMIDABLE"),
]
test_str = "for forester forest formidable forever foresmic foresti foresteri formidablek formidabl"
generator_test.do(pattern_action_pair_list, test_str, {}, choice)
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input(
"Pseudo Ambgiguous Post Condition: The Philosophical Cut", "SAME;")
pattern_list = [
# -- pre-conditioned expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
#
# -- post-conditioned patterns do not need to appear before the same non-postconditioned
# patterns, since they are always longer.
#
# normal repetition (one or more) of 'x'
# 'hey+/hey+',
'hey+/(he[y]?)+',
# other characters
'[a-z]+',
# whitespace
'[ \\t\\n]+'
]
pattern_action_pair_list = map(lambda x: [x, x.replace("\\", "\\\\")],
pattern_list)
test_str = "heyheyhe hey yhey eyhey heyhey heyhe"
generator_test.do(pattern_action_pair_list,
test_str, {},
choice,
QuexBufferSize=20)
#! /usr/bin/env python
import sys
import os
sys.path.insert(0, os.environ["QUEX_PATH"])
import generator_test
choice = generator_test.hwut_input("Buffer Reload: Backwards", "SAME;",
["Cpp-ASSERTS", "ANSI-C-ASSERTS"],
["Cpp_StrangeStream"])
if choice.find("-ASSERTS") != -1:
choice = choice.replace("-ASSERTS", "")
ASSERT_str = "-DQUEX_OPTION_ASSERTS"
else:
ASSERT_str = ""
pattern_action_pair_list = [
# keyword (needs to come before identifier, because otherwise they would be overruled by it.)
('"0xxxxxxx"/"a"/', "0xxxxxxx / a"),
# identifier
('[0a-z]{2}', "IDENTIFIER"),
#
('[ \\t\\n]+', "WHITESPACE")
]
# |12456789|
test_str = " 0xxxxxxalola 0xxxxxxxa"
generator_test.do(pattern_action_pair_list,
test_str, {},
Language=choice,
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input("Pre- and Post- Conditions: Priorities", "SAME;")
def test(Info, PatternActionPairList, TestStr, Choice):
print "=========================================================================="
print info
generator_test.do(PatternActionPairList, TestStr, {}, Choice)
#=====================================================================================
pattern_action_pair_list = [
('"x"', "[A-Z]"),
('[A-Z]', "OTHER"),
('"x"/"Z"', "X / Z"),
('"A"/"x"/', "A / X /"),
('[ ]', "WHITESPACE"),
('"x"/[YZ]', "X / [YZ]"),
]
info = \
"""
(1) Same Length of Core Pattern
-- 'x' preceedes 'A/x/' thus 'A/x/' shall never trigger
-- 'x' preceedes 'x/Z', but 'x/Z' is a post conditioned pattern
=> 'x/Z' succeeds.
-- 'x/Z' preceeds 'x/[YZ]', thus for 'xZ' the second shall never match.
"""
test_str = "AxZ Ax xY"
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input("Pre- and Post- Conditions: Simple", "SAME;")
pattern_action_pair_list = [
# -- pre-contexted expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
#
# -- post-contexted patterns do not need to appear before the same non-postconditioned
# patterns, since they are always longer.
#
# other characters
('[a-wz]+', "OTHER+"),
# repetition of 'x' (one or more) **preceded** by 'good' + whitespace
('"hello"[ \\t]+/"x"+/[ \\t]+"world"', "HELLO / X+ / WORLD"),
#
('"x"+/[ \\t]+"world"', "X+ / WORLD"),
# repetition of 'x' (one or more) **preceded** by 'good' + whitespace
('"hello"[ \\t]+/"x"+/', "HELLO WSPC. / X+ /"),
# normal repetition (one or more) of 'x'
('"x"+', "X+"),
# whitespace
('[ \\t\\n]+', "WHITESPACE")
]
test_str = "x hello xxxbonjour hello xx world xx world hello xxx x x"
generator_test.do(pattern_action_pair_list, test_str, {}, choice, QuexBufferSize=13)
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input("Pseudo Ambgiguous Post Condition: Part II", "SAME;",
DeleteChoices=["Cpp-PathUniform", "Cpp-PathUniform-CG"])
pattern_list = [
# -- pre-contexted expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
#
# -- post-conditioned patterns do not need to appear before the same non-postconditioned
# patterns, since they are always longer.
#
# normal repetition (one or more) of 'x'
'hey/h',
'(hey)+/hey',
'hey',
# other characters
'[a-z]+',
# whitespace
'[ \\t\\n]+'
]
pattern_action_pair_list = map(lambda x: [x, x.replace("\\", "\\\\")], pattern_list)
test_str = "heyheyhey hey yhey eyhey heyhey heyhe"
generator_test.do(pattern_action_pair_list, test_str, {}, choice, QuexBufferSize=20)
#! /usr/bin/env python
import sys
sys.path.append("../../../../")
import generator_test
choice = generator_test.hwut_input("Buffer Reload: No Backward Reload -- Precondition at Border",
"SAME;",
["Cpp-ASSERTS", "ANSI-C-ASSERTS"])
if choice.find("-ASSERTS") != -1:
choice = choice.replace("-ASSERTS", "")
ASSERT_str = "-DQUEX_OPTION_ASSERTS"
else:
ASSERT_str = ""
pattern_action_pair_list = [
# keyword (needs to come before identifier, because otherwise they would be overruled by it.)
('"0xxxxx"/"a"/', "0xxxxx / a"),
# identifier
('[0a-z]{2}', "IDENTIFIER"),
#
('[ \\t\\n]+', "WHITESPACE")
]
print "## NOTE: The following setup guides the lexer into a buffer reload right after"
print "## the pre-conditions. No buffer reload backwards is to appear!"
test_str = " 0xxxxxa lola"
generator_test.do(pattern_action_pair_list, test_str, {}, choice,
QuexBufferSize=11, QuexBufferFallbackN=2, ShowBufferLoadsF=True,
AssertsActionvation_str=ASSERT_str)
#! /usr/bin/env python
import sys
import os
sys.path.insert(0, os.environ["QUEX_PATH"])
import generator_test
choice = generator_test.hwut_input("Buffer Reload: Backwards",
"SAME;",
["Cpp-ASSERTS", "ANSI-C-ASSERTS"],
["Cpp_StrangeStream"])
if choice.find("-ASSERTS") != -1:
choice = choice.replace("-ASSERTS", "")
ASSERT_str = "-DQUEX_OPTION_ASSERTS"
else:
ASSERT_str = ""
pattern_action_pair_list = [
# keyword (needs to come before identifier, because otherwise they would be overruled by it.)
('"0xxxxxxx"/"a"/', "0xxxxxxx / a"),
# identifier
('[0a-z]{2}', "IDENTIFIER"),
#
('[ \\t\\n]+', "WHITESPACE")
]
# |12456789|
test_str = " 0xxxxxxalola 0xxxxxxxa"
generator_test.do(pattern_action_pair_list, test_str, {}, Language=choice,
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input("CONTINUE: Reentry analysis without return from function",
"SAME;")
pattern_action_pair_list = [
# pre-conditioned expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
('[A-Z]+":"', "LABEL"),
('"PRINT"', "KEYWORD CONTINUE"),
('[A-Z]+', "IDENTIFIER CONTINUE"),
('[ \\t]+', "WHITESPACE CONTINUE"),
]
test_str = "ABERHALLO: GUGU PRINT PRINT: PRINTERLEIN"
generator_test.do(pattern_action_pair_list, test_str, {}, choice)
#! /usr/bin/env python
import sys
sys.path.append("../../../../")
import generator_test
choice = generator_test.hwut_input("Simple: Maximum Length Match", "SAME;")
pattern_dict = { "DIGIT": "[0-9]" }
pattern_action_pair_list = [
# keyword (need to come before identifier, because otherwise they would be overruled by it.)
('"if"', "IF"),
('"else"', "ELSE"),
('"struct"', "STRUCT"),
('"for"', "FOR"),
('"typedef"', "TYPEDEF"),
('"typedefun"', "TYPEDEFUN"),
('"type"', "TYPE"),
('"def"', "DEF"),
('"fun"', "FUN"),
('"while"', "WHILE"),
('"return"', "RETURN"),
# identifier
('[_a-zA-Z][_a-zA-Z0-9]*', "IDENTIFIER"),
#
('"{"', "BRACKET_OPEN"),
('"}"', "BRACKET_CLOSE"),
('"("', "BRACKET_OPEN"),
('")"', "BRACKET_CLOSE"),
('";"', "SEMICOLON"),
('"="', "OP_ASSIGN"),
('"=="', "OP_COMPARISON"),
#! /usr/bin/env python
import generator_test
choice = generator_test.hwut_input("Simple: Tiny Expressions", "SAME;")
pattern_action_pair_list = [
# pre-contexted expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
('[A-Z]+":"', "LABEL"),
('"PRINT"', "KEYWORD"),
('[A-Z]+', "IDENTIFIER"),
('[ \\t]+', "WHITESPACE"),
]
test_str = "ABERHALLO: GUGU PRINT PRINT: PRINTERLEIN"
generator_test.do(pattern_action_pair_list, test_str, {}, choice)
#! /usr/bin/env python
import generator_test
from generator_test import hwut_input
choice = hwut_input("Simple: Begin of Line (BOL), End of Line (EOL)", "SAME;")
pattern_action_pair_list = [
# pre-conditioned expressions need to preceed same (non-preoconditioned) expressions,
# otherwise, the un-conditional expressions gain precedence and the un-conditional
# pattern is never matched.
('^[A-Z]+":"', "BOL-LABEL"),
('[A-Z]+":"', "LABEL"),
('"PRINT"', "KEYWORD"),
('[A-Z]+', "IDENTIFIER"),
('[A-Z]+$', "EOL-IDENTIFIER"),
('[ \\t]+', "WHITESPACE"),
('\\n', "NEWNLINE"),
]
test_str = \
"""HERE: THERE:
THIS THAT
HERE: THERE:
THIS THAT"""
generator_test.do(pattern_action_pair_list, test_str, {}, choice)