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

Example 36 with Node

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

the class ReferencedMachines method determinePackage.

private String[] determinePackage(final TPragmaIdOrString packageTerminal, final Node node) {
    String text = packageTerminal.getText();
    // "foo.bar" or foo.bar
    if ((text.startsWith("\"") && text.endsWith("\""))) {
        text = text.replaceAll("\"", "");
    }
    final String[] packageNameArray = text.split("\\.");
    final Pattern VALID_IDENTIFIER = Pattern.compile("([\\p{L}][\\p{L}\\p{N}_]*)");
    for (int i = 0; i < packageNameArray.length; i++) {
        boolean matches = VALID_IDENTIFIER.matcher(packageNameArray[i]).matches();
        if (!matches) {
            throw new VisitorException(new CheckException("Invalid package pragma: " + text, node));
        }
    }
    return packageNameArray;
}

Example 37 with Node

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

the class ReferencedMachines method caseAImportPackage.

@Override
public void caseAImportPackage(AImportPackage node) {
    final String[] packageArray = determinePackage(node.getPackage(), node);
    final File pathFile = getFileStartingAtRootDirectory(packageArray);
    final String path = pathFile.getAbsolutePath();
    if (pathFile.exists()) {
        if (!pathFile.isDirectory()) {
            throw new VisitorException(new CheckException(String.format("Imported package is not a directory: %s", path), node));
        }
    } else {
        throw new VisitorException(new CheckException(String.format("Imported package does not exist: %s", path), node));
    }
    if (this.pathList.contains(path)) {
        throw new VisitorException(new CheckException(String.format("Duplicate import statement: %s", node.getPackage().getText()), node));
    }
    this.pathList.add(path);
}

Example 38 with Node

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

the class ReferencedMachines method caseAImplementationMachineParseUnit.

// IMPLEMENTS
@Override
public void caseAImplementationMachineParseUnit(AImplementationMachineParseUnit node) {
    node.getHeader().apply(this);
    String name = node.getRefMachine().getText();
    referncesTable.put(name, new MachineReference(name, node.getRefMachine()));
    for (Node mclause : node.getMachineClauses()) {
        mclause.apply(this);
    }
}

Example 39 with Node

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

the class OpSubstitutions method caseAFuncOpSubstitution.

@Override
public void caseAFuncOpSubstitution(final AFuncOpSubstitution node) {
    final PExpression expression = node.getFunction();
    PExpression idExpr = null;
    LinkedList<PExpression> parameters = null;
    Type type = null;
    TIdentifierLiteral idToken = null;
    String idString = null;
    if (expression instanceof AFunctionExpression) {
        // the operation was parsed as a function expression
        final AFunctionExpression function = (AFunctionExpression) expression;
        final PExpression funcId = function.getIdentifier();
        if (funcId instanceof AIdentifierExpression) {
            final AIdentifierExpression identifier = (AIdentifierExpression) funcId;
            idString = Utils.getTIdentifierListAsString(identifier.getIdentifier());
            idToken = identifier.getIdentifier().get(0);
            type = definitions.getType(idString);
        } else {
            type = Type.NoDefinition;
        }
        idExpr = function.getIdentifier();
        parameters = new LinkedList<>(function.getParameters());
    } else if (expression instanceof AIdentifierExpression) {
        // the operation was parsed as an identifier expression
        final AIdentifierExpression identifier = (AIdentifierExpression) expression;
        idString = Utils.getTIdentifierListAsString(identifier.getIdentifier());
        idToken = identifier.getIdentifier().get(0);
        type = definitions.getType(idString);
        idExpr = expression;
        parameters = new LinkedList<>();
    } else {
        // some other expression was parsed (NOT allowed)
        throw new BParseException(null, "Expecting operation");
    }
    if (type != Type.NoDefinition && idToken != null) {
        if (type == Type.Substitution || type == Type.ExprOrSubst) {
            // create DefinitionSubstitution
            final ADefinitionSubstitution defSubst = new ADefinitionSubstitution(new TDefLiteralSubstitution(idToken.getText(), idToken.getLine(), idToken.getPos()), parameters);
            if (type == Type.ExprOrSubst) {
                // type is determined now => set to Substitution
                setTypeSubstDef(node, idString);
            }
            // transfer position information
            final PositionedNode posNode = node;
            final PositionedNode newPosNode = defSubst;
            newPosNode.setStartPos(posNode.getStartPos());
            newPosNode.setEndPos(posNode.getEndPos());
            node.replaceBy(defSubst);
            defSubst.apply(this);
        } else {
            // finding some other type here is an error!
            throw new VisitorException(new CheckException("Expecting substitution here but found definition with type '" + type + "'", node));
        }
    } else {
        // no def, no problem ;-)
        final AOpSubstitution opSubst = new AOpSubstitution(idExpr, parameters);
        opSubst.setStartPos(idExpr.getStartPos());
        opSubst.setEndPos(idExpr.getEndPos());
        node.replaceBy(opSubst);
        opSubst.apply(this);
    }
}

Example 40 with Node

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

the class RulesMachineChecker method outADefineSubstitution.

@Override
public void outADefineSubstitution(ADefineSubstitution node) {
    // section
    if (currentOperation != null && currentOperation instanceof ComputationOperation) {
        ComputationOperation computationOperation = (ComputationOperation) currentOperation;
        try {
            computationOperation.addDefineVariable(node.getName());
            this.knownIdentifier.addKnownIdentifier(node.getName());
        } catch (CheckException e) {
            this.errorList.add(e);
        }
    }
}