openpectus.lang.exec.analyzer

Attributes

logger

Classes

`AnalyzerItemType`	Create a collection of name/value pairs.
`AnalyzerItem`
`AnalyzerVisitorBase`	Override by specific feature analyzers.
`UnreachableCodeCheckAnalyzer`	Checks:
`InfiniteBlockCheckAnalyzer`	Checks:
`IndentationCheckAnalyzer`	Checks:
`ThresholdCheckAnalyzer`	Checks:
`WhitespaceCheckAnalyzer`	Fills in node.has_only_trailing_whitespace for whitespace nodes.
`ConditionCheckAnalyzer`	Checks:
`SimulateCheckAnalyzer`	Checks same as ConditionCheckAnalyzer
`CommandCheckAnalyzer`	Checks:
`MacroCheckAnalyzer`	Checks:
`SemanticCheckAnalyzer`	Facade that combines the check analyzers into a single analyzer.

Module Contents

openpectus.lang.exec.analyzer.logger

class openpectus.lang.exec.analyzer.AnalyzerItemType(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

attribute access:

>>> Color.RED
<Color.RED: 1>

value lookup:

>>> Color(1)
<Color.RED: 1>

name lookup:

>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

HINT = ('HINT',)

INFO = ('INFO',)

WARNING = ('WARNING',)

ERROR = 'ERROR'

class openpectus.lang.exec.analyzer.AnalyzerItem(id, message, node, type, description='', start=None, length=None, end=None, data=None)

Parameters:

id (str)
message (str)
node (openpectus.lang.model.ast.Node | openpectus.lang.model.ast.NodeWithChildren | None)
type (AnalyzerItemType)
description (str)
start (int | None)
length (int | None)
end (int | None)
data (dict[str, str] | None)

id: str

message: str

description: str = ''

type: AnalyzerItemType

node: openpectus.lang.model.ast.Node | None

range: openpectus.lang.model.ast.Range

data

__repr__()

Return type:: str

class openpectus.lang.exec.analyzer.AnalyzerVisitorBase

Bases: openpectus.lang.exec.visitor.NodeVisitor

Override by specific feature analyzers.

items: list[AnalyzerItem] = []

__str__()

Return type:: str

add_item(item)

Parameters:: item (AnalyzerItem)

analyze(n)

Run analysis synchronously.

Note: This runs visit_ProgramNode(n) for ProgramNode, same way as interpreter. For interpretation, this differs from visit(n) but for analysis it should not make a difference.

Parameters:: n (openpectus.lang.model.ast.ProgramNode)

class openpectus.lang.exec.analyzer.UnreachableCodeCheckAnalyzer

Bases: AnalyzerVisitorBase

Checks: * Presence of code in a Block following End block command * Presence of code after “Stop” and “Restart” commands

method_end: openpectus.lang.model.ast.EngineCommandNode | None = None

first_command_after_end: openpectus.lang.model.ast.Node | None = None

last_command_after_end: openpectus.lang.model.ast.Node | None = None

create_item(node)

Parameters:: node (openpectus.lang.model.ast.Node)

visit_BlockNode(node)

Parameters:: node (openpectus.lang.model.ast.BlockNode)

visit_EngineCommandNode(node)

Parameters:: node (openpectus.lang.model.ast.EngineCommandNode)

visit_Node(node)

Return type:: openpectus.lang.exec.visitor.NodeGenerator

analyze(n)

Run analysis synchronously.

Note: This runs visit_ProgramNode(n) for ProgramNode, same way as interpreter. For interpretation, this differs from visit(n) but for analysis it should not make a difference.

class openpectus.lang.exec.analyzer.InfiniteBlockCheckAnalyzer

Bases: AnalyzerVisitorBase

Checks: * Block can potentially finish due to End block or End blocks

create_item(node)

Parameters:: node (openpectus.lang.model.ast.Node)

has_global_end = False

requires_global_end: list[openpectus.lang.model.ast.Node] = []

__str__()

Return type:: str

check_global_end_block(node)

Parameters:: node (openpectus.lang.model.ast.EndBlockNode | openpectus.lang.model.ast.EndBlocksNode | openpectus.lang.model.ast.EngineCommandNode)

check_local_end_block(node)

Parameters:: node (openpectus.lang.model.ast.BlockNode)

visit_ProgramNode(node)

Parameters:: node (openpectus.lang.model.ast.ProgramNode)

visit_BlockNode(node)

Parameters:: node (openpectus.lang.model.ast.BlockNode)

visit_EndBlockNode(node)

Parameters:: node (openpectus.lang.model.ast.EndBlockNode)

visit_EndBlocksNode(node)

Parameters:: node (openpectus.lang.model.ast.EndBlocksNode)

visit_EngineCommandNode(node)

Parameters:: node (openpectus.lang.model.ast.EngineCommandNode)

class openpectus.lang.exec.analyzer.IndentationCheckAnalyzer

Bases: AnalyzerVisitorBase

Checks: * Presence of indentation error flag from parser

create_item(node)

Parameters:: node (openpectus.lang.model.ast.Node)

visit_Node(node)

Parameters:: node (openpectus.lang.model.ast.Node)
Return type:: openpectus.lang.exec.visitor.NodeGenerator

class openpectus.lang.exec.analyzer.ThresholdCheckAnalyzer

Bases: AnalyzerVisitorBase

Checks: * Thresholds are ordered from smallest to largest.

max_threshold_in_parent: dict[openpectus.lang.model.ast.Node, openpectus.lang.model.ast.Node]

visit_Node(node)

Parameters:: node (openpectus.lang.model.ast.Node)
Return type:: openpectus.lang.exec.visitor.NodeGenerator

class openpectus.lang.exec.analyzer.WhitespaceCheckAnalyzer

Bases: AnalyzerVisitorBase

Fills in node.has_only_trailing_whitespace for whitespace nodes. This allows the interpreter to not advance over only white space/comments. This allows the use to edit these lines, e.g. append lines to a method while the methods is running.

whitespace_nodes: list[openpectus.lang.model.ast.BlankNode | openpectus.lang.model.ast.CommentNode] = []

is_whitespace_node(node)

Parameters:: node (openpectus.lang.model.ast.Node)

visit_BlankNode(node)

visit_CommentNode(node)

visit_AlarmNode(node)

visit_BlockNode(node)

visit_ProgramNode(node)

visit_WatchNode(node)

visit_NodeWithChildren(node)

Parameters:: node (openpectus.lang.model.ast.NodeWithChildren)

analyze(n)

Run analysis synchronously.

Note: This runs visit_ProgramNode(n) for ProgramNode, same way as interpreter. For interpretation, this differs from visit(n) but for analysis it should not make a difference.

class openpectus.lang.exec.analyzer.ConditionCheckAnalyzer(tags)

Bases: AnalyzerVisitorBase

Checks: * Condition is present for Watch and Alarm * Condition contains tag name * Spell check of given tag name * Given tag name is defined * Unit is not defined for compared tag without unit * Unit is defined for compared tag with unit * Given unit is defined * Given unit is compatible with given tag

Parameters:: tags (openpectus.lang.exec.tags.TagValueCollection)

tags

__str__()

Return type:: str

visit_WatchNode(node)

Parameters:: node (openpectus.lang.model.ast.WatchNode)

visit_AlarmNode(node)

Parameters:: node (openpectus.lang.model.ast.AlarmNode)

analyze_condition(node)

Parameters:: node (openpectus.lang.model.ast.NodeWithCondition)

class openpectus.lang.exec.analyzer.SimulateCheckAnalyzer(tags)

Bases: AnalyzerVisitorBase

Checks same as ConditionCheckAnalyzer

Parameters:: tags (openpectus.lang.exec.tags.TagValueCollection)

tags

__str__()

Return type:: str

visit_SimulateOffNode(node)

Parameters:: node (openpectus.lang.model.ast.SimulateOffNode)

visit_SimulateNode(node)

Parameters:: node (openpectus.lang.model.ast.SimulateNode)

class openpectus.lang.exec.analyzer.CommandCheckAnalyzer(commands)

Bases: AnalyzerVisitorBase

Checks: * Spell check of command name * Given command name is defined * Arguments pass validation given command argparser * Commands that don’t accept arguments don’t get arguments

Parameters:: commands (openpectus.lang.exec.commands.CommandCollection)

commands

__str__()

Return type:: str

visit_InterpreterCommandNode(node)

Parameters:: node (openpectus.lang.model.ast.InterpreterCommandNode)

visit_EngineCommandNode(node)

Parameters:: node (openpectus.lang.model.ast.EngineCommandNode)

visit_UodCommandNode(node)

Parameters:: node (openpectus.lang.model.ast.UodCommandNode)

visit_ErrorInstructionNode(node)

check_command_node(node)

Parameters:: node (openpectus.lang.model.ast.Node)

class openpectus.lang.exec.analyzer.MacroCheckAnalyzer

Bases: AnalyzerVisitorBase

Checks: * “Macro” has an argument * “Call macro” has and argument * “Call macro” argument is a defined “Macro” * “Macro” is not left unused * Spell check of “Call macro” argument * “Macro” is redefined * Macro contains call to itself

macros: dict[str, openpectus.lang.model.ast.MacroNode]

macro_calls: list[openpectus.lang.model.ast.CallMacroNode] = []

macros_registered: list[openpectus.lang.model.ast.MacroNode] = []

macros_called: list[openpectus.lang.model.ast.MacroNode] = []

visit_CallMacroNode(node)

Parameters:: node (openpectus.lang.model.ast.CallMacroNode)

visit_MacroNode(node)

Parameters:: node (openpectus.lang.model.ast.MacroNode)

analyze(n)

Run analysis synchronously.

Note: This runs visit_ProgramNode(n) for ProgramNode, same way as interpreter. For interpretation, this differs from visit(n) but for analysis it should not make a difference.

class openpectus.lang.exec.analyzer.SemanticCheckAnalyzer(tags, commands)

Facade that combines the check analyzers into a single analyzer.

Parameters:

tags (openpectus.lang.exec.tags.TagValueCollection)
commands (openpectus.lang.exec.commands.CommandCollection)

items: list[AnalyzerItem] = []

analyzers: list[AnalyzerVisitorBase]

__str__()

Return type:: str

analyze(program)

Parameters:: program (openpectus.lang.model.ast.ProgramNode)

property errors: list[AnalyzerItem]

Return type:: list[AnalyzerItem]

property warnings: list[AnalyzerItem]

Return type:: list[AnalyzerItem]