Updated component and bus generation logic + bugfixes

Extracted schema and library management to Application
2022-05-31 01:05:08 +02:00 · 2022-05-30 23:11:06 +02:00
21 changed files with 528 additions and 236 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -37,5 +37,5 @@ add_executable(SchemeEditor
  comdel/parser/comdellexer.cpp
  main.cpp
  mainwindow.ui
-        comdel/domain/comdel_validator.cpp comdel/domain/comdel_validator.h comdel/display/attribute_dialog.cpp comdel/display/attribute_dialog.h comdel/display/name_dialog.cpp comdel/display/name_dialog.h comdel/domain/comdel_generator.cpp comdel/domain/comdel_generator.h comdel/display/library_list.cpp comdel/display/library_list.h)
+        comdel/domain/comdel_validator.cpp comdel/domain/comdel_validator.h comdel/display/attribute_dialog.cpp comdel/display/attribute_dialog.h comdel/display/name_dialog.cpp comdel/display/name_dialog.h comdel/domain/comdel_generator.cpp comdel/domain/comdel_generator.h comdel/display/library_list.cpp comdel/display/library_list.h application.cpp application.h)
 target_link_libraries(SchemeEditor Qt5::Core Qt5::Gui Qt5::Widgets)
--- a/application.cpp
+++ b/application.cpp
@ -0,0 +1,199 @@
+//
+// Created by bbr on 27.05.22..
+//
+
+#include "application.h"
+#include "comdel/parser/parse_context.h"
+#include "comdel/parser/parser_util.h"
+#include "comdel/domain/schema_creator.h"
+#include "comdel/domain/comdel_generator.h"
+#include "comdel/domain/comdel_validator.h"
+
+std::optional<domain::Library> Application::getLibrary() {
+    return library;
+}
+
+domain::Schema *Application::getSchema() {
+    return schema;
+}
+
+void Application::clear() {
+    if(schema != nullptr) {
+        delete schema;
+        schema = nullptr;
+    }
+    library = std::nullopt;
+    libraryPath = "";
+}
+
+bool Application::loadLibrary(std::string& filename, std::ostream &errorOutput) {
+    clear();
+
+    ParseContext parseContext;
+    auto libraryNode = load_library_from_file(&parseContext, filename.c_str(), errorOutput);
+    if(libraryNode) {
+        domain::SchemaCreator generator(validators);
+        library = generator.loadLibrary(*libraryNode);
+
+        for (auto& error : generator.getErrors()) {
+            parseContext.formatError(error, errorOutput, "ERROR: ");
+        }
+
+        if(library.has_value()) {
+            errorOutput<<"Failed creating library model"<<std::endl;
+            return false;
+        } else {
+            libraryPath = filename;
+            // on library load we create a new schema
+            schema = new domain::Schema();
+        }
+
+    } else {
+        errorOutput<<"Failed parsing library"<<std::endl;
+        return false;
+    }
+    return true;
+}
+
+bool Application::loadSchema(std::string &filename, std::ostream &errorOutput) {
+    clear();
+
+    ParseContext parseContext;
+    auto schemaNode = load_schema_from_file(&parseContext, filename.c_str(), errorOutput);
+
+    if(schemaNode) {
+        domain::SchemaCreator generator(validators);
+        library = generator.loadLibrary(*schemaNode->library);
+
+        libraryPath = schemaNode->source->asString();
+
+        for (auto& error : generator.getErrors()) {
+            parseContext.formatError(error, errorOutput, "ERROR: ");
+        }
+
+        if(library) {
+            schema = generator.loadSchema(*schemaNode, *library);
+
+            for (auto& error : generator.getErrors()) {
+                parseContext.formatError(error, errorOutput, "ERROR: ");
+            }
+
+            if(schema == nullptr) {
+                clear();
+                return false;
+            }
+        } else {
+            clear();
+            return false;
+        }
+
+    } else {
+        errorOutput<<"Failed parsing library"<<std::endl;
+        return false;
+    }
+    return true;
+}
+
+bool Application::generateSchema(std::ostringstream &output) {
+    if(schema == nullptr) {
+        return false;
+    }
+    domain::generate_schema(libraryPath, schema, output);
+    return true;
+}
+
+std::vector<domain::ValidationError> Application::validateSchema() {
+    if(schema == nullptr) {
+        return std::vector<domain::ValidationError>{domain::ValidationError(domain::Action::ERROR, "No schema loaded")};
+    }
+
+    domain::ComdelValidator validator{validators};
+
+    domain::ValidationContext context;
+    context.instance = nullptr;
+    context.attribute = nullptr;
+    context.addressSpaces = {};
+
+    for(auto &lib: library->getAddressSpaces()) {
+        context.addressSpaces.insert(std::make_pair(lib.getName(), lib));
+    }
+    auto errors = validator.validateSchema(*schema, context);
+
+    auto countValidation = validator.validateInstanceCount(*schema, *library, context);
+    errors.insert(errors.end(), countValidation.begin(), countValidation.end());
+
+    auto nameValidation = validator.validateInstanceNames(*schema, *library, context);
+    errors.insert(errors.end(), nameValidation.begin(), nameValidation.end());
+
+    auto pinValidation = validator.validatePinConnections(*schema, *library, context);
+    errors.insert(errors.end(), pinValidation.begin(), pinValidation.end());
+    return errors;
+}
+
+std::vector<domain::ValidationError> Application::generateComdel(std::ostringstream &output) {
+
+    auto errors = validateSchema();
+    if(Application::hasErrors(errors)) {
+        // as long as all validation errors are warning we continue with build
+        domain::generate_comdel(schema, library.value(), output);
+    }
+    return errors;
+}
+
+bool Application::hasErrors(std::vector<domain::ValidationError> errors) {
+    for(auto& err: errors) {
+        if(err.type == domain::Action::ERROR) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// static instance of application
+static Application *application = nullptr;
+
+Application *Application::instance() {
+    if(application == nullptr) {
+        application = new Application();
+    }
+    return application;
+}
+
+std::shared_ptr<domain::ComponentInstance> Application::addComponent(domain::Component component, std::vector<domain::InstanceAttribute> attributes, int x, int y) {
+    std::set<std::string> names;
+    for(const auto& c: schema->componentInstances) {
+        names.insert(c->name);
+    }
+    std::string name = generateName(names, component.getInstanceName());
+
+    schema->componentInstances.push_back(std::make_shared<domain::ComponentInstance>(name, attributes, std::make_pair(x, y), component));
+    return schema->componentInstances.back();
+}
+
+std::shared_ptr<domain::BusInstance> Application::addBus(domain::Bus bus, int x, int y) {
+    std::set<std::string> names;
+    for(const auto& b: schema->busInstances) {
+        names.insert(b->name);
+    }
+    std::string name = generateName(names, bus.getInstanceName());
+
+    schema->busInstances.push_back(std::make_shared<domain::BusInstance>(name, std::make_pair(x, y), bus));
+    return schema->busInstances.back();
+}
+
+
+std::string Application::generateName(std::set<std::string>& names, std::string instanceName) {
+    if(names.find(instanceName) == names.end()) {
+        return instanceName;
+    }
+    char buffer[4];
+    for(int i=0; i<1000; i++) {
+        sprintf(buffer, "%03d", i);
+        auto name = instanceName + "_" + buffer;
+        if(names.find(name) == names.end()) {
+            return name;
+        }
+    }
+    // return default value as this should never happen
+    return instanceName;
+}
--- a/application.h
+++ b/application.h
@ -0,0 +1,48 @@
+//
+// Created by bbr on 27.05.22..
+//
+
+#ifndef SCHEMEEDITOR_APPLICATION_H
+#define SCHEMEEDITOR_APPLICATION_H
+
+
+#include <set>
+#include "comdel/domain/library.h"
+#include "comdel/domain/schema.h"
+#include "comdel/domain/comdel_validator.h"
+
+
+class Application {
+private:
+    std::string libraryPath;
+    std::optional<domain::Library> library = std::nullopt;
+    domain::Schema* schema = nullptr;
+    std::vector<domain::FunctionValidator*> validators = domain::getSupportedValidators();
+
+    std::string generateName(std::set<std::string>& names, std::string instanceName);
+
+public:
+    std::optional<domain::Library> getLibrary();
+    domain::Schema* getSchema();
+
+    void clear();
+
+    bool loadLibrary(std::string& filename, std::ostream& errorOutput);
+    bool loadSchema(std::string& filename, std::ostream& errorOutput);
+
+    static Application* instance();
+
+    bool generateSchema(std::ostringstream &output);
+    std::vector<domain::ValidationError> validateSchema();
+    std::vector<domain::ValidationError> generateComdel(std::ostringstream &output);
+
+    std::shared_ptr<domain::ComponentInstance> addComponent(domain::Component component, std::vector<domain::InstanceAttribute> attributes, int x, int y);
+    std::shared_ptr<domain::BusInstance> addBus(domain::Bus bus, int x, int y);
+
+    static bool hasErrors(std::vector<domain::ValidationError> empty);
+
+    ~Application() = default;
+};
+
+
+#endif //SCHEMEEDITOR_APPLICATION_H
--- a/comdel/display/attribute_dialog.cpp
+++ b/comdel/display/attribute_dialog.cpp
@ -5,6 +5,8 @@
 #include "attribute_dialog.h"
 #include "mainwindow.h"

+#include "application.h"
+
 namespace display {

    void AttributeDialog::onUpdate() {
@ -15,7 +17,7 @@ namespace display {

        domain::ValidationContext context;

-        for (auto &addressSpace: MainWindow::getLibrary()->getAddressSpaces()) {
+        for (auto &addressSpace: Application::instance()->getLibrary()->getAddressSpaces()) {
            context.addressSpaces.insert(std::make_pair(addressSpace.getName(), addressSpace));
        }

--- a/comdel/display/component_display.cpp
+++ b/comdel/display/component_display.cpp
@ -2,17 +2,24 @@
 #include "attribute_dialog.h"
 #include "name_dialog.h"
 #include "mainwindow.h"
+#include "application.h"

 #include <QMenu>
 #include <QLine>
 #include <QGraphicsSceneContextMenuEvent>
+#include <set>

 namespace display {

    void Component::contextMenuEvent(QGraphicsSceneContextMenuEvent *event) {
        QMenu menu;
        menu.addAction("Izmjeni ime", [this]() {
-            auto dialog = new NameDialog(this->instance.get());
+            std::set<std::string> names;
+            for(const auto &component: Application::instance()->getSchema()->componentInstances) {
+                names.insert(component->name);
+            }
+
+            auto dialog = new NameDialog(this->instance.get(), names);
            dialog->exec();
        });
        menu.addSeparator();
@ -24,7 +31,7 @@ namespace display {
                                         [attr]() {
                                             if (attr->value.getType() == domain::Value::MEMORY_REFERENCE) {
                                                 auto dialog = new MemoryDialog(attr,
-                                                                                MainWindow::getSchema()->componentInstances);
+                                                                                Application::instance()->getSchema()->componentInstances);
                                                 dialog->exec();
                                             } else {
                                                 auto dialog = new AttributeDialog(attr);
@ -92,7 +99,12 @@ namespace display {
    void Bus::contextMenuEvent(QGraphicsSceneContextMenuEvent *event) {
        QMenu menu;
        menu.addAction("Izmjeni ime", [this]() {
-            auto dialog = new NameDialog(this->busInstance.get());
+            std::set<std::string> names;
+            for(const auto &component: Application::instance()->getSchema()->busInstances) {
+                names.insert(component->name);
+            }
+
+            auto dialog = new NameDialog(this->busInstance.get(), names);
            dialog->exec();
        });
        menu.exec(event->screenPos());
@ -109,7 +121,7 @@ namespace display {
    QVariant BusGroup::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value) {
        if (change == ItemPositionChange && scene()) {
            // value is the new position.
-            QPointF newPos = value.toPointF();
+            QPoint newPos = value.toPointF().toPoint();
            busInstance->position.first = newPos.x();
            busInstance->position.second = newPos.y();

@ -135,7 +147,7 @@ namespace display {
    QVariant ComponentGroup::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value) {
        if (change == ItemPositionChange && scene()) {
            // value is the new position.
-            QPointF newPos = value.toPointF();
+            QPoint newPos = value.toPointF().toPoint();
            componentInstance->position.first = newPos.x();
            componentInstance->position.second = newPos.y();

--- a/comdel/display/name_dialog.cpp
+++ b/comdel/display/name_dialog.cpp
@ -2,37 +2,54 @@
 // Created by bbr on 18. 04. 2022..
 //

+#include <set>
 #include "name_dialog.h"

-display::NameDialog::NameDialog(domain::ComponentInstance *instance) : componentInstance(instance) {
+display::NameDialog::NameDialog(domain::ComponentInstance *instance, std::set<std::string>& names) : componentInstance(instance), usedNames(names) {
+    usedNames.erase(instance->name);
+
    auto *layout = new QVBoxLayout(this);
    layout->addWidget(new QLabel("Izmjeni ime", this));

    edit = new QLineEdit(this);
    edit->insert(instance->name.c_str());
+    connect(edit, &QLineEdit::textChanged, this, &NameDialog::onNameUpdate);
    layout->addWidget(edit);
    this->setWindowTitle("Izmjeni ime");
-    auto *button = new QPushButton("Ažuriraj", this);
+    button = new QPushButton("Ažuriraj", this);
    connect(button, &QPushButton::clicked, this, &NameDialog::onNameChange);
    layout->addWidget(button);
    this->setLayout(layout);
 }

-display::NameDialog::NameDialog(domain::BusInstance *instance): busInstance(instance) {
+display::NameDialog::NameDialog(domain::BusInstance *instance, std::set<std::string>& names): busInstance(instance), usedNames(names) {
+    usedNames.erase(instance->name);
+
    auto *layout = new QVBoxLayout(this);
    layout->addWidget(new QLabel("Izmjeni ime", this));

    edit = new QLineEdit(this);
    edit->insert(instance->name.c_str());
+    connect(edit, &QLineEdit::textChanged, this, &NameDialog::onNameUpdate);
    layout->addWidget(edit);
    this->setWindowTitle("Izmjeni ime");
-    auto *button = new QPushButton("Ažuriraj", this);
+    button = new QPushButton("Ažuriraj", this);
    connect(button, &QPushButton::clicked, this, &NameDialog::onNameChange);
    layout->addWidget(button);
    this->setLayout(layout);
 }

+void display::NameDialog::onNameUpdate(const QString &text) {
+    if(usedNames.find(text.toStdString()) == usedNames.end()) {
+        button->setDisabled(false);
+    } else {
+        button->setDisabled(true);
+    }
+}
+
 void display::NameDialog::onNameChange() {
+
+
    if (componentInstance != nullptr) {
        componentInstance->name = this->edit->text().toStdString();
    } else if (busInstance != nullptr) {
--- a/comdel/display/name_dialog.h
+++ b/comdel/display/name_dialog.h
@ -7,24 +7,28 @@
 #include <QLineEdit>
 #include <QPushButton>

+#include <set>
+
 #include <comdel/domain/instance.h>

 namespace display {

    class NameDialog : public QDialog {

+        std::set<std::string> usedNames;
        QLineEdit *edit = nullptr;
        domain::ComponentInstance *componentInstance = nullptr;
        domain::BusInstance *busInstance = nullptr;
+        QPushButton *button;

    public:

-        NameDialog(domain::ComponentInstance *instance);
+        NameDialog(domain::ComponentInstance *instance, std::set<std::string>& names);

-        NameDialog(domain::BusInstance *instance);
+        NameDialog(domain::BusInstance *instance, std::set<std::string>& names);

    public slots:
-
+        void onNameUpdate(const QString& text);
        void onNameChange();
    };

--- a/comdel/display/schema_display.cpp
+++ b/comdel/display/schema_display.cpp
@ -1,5 +1,7 @@
 #include "component_display.h"
 #include "schema_display.h"
+#include "application.h"
+#include "attribute_dialog.h"

 #include <QDrag>
 #include <QDragEnterEvent>
@ -10,13 +12,14 @@ namespace display {
    Schema::Schema() {
        this->selectedBrush.setColor(QColor::fromRgb(20, 20, 125));
        this->selectedPen.setColor(QColor::fromRgb(20, 20, 125));
-
+        schema = nullptr;
+        library = std::nullopt;
        this->setScene(&scene);
        this->setAcceptDrops(true);
    }


-    void Schema::setSchema(domain::Schema *_schema, domain::Library *_library) {
+    void Schema::setSchema(domain::Schema *_schema, std::optional<domain::Library> _library) {
        components.clear();
        buses.clear();

@ -85,15 +88,30 @@ namespace display {

            auto attributes = std::vector<domain::InstanceAttribute>();
            for (auto attr: component.getAttributes()) {
-                attributes.emplace_back(attr.getName(), attr.getDefault(), attr);
+                domain::InstanceAttribute attribute(attr.getName(), attr.getDefault(), attr);
+                if(attr.getPopup().has_value() && attr.getPopup()->getType() == domain::Popup::AUTOMATIC) {
+                    if(attr.getDefault().isType(domain::Value::MEMORY_REFERENCE)) {
+                        auto dialog = new MemoryDialog(&attribute, schema->componentInstances);
+                        if(dialog->exec() == QDialog::Rejected) {
+                            // if any dialog isn't set, whole creation is rejected
+                            event->ignore();
+                            return;
+                        }
+                    } else {
+                        auto dialog = new AttributeDialog(&attribute);
+                        if(dialog->exec() == QDialog::Rejected) {
+                            // if any dialog isn't set, whole creation is rejected
+                            event->ignore();
+                            return;
+                        }
+                    }
+                }
+                attributes.push_back(attribute);
            }

-            auto currentPos = this->mapToScene(event->pos());
+            auto currentPos = this->mapToScene(event->pos()).toPoint();

-            auto instance = std::make_shared<domain::ComponentInstance>(component.getInstanceName(), attributes,
-                                                                        std::make_pair(currentPos.x(), currentPos.y()),
-                                                                        component);
-            schema->componentInstances.push_back(instance);
+            auto instance = Application::instance()->addComponent(component, attributes, currentPos.x(), currentPos.y());

            auto group = new display::ComponentGroup(instance);
            scene.addItem(group);
@ -110,11 +128,9 @@ namespace display {
        if (event->mimeData()->hasFormat("comdel/bus")) {
            auto bus = library->getBus(event->mimeData()->data("comdel/bus").toStdString());

-            auto currentPos = this->mapToScene(event->pos());
+            auto currentPos = this->mapToScene(event->pos()).toPoint();

-            auto instance = std::make_shared<domain::BusInstance>(bus.getName(),
-                                                                  std::make_pair(currentPos.x(), currentPos.y()), bus);
-            schema->busInstances.push_back(instance);
+            auto instance = Application::instance()->addBus(bus, currentPos.x(), currentPos.y());

            auto group = new display::BusGroup(instance);
            scene.addItem(group);
@ -216,6 +232,9 @@ namespace display {

        for (auto bus: busInstances) {
            auto &group = buses[bus->name];
+            if(group == nullptr) {
+                continue;
+            }
            auto rect = new QGraphicsRectItem(group->boundingRect());
            rect->setPen(selectedPen);
            rect->setPos(group->scenePos());
--- a/comdel/display/schema_display.h
+++ b/comdel/display/schema_display.h
@ -46,7 +46,7 @@ namespace display {
        std::vector<BusConnection *> busConnections;
        std::vector<DirectConnection *> directConnections;

-        void setSchema(domain::Schema *schema, domain::Library *library);
+        void setSchema(domain::Schema *schema, std::optional<domain::Library> library);

        void updateConnections();

@ -65,8 +65,8 @@ namespace display {
    private:
        QGraphicsScene scene;

-        domain::Schema *schema;
-        domain::Library *library;
+        domain::Schema *schema{};
+        std::optional<domain::Library> library;

        std::vector<domain::BusInstance *>
        getAvailableConnectionBusses(domain::ComponentInstance *instance, domain::Pin &pin);
--- a/comdel/domain/bus.cpp
+++ b/comdel/domain/bus.cpp
@ -10,6 +10,11 @@ namespace domain {
        return name;
    }

+    std::string Bus::getInstanceName() {
+        return instanceName;
+    }
+
+
    int Wire::getWidth() {
        return width;
    }
@ -30,9 +35,9 @@ namespace domain {
        return type;
    }

-    Bus::Bus(std::string name, std::string tooltip, BusType type, std::pair<int, int> count, std::vector<Wire> wires,
+    Bus::Bus(std::string name, std::string instanceName, std::string tooltip, BusType type, std::pair<int, int> count, std::vector<Wire> wires,
             std::optional<ui::Bus> displayBus)
-            : name(name), tooltip(tooltip), type(type), count(count), wires(wires), displayBus(displayBus) {}
+            : name(name), instanceName(instanceName), tooltip(tooltip), type(type), count(count), wires(wires), displayBus(displayBus) {}

    std::string Bus::getName() {
        return name;
@ -57,5 +62,4 @@ namespace domain {
    std::optional<ui::Bus> Bus::getDisplayBus() {
        return displayBus;
    }
-
 } // namespace domain
--- a/comdel/domain/bus.h
+++ b/comdel/domain/bus.h
@ -54,6 +54,7 @@ namespace domain {
        };
    private:
        std::string name;
+        std::string instanceName;
        std::string tooltip;
        BusType type;

@ -62,11 +63,13 @@ namespace domain {
        std::vector<Wire> wires;

    public:
-        Bus(std::string name, std::string tooltip, BusType type, std::pair<int, int> count, std::vector<Wire> wires,
+        Bus(std::string name, std::string instanceName, std::string tooltip, BusType type, std::pair<int, int> count, std::vector<Wire> wires,
            std::optional<ui::Bus> display = std::nullopt);

        std::string getName();

+        std::string getInstanceName();
+
        std::string getTooltip();

        BusType getType();
--- a/comdel/domain/comdel_validator.cpp
+++ b/comdel/domain/comdel_validator.cpp
@ -1,3 +1,4 @@
+#include <set>
 #include "comdel_validator.h"
 #include "library.h"

@ -38,11 +39,11 @@ namespace domain {
                auto message = populateMessage(
                        "Not enough instances of component '{componentName}' required at least {min}, found {count}",
                        context);
-                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
+                errors.emplace_back(Action::ERROR, message);
            } else if (count > comp.getCount().second) {
                auto message = populateMessage(
                        "To many instances of component '{componentName}' allow at most {max}, found {count}", context);
-                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
+                errors.emplace_back(Action::ERROR, message);
            }
        }

@ -64,11 +65,11 @@ namespace domain {
            if (count < bus.getCount().first) {
                auto message = populateMessage(
                        "Not enough instances of bus '{busName}' required at least {min}, found {count}", context);
-                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
+                errors.emplace_back(Action::ERROR, message);
            } else if (count > bus.getCount().second) {
                auto message = populateMessage(
                        "To many instances of bus '{busName}' allow at most {max}, found {count}", context);
-                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
+                errors.emplace_back(Action::ERROR, message);
            }
        }

@ -86,7 +87,7 @@ namespace domain {
                        context.instance = inst.get();
                        context.attributes["instanceName"] = Value::fromString(inst->name);
                        auto message = populateMessage(pin.getConnection().getMessage(), context);
-                        errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
+                        errors.emplace_back(Action::ERROR, message);
                    }
                }
            }
@ -152,6 +153,24 @@ namespace domain {
        return nullopt;
    }

+    std::vector<ValidationError>
+    ComdelValidator::validateInstanceNames(Schema &schema, Library &library, ValidationContext context) {
+        std::set<std::string> names;
+        std::vector<ValidationError> errors;
+
+        for(auto& component: schema.componentInstances) {
+            if(names.find(component->name) != names.end()) {
+                context.attributes["componentName"] = Value::fromString(component->name);
+                auto message = populateMessage(
+                        "There are multiple component instances named '{componentName}'", context);
+                errors.emplace_back(Action::ERROR, message);
+            }
+            names.insert(component->name);
+        }
+        return errors;
+    }
+
+
    std::string ComdelValidator::populateMessage(string source, ValidationContext context) {
        for (auto &[key, value]: context.attributes) {
            source = replacePlaceholder(source, key, value);
@ -202,5 +221,4 @@ namespace domain {
            this->validators.insert(std::make_pair(validator->getName(), validator));
        }
    }
-
 }
--- a/comdel/domain/comdel_validator.h
+++ b/comdel/domain/comdel_validator.h
@ -12,6 +12,10 @@ namespace domain {
        InstanceAttribute *attribute;
        Action::ActionType type;
        std::string message;
+
+        ValidationError(Action::ActionType type, std::string message): instance(nullptr), attribute(nullptr), type(type), message(message) {}
+
+        ValidationError(ComponentInstance* instance, InstanceAttribute* attribute, Action::ActionType type, std::string message): instance(instance), attribute(attribute), type(type), message(message) {}
    };

    struct ValidationContext {
@ -31,6 +35,8 @@ namespace domain {

        std::optional<ValidationError> validateRule(Rule rule, ValidationContext context);

+        std::vector<ValidationError> validateInstanceNames(Schema &schema, Library &library, ValidationContext context);
+
        std::vector<ValidationError> validateInstanceCount(Schema &schema, Library &library, ValidationContext context);

        std::vector<ValidationError>
--- a/comdel/domain/schema_creator.cpp
+++ b/comdel/domain/schema_creator.cpp
@ -167,8 +167,7 @@ namespace domain {
        }

        for (auto &comp: node.components) {
-            std::optional<Component> component;
-            component = loadComponent(comp);
+            auto component = loadComponent(comp);
            if (component) {
                components.push_back(*component);
            }
@ -196,13 +195,24 @@ namespace domain {
            }
        }

+        if(errors.empty()) {
            return Library(name, libraryInfo, header, componentDirectory, componentHeader, addressSpaces, components, buses,
                           connections, messages);
+        } else {
+            return nullopt;
+        }
+
    }

    std::optional<Bus> SchemaCreator::loadBus(BusNode node) {
        std::string busName = node.name.value;

+        if (!node.instanceName) {
+            errors.emplace_back(node.span, "missing @instanceName");
+            return nullopt;
+        }
+        std::string instanceName = node.instanceName->value;
+
        auto count = std::make_pair<int, int>(1, 1);
        if (node.count) {
            count = std::make_pair<int, int>(node.count->first.value, node.count->second.value);
@ -259,7 +269,7 @@ namespace domain {
            return nullopt;
        }

-        return Bus(busName, tooltip, type, count, wires, displayBus);
+        return Bus(busName, instanceName, tooltip, type, count, wires, displayBus);
    }


@ -497,7 +507,7 @@ namespace domain {
            pop();
            return nullopt;
        }
-        std::string instanceName = node.instanceName->asString();
+        std::string instanceName = node.instanceName->value;

        auto count = std::make_pair<int, int>(1, 1);
        if (node.count) {
@ -950,7 +960,13 @@ namespace domain {
            }
        }

+        if(errors.empty()) {
            return schema;
+        } else {
+            delete schema;
+            return nullptr;
+        }
+
    }

    shared_ptr<ComponentInstance> SchemaCreator::loadComponentInstance(InstanceNode instance, Library &library) {
--- a/comdel/parser/ast_nodes.h
+++ b/comdel/parser/ast_nodes.h
@ -309,7 +309,7 @@ struct ComponentNode : public AstNode {
    std::optional<StringNode> source;
    EnumNode<ComponentType> type;
    std::vector<RuleNode> rules;
-    std::optional<StringNode> instanceName;
+    std::optional<IdentifierNode> instanceName;
    std::optional<CountNode> count;
    std::optional<DisplayNode> display;
    std::vector<PinNode> pins;
@ -325,6 +325,7 @@ struct BusNode : public AstNode {

    EnumNode<BusType> type;
    IdentifierNode name;
+    std::optional<IdentifierNode> instanceName;
    std::optional<StringNode> tooltip;
    std::optional<CountNode> count;
    std::optional<DisplayNode> display;
--- a/comdel/parser/comdel_parser.cpp
+++ b/comdel/parser/comdel_parser.cpp
@ -438,7 +438,7 @@ PResult<ComponentNode> ComdelParser::parseComponent() {
        PResult<poly<AstNode>> err;
        if (check(TokenType::KW_INSTANCE_NAME)) {
            bump();
-            ASSIGN_OR_SET_ERR(component.instanceName, parseString());
+            ASSIGN_OR_SET_ERR(component.instanceName, parseIdentifier());
        } else if (check(TokenType::KW_TOOLTIP)) {
            bump();
            ASSIGN_OR_SET_ERR(component.tooltip, parseString());
@ -554,14 +554,17 @@ PResult<BusNode> ComdelParser::parseBus() {
        PResult<poly<AstNode>> err;
        if (check(TokenType::KW_TOOLTIP)) {
            bump();
-            ASSIGN_OR_RETURN_IF_ERR(bus.tooltip, parseString());
+            ASSIGN_OR_SET_ERR(bus.tooltip, parseString());
+        } else if (check(TokenType::KW_INSTANCE_NAME)) {
+            bump();
+            ASSIGN_OR_SET_ERR(bus.instanceName, parseIdentifier());
        } else if (check(TokenType::KW_COUNT)) {
-            ASSIGN_OR_RETURN_IF_ERR(bus.count, parseCount());
+            ASSIGN_OR_SET_ERR(bus.count, parseCount());
        } else if (check(TokenType::KW_DISPLAY)) {
-            ASSIGN_OR_RETURN_IF_ERR(bus.display, parseDisplay());
+            ASSIGN_OR_SET_ERR(bus.display, parseDisplay());
        } else if (check(TokenType::KW_WIRES)) {
            bump();
-            RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
+            if(consume(TokenType::LBRACE)) {
                while (check(TokenType::IDENTIFIER)) {
                    APPEND_OR_RETURN_IF_ERR(bus.wires, parseWire());

@ -569,7 +572,12 @@ PResult<BusNode> ComdelParser::parseBus() {
                        RETURN_IF_NOT_TOKEN(TokenType::COMMA);
                    }
                }
-            RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
+            } else {
+                err = unexpected();
+            }
+            if(!consume(TokenType::RBRACE)) {
+                err = unexpected();
+            }
        } else {
            err = unexpected();
            bump();
--- a/model/comdel.system
+++ b/model/comdel.system
@ -7,7 +7,7 @@
 component System
 {
  clock 100MHz;
-	//glavnaSabirnica
+	//bus
 	wire<32> ADR;
 	wire<32> DATA;
 	wire READ;
@ -23,31 +23,32 @@ component System
 	wire --BACK;


-	//directRam
-	wire INT;
-
-
 	// components --------------------------------------------
-	subcomponent Memorija memorija<false, 1, 65536, 8, 0>(ADR, DATA, READ, WRITE, SIZE, WAIT, INT);
-	subcomponent FRISC procesor(ADR, DATA, READ, WRITE, SIZE, WAIT, INT0, INT1, INT2, INT3, --IACK, 1, *, INT) uses memorija;
+	subcomponent Memorija mem<false, 1, 1024, 8, 1024>(ADR, DATA, READ, WRITE, SIZE, WAIT, 94534054858378, 0, null, null);
+	subcomponent FRISC procesor_002(ADR, DATA, READ, WRITE, SIZE, WAIT, INT0, INT1, INT2, INT3, --IACK, 1, *, 94534054858378, 0, null, null);
+	subcomponent FRISC procesor_001(ADR, DATA, READ, WRITE, SIZE, WAIT, INT0, INT1, INT2, INT3, --IACK, 1, *, 94534054858378, 0, null, null);
+	subcomponent FRISC procesor_000(ADR, DATA, READ, WRITE, SIZE, WAIT, INT0, INT1, INT2, INT3, --IACK, 1, *, 94534054858378, 0, null, null);
+	subcomponent FRISC procesor(ADR, DATA, READ, WRITE, SIZE, WAIT, INT0, INT1, INT2, INT3, --IACK, 1, *, 94534054858378, 0, null, null);

 	display {
-		component { x: -582; y: -296; ref: "procesor"; }
-		component { x: -446; y: -12; ref: "memorija"; }
+		component { x: 0; y: 0; ref: "procesor_002"; }
+		component { x: 0; y: 250; ref: "mem"; }
+		component { x: -89; y: 74; ref: "procesor_001"; }
+		component { x: -175; y: 195; ref: "procesor_000"; }
+		component { x: -195; y: 63; ref: "procesor"; }

-		// glavnaSabirnica bus
+		// bus bus

 		rectangle {
-			x: -581; y: -37;
+			x: 0; y: 200;
 			w: 100; h: 20;
 		}


-		// directRam bus
-
-
-		line {x1:-532; y1:-180; x2:-530; y2:-26;}
-		line {x1:-462; y1:16; x2:-466; y2:-246;}
-		line {x1:-396; y1:-28; x2:-530; y2:-26;}
+		line {x1:50; y1:116; x2:50; y2:210;}
+		line {x1:50; y1:234; x2:50; y2:210;}
+		line {x1:-39; y1:190; x2:50; y2:210;}
+		line {x1:-145; y1:179; x2:50; y2:210;}
+		line {x1:-125; y1:311; x2:50; y2:210;}
 	}
 }
--- a/model/frisc_library.csl
+++ b/model/frisc_library.csl
@ -18,7 +18,7 @@
 }

@component FRISC processor {
-    @instanceName "procesor"
+    @instanceName procesor
    @tooltip "Procesor FRISC, mora postojati jedan"
    @count (1, 1)
    @source "FRISC.cdl"
@ -77,7 +77,7 @@
 }

@component Memorija memory {
-    @instanceName "memorija"
+    @instanceName memorija
    @tooltip "Memorijska komponenta, mora postojati barem jedna"
    @count (1,1000)
    @source "memory.cdl"
@ -219,7 +219,7 @@
 }

@component DMA {
-    @instanceName "dma"
+    @instanceName dma
    @tooltip "DMA-kontroler"
    @count (0,1000)
    @source "dma.cdl"
@ -299,6 +299,7 @@
 }

@bus glavnaSabirnica regular {
+    @instanceName glavnaSabirnica
    @tooltip "sabirnica za spajanje FRISC a s memorijama i UI/jedinicama"
    @count (1,1)
    @display {
@ -334,6 +335,7 @@
    }
 }
@bus PIOSabirnica automatic {
+    @instanceName PIOSabirnica
    @count (0, 20)
    @wires {
        PIO_DATA<8>,
@ -343,6 +345,7 @@
 }

@bus directRam automatic {
+    @instanceName directRam
    @wires {
        INT
    }
--- a/examples/simplified
+++ b/examples/simplified
@ -1,7 +1,7 @@
@source "frisc_library.csl"

@schema {
-	@instance proc FRISC {
+	@instance procesor_002 FRISC {
 		@position (0, 0)
 		@attribute _memory null
 	}
@ -15,11 +15,28 @@
 		@attribute pocetnaAdresa 1024
 	}

+	@instance procesor_001 FRISC {
+		@position (-89, 74)
+		@attribute _memory null
+	}
+
+	@instance procesor_000 FRISC {
+		@position (-175, 195)
+		@attribute _memory null
+	}
+
+	@instance procesor FRISC {
+		@position (-195, 63)
+		@attribute _memory null
+	}
+
 	@instance bus glavnaSabirnica {
 		@position (0, 200)
 		@size 100
 	}

+	@connection (procesor_002.glavniPin, bus) {
+	}
 	@connection (mem.glavniPin, bus) {
 	}
 }
--- a/mainwindow.cpp
+++ b/mainwindow.cpp
@ -1,5 +1,6 @@
 #include "mainwindow.h"
 #include "ui_mainwindow.h"
+#include "application.h"

 #include <QFileDialog>
 #include <QHBoxLayout>
@ -14,22 +15,13 @@
 #include <fstream>
 #include <comdel/domain/comdel_generator.h>

-std::optional<domain::Library> MainWindow::library;
-domain::Schema* MainWindow::schema;
-
 MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
 {
-    schema = nullptr;
-    library = std::nullopt;
-
    ui->setupUi(this);

    setupUi();
-
-    // define allowed methods
-    validators = domain::getSupportedValidators();
 }

 void MainWindow::setupUi()
@ -71,187 +63,123 @@ void MainWindow::setupUi()
 void MainWindow::onLoadLibrary() {
    auto filename = QFileDialog::getOpenFileName(this,
             tr("Open library"), "/home", tr("Comdel library (*.csl)"));
-
-    std::ostringstream buffer;
-
-    log->clear();
-
    if(!filename.isEmpty()) {
-        librarySource = filename.toStdString();
-
+        std::ostringstream output;
        clear();

-        ParseContext parseContext;
-        auto libraryNode = load_library_from_file(&parseContext, filename.toStdString().c_str(), buffer);
-        if(libraryNode) {
-            domain::SchemaCreator generator(validators);
-            library = generator.loadLibrary(*libraryNode);
+        auto librarySource = filename.toStdString();

-            for (auto& error : generator.getErrors()) {
-                parseContext.formatError(error, buffer, "ERROR: ");
+        auto instance = Application::instance();
+        if(!instance->loadLibrary(librarySource, output)) {
+            log->appendPlainText(QString::fromStdString(output.str()));
        }

-            if(generator.getErrors().empty()) {
-                libraryDisplay->setLibrary(library);
-
-                // on library load we create a new schema
-                schema = new domain::Schema();
-                schemaDisplay->setSchema(schema, &(*library));
+        libraryDisplay->setLibrary(instance->getLibrary());
+        schemaDisplay->setSchema(instance->getSchema(), instance->getLibrary());
    }
-
-        } else {
-            buffer<<"Failed loading library"<<std::endl;
-        }
-    }
-
-    log->appendPlainText(QString::fromStdString(buffer.str()));
 }

 void MainWindow::onLoadSchema() {
    auto filename = QFileDialog::getOpenFileName(this,
             tr("Open schema"), "/home", tr("Comdel schema (*.csl)"));
-
-    std::ostringstream buffer;
-
-    log->clear();
-
    if(!filename.isEmpty()) {
+        std::ostringstream output;
        clear();

-        ParseContext parseContext;
-        auto schemaNode = load_schema_from_file(&parseContext, filename.toStdString().c_str(), buffer);
+        auto schemaSource = filename.toStdString();

-        if(schemaNode) {
-            domain::SchemaCreator generator(validators);
-            library = generator.loadLibrary(*schemaNode->library);
-
-            librarySource = schemaNode->source->asString();
-
-            for (auto& error : generator.getErrors()) {
-                parseContext.formatError(error, buffer, "ERROR: ");
+        auto instance = Application::instance();
+        if(!instance->loadSchema(schemaSource, output)) {
+            log->appendPlainText(QString::fromStdString(output.str()));
        }

-            if(library) {
-                schema = generator.loadSchema(*schemaNode, *library);
-
-                for (auto& error : generator.getErrors()) {
-                    parseContext.formatError(error, buffer, "ERROR: ");
-                    delete schema;
-                    schema = nullptr;
+        libraryDisplay->setLibrary(instance->getLibrary());
+        schemaDisplay->setSchema(instance->getSchema(), instance->getLibrary());
    }
-            } else {
-                library = std::nullopt;
-            }
-
-            if(generator.getErrors().empty()) {
-                libraryDisplay->setLibrary(library);
-                schemaDisplay->setSchema(schema, &(*library));
-            }
-        }
-    }
-
-    log->appendPlainText(QString::fromStdString(buffer.str()));
 }

 void MainWindow::onStoreScheme() {
-    if(schema == nullptr) {
-        return;
-    }
-
    auto filename = QFileDialog::getSaveFileName(this,
                                                 tr("Save schema"), "/home", tr("Comdel schema (*.csl)"));
+    if(!filename.isEmpty()) {
+        log->clear();

-    std::ostringstream buffer;
-
-    domain::generate_schema(librarySource, schema, buffer);
+        std::ostringstream output;

+        if(Application::instance()->generateSchema(output)) {
            std::ofstream out(filename.toStdString(), std::ios::out | std::ios::binary);
-    out<<buffer.str();
+            out<<output.str();
            out.close();
+
+            log->appendPlainText("Successfully stored schema\n");
+        } else {
+            log->appendPlainText("Failed storing schema\n");
+        }
+    }
+
 }

 void MainWindow::onGenerateComdel() {
-    if(schema == nullptr) {
-        return;
-    }
-
    auto filename = QFileDialog::getSaveFileName(this,
                                                 tr("Save schema"), "/home", tr("Comdel system (*.system)"));
+    if(!filename.isEmpty()) {
+        log->clear();

-    std::ostringstream buffer;
+        std::ostringstream output;

-    domain::generate_comdel(schema, library.value(), buffer);
+        auto validationErrors = Application::instance()->generateComdel(output);

+        std::ostringstream buff;
+        formatErrors(validationErrors, buff);
+        log->appendPlainText(QString::fromStdString(buff.str()));
+
+        if(Application::hasErrors(validationErrors)) {
            std::ofstream out(filename.toStdString(), std::ios::out | std::ios::binary);
-    out<<buffer.str();
+            out<<output.str();
            out.close();
+
+            log->appendPlainText("Successfully generated comdel\n");
+        } else {
+            log->appendPlainText("Failed generating comdel\n");
+        }
+    }
 }


 void MainWindow::onValidateSchema(bool /*toggled*/) {
-    if(schema == nullptr) {
-        return;
-    }

    log->clear();

-    this->validationErrors.clear();
-
-    domain::ComdelValidator validator{validators};
-
-    domain::ValidationContext context;
-    context.instance = nullptr;
-    context.attribute = nullptr;
-    context.addressSpaces = {};
-
-    for(auto &lib: library->getAddressSpaces()) {
-        context.addressSpaces.insert(std::make_pair(lib.getName(), lib));
-    }
-    auto errors = validator.validateSchema(*schema, context);
-
-    auto countValidation = validator.validateInstanceCount(*schema, *library, context);
-    errors.insert(errors.end(), countValidation.begin(), countValidation.end());
-
-    auto pinValidation = validator.validatePinConnections(*schema, *library, context);
-    errors.insert(errors.end(), pinValidation.begin(), pinValidation.end());
-
-    errors.erase(std::remove_if(
-                    errors.begin(), errors.end(), [](const domain::ValidationError& error) { return error.type == domain::Action::WARNING;}),
-            errors.end());
+    auto errors = Application::instance()->validateSchema();

    std::ostringstream buff;
-
-    for(auto err: errors) {
-        if(err.instance != nullptr) {
-            buff << err.instance->name;
-        }
-        if(err.attribute != nullptr) {
-            buff << "::" << err.attribute->name;
-        }
-        if(err.type == domain::Action::ERROR) {
-            buff << " [ERROR] ";
-        } else {
-            buff << " [WARNING] ";
-        }
-        buff << err.message << std::endl;
-    }
+    formatErrors(errors, buff);

    log->appendPlainText(QString::fromStdString(buff.str()));

-    validationErrors = errors;
 }

+void MainWindow::formatErrors(std::vector<domain::ValidationError>& errors, std::ostream& output) {
+    for(auto& err: errors) {
+        if(err.instance != nullptr) {
+            output << err.instance->name;
+        }
+        if(err.attribute != nullptr) {
+            output << "::" << err.attribute->name;
+        }
+        if(err.type == domain::Action::ERROR) {
+            output << " [ERROR] ";
+        } else {
+            output << " [WARNING] ";
+        }
+        output << err.message << std::endl;
+    }
+}

 void MainWindow::clear() {
-    validationErrors.clear();
-    if(schema != nullptr) {
-        delete schema;
-        schema = nullptr;
-    }
-    library = std::nullopt;
-
-    libraryDisplay->setLibrary(library);
-    schemaDisplay->setSchema(schema, nullptr);
+    log->clear();
+    this->schemaDisplay->setSchema(nullptr, std::nullopt);
+    this->libraryDisplay->setLibrary(std::nullopt);
 }

 MainWindow::~MainWindow()
--- a/mainwindow.h
+++ b/mainwindow.h
@ -24,26 +24,11 @@ public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

-    display::Library *libraryDisplay;
-    display::Schema *schemaDisplay;
-
-    static std::optional<domain::Library> library;
-    static domain::Schema* schema;
-
    std::vector<domain::FunctionValidator*> validators;

    void setupUi();
    void clear();

-    static domain::Schema* getSchema() {
-        return schema;
-    }
-
-    static std::optional<domain::Library> getLibrary() {
-        return library;
-    }
-
-
 private slots:
    void onLoadLibrary();
    void onLoadSchema();
@ -52,10 +37,11 @@ private slots:
    void onGenerateComdel();

 private:
-    std::string librarySource;
+    display::Library *libraryDisplay;
+    display::Schema *schemaDisplay;
    Ui::MainWindow *ui;
    QPlainTextEdit *log;
-    std::vector<domain::ValidationError> validationErrors;

+    static void formatErrors(std::vector<domain::ValidationError>& errors, std::ostream& output);
 };
 #endif // MAIN_WINDOW_H
Author	SHA1	Message	Date
Borna Rajković	f93a2afa63	Updated component and bus generation logic + bugfixes	2022-05-31 01:05:08 +02:00
Borna Rajković	86b8861533	Extracted schema and library management to Application	2022-05-30 23:11:06 +02:00