Examples with Node de.be4.classicalb.core.parser.node.Node used on opensource projects

Example 96 with Node

use of de.be4.classicalb.core.parser.node.Node in project probparsers by bendisposto.

the class MachineContext method visitBDefinition.

public void visitBDefinition(Node node, String name, List<PExpression> copy, Node rightSide) {
    if (!this.definitions.containsValue(node)) {
        return;
    }
    contextTable.add(new LinkedHashMap<String, Node>());
    for (PExpression e : copy) {
        putLocalVariableIntoCurrentScope((AIdentifierExpression) e);
    }
    rightSide.apply(this);
    contextTable.remove(contextTable.size() - 1);
}

Example 97 with Node

use of de.be4.classicalb.core.parser.node.Node in project probparsers by bendisposto.

the class MachineContext method caseAAnySubstitution.

@Override
public void caseAAnySubstitution(AAnySubstitution node) {
    contextTable.add(new LinkedHashMap<String, Node>());
    List<PExpression> copy = new ArrayList<PExpression>(node.getIdentifiers());
    for (PExpression e : copy) {
        putLocalVariableIntoCurrentScope((AIdentifierExpression) e);
    }
    node.getWhere().apply(this);
    node.getThen().apply(this);
}

Example 98 with Node

use of de.be4.classicalb.core.parser.node.Node in project probparsers by bendisposto.

the class MachineContext method caseAOpSubstitution.

@Override
public void caseAOpSubstitution(AOpSubstitution node) {
    if (node.getName() != null) {
        AIdentifierExpression op = (AIdentifierExpression) node.getName();
        String name = Utils.getTIdentifierListAsString(op.getIdentifier());
        Node o = operations.get(name);
        if (o != null) {
            this.referencesTable.put(op, o);
        } else {
            throw new ScopeException("Unknown operation '" + name + "'");
        }
    }
    {
        List<PExpression> copy = new ArrayList<PExpression>(node.getParameters());
        for (PExpression e : copy) {
            e.apply(this);
        }
    }
}

Example 99 with Node

use of de.be4.classicalb.core.parser.node.Node in project probparsers by bendisposto.

the class MachineContext method caseAVariablesMachineClause.

@Override
public void caseAVariablesMachineClause(AVariablesMachineClause node) {
    List<PExpression> copy = new ArrayList<PExpression>(node.getIdentifiers());
    for (PExpression e : copy) {
        AIdentifierExpression v = (AIdentifierExpression) e;
        String name = Utils.getTIdentifierListAsString(v.getIdentifier());
        exist(v.getIdentifier());
        variables.put(name, v);
    }
}

Example 100 with Node

use of de.be4.classicalb.core.parser.node.Node in project probparsers by bendisposto.

the class EventBParser method parse.

/**
 * Parses the input string.
 *
 * @param input
 *            the {@link String} to be parsed
 * @param debugOutput
 *            output debug messages on standard out?
 * @return the root node of the AST
 * @throws BException
 *             The {@link BException} class stores the actual exception as
 *             delegate and forwards all method calls to it. So it is save
 *             for tools to just use this exception if they want to extract
 *             an error message. If the tools needs to extract additional
 *             information, such as a sourcecode position or involved tokens
 *             respectively nodes, it needs to retrieve the delegate
 *             exception. The {@link BException} class offers a
 *             {@link BException#getCause()} method for this, which returns
 *             the delegate exception.
 *             <p>
 *             Internal exceptions:
 *             <ul>
 *             <li>{@link EventBLexerException}: If any error occurs in the
 *             generated or customized lexer a {@link LexerException} is
 *             thrown. Usually the lexer classes just throw a
 *             {@link LexerException}. But this class unfortunately does not
 *             contain any explicit information about the sourcecode
 *             position where the error occured. Using aspect-oriented
 *             programming we intercept the throwing of these exceptions to
 *             replace them by our own exception. In our own exception we
 *             provide the sourcecode position of the last characters that
 *             were read from the input.</li>
 *             <li>{@link EventBParseException}: This exception is thrown in
 *             two situations. On the one hand if the parser throws a
 *             {@link ParserException} we convert it into a
 *             {@link EventBParseException}. On the other hand it can be
 *             thrown if any error is found during the AST transformations
 *             after the parser has finished. We try to provide a token if a
 *             single token is involved in the error. Otherwise a
 *             {@link SourcecodeRange} is provided, which can be used to
 *             retrieve detailed position information from the
 *             {@link SourcePositions} (s. {@link #getSourcePositions()}).
 *             </li>
 *             <li>{@link CheckException}: If any problem occurs while
 *             performing semantic checks, a {@link CheckException} is
 *             thrown. We provide one or more nodes that are involved in the
 *             problem. For example, if we find dublicate machine clauses,
 *             we will list all occurances in the exception.</li>
 *             </ul>
 */
public Start parse(final String input, final boolean debugOutput) throws BException {
    final Reader reader = new StringReader(input);
    try {
        /*
			 * Main parser
			 */
        final EventBLexer lexer = new EventBLexer(new PushbackReader(reader, 99));
        lexer.setDebugOutput(debugOutput);
        Parser parser = new Parser(lexer);
        final Start rootNode = parser.parse();
        final List<IToken> tokenList = ((ITokenListContainer) lexer).getTokenList();
        /*
			 * Retrieving sourcecode positions which were found by ParserAspect
			 */
        final Map<PositionedNode, SourcecodeRange> positions = ((IParser) parser).getMapping();
        sourcePositions = new SourcePositions(tokenList, positions);
        parser = null;
        return rootNode;
    } catch (final LexerException e) {
        /*
			 * Actually it's supposed to be a EventBLexerException because the
			 * aspect 'LexerAspect' replaces any LexerException to provide
			 * sourcecode position information in the BLexerException.
			 */
        throw new BException(e);
    } catch (final ParserException e) {
        throw new BException(createEventBParseException(e));
    } catch (final EventBParseException e) {
        throw new BException(e);
    } catch (final IOException e) {
        // shouldn't happen and if, we cannot handle it
        throw new BException(e);
    }
}