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 application.cpp application.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)
 target_link_libraries(SchemeEditor Qt5::Core Qt5::Gui Qt5::Widgets)

application.cpp

@@ -1,199 +0,0 @@
-//
-// 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;
-}

application.h

@@ -1,48 +0,0 @@
-//
-// 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

comdel/display/attribute_dialog.cpp

@@ -5,8 +5,6 @@
 #include "attribute_dialog.h"
 #include "mainwindow.h"
 
-#include "application.h"
-
 namespace display {
 
     void AttributeDialog::onUpdate() {
@@ -17,7 +15,7 @@ namespace display {
 
         domain::ValidationContext context;
 
-        for (auto &addressSpace: Application::instance()->getLibrary()->getAddressSpaces()) {
+        for (auto &addressSpace: MainWindow::getLibrary()->getAddressSpaces()) {
             context.addressSpaces.insert(std::make_pair(addressSpace.getName(), addressSpace));
         }
 

comdel/display/component_display.cpp

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

comdel/display/name_dialog.cpp

@@ -2,54 +2,37 @@
 // Created by bbr on 18. 04. 2022..
 //
 
-#include <set>
 #include "name_dialog.h"
 
-display::NameDialog::NameDialog(domain::ComponentInstance *instance, std::set<std::string>& names) : componentInstance(instance), usedNames(names) {
+display::NameDialog::NameDialog(domain::ComponentInstance *instance) : componentInstance(instance) {
-    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");
-    button = new QPushButton("Ažuriraj", this);
+    auto *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, std::set<std::string>& names): busInstance(instance), usedNames(names) {
+display::NameDialog::NameDialog(domain::BusInstance *instance): busInstance(instance) {
-    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");
-    button = new QPushButton("Ažuriraj", this);
+    auto *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) {

comdel/display/name_dialog.h

@@ -7,28 +7,24 @@
 #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, std::set<std::string>& names);
+        NameDialog(domain::ComponentInstance *instance);
 
-        NameDialog(domain::BusInstance *instance, std::set<std::string>& names);
+        NameDialog(domain::BusInstance *instance);
 
     public slots:
-        void onNameUpdate(const QString& text);
+
         void onNameChange();
     };
 

comdel/display/schema_display.cpp

@@ -1,7 +1,5 @@
 #include "component_display.h"
 #include "schema_display.h"
-#include "application.h"
-#include "attribute_dialog.h"
 
 #include <QDrag>
 #include <QDragEnterEvent>
@@ -12,14 +10,13 @@ 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, std::optional<domain::Library> _library) {
+    void Schema::setSchema(domain::Schema *_schema, domain::Library *_library) {
         components.clear();
         buses.clear();
 
@@ -88,30 +85,15 @@ namespace display {
 
             auto attributes = std::vector<domain::InstanceAttribute>();
             for (auto attr: component.getAttributes()) {
-                domain::InstanceAttribute attribute(attr.getName(), attr.getDefault(), attr);
+                attributes.emplace_back(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()).toPoint();
+            auto currentPos = this->mapToScene(event->pos());
 
-            auto instance = Application::instance()->addComponent(component, attributes, currentPos.x(), currentPos.y());
+            auto instance = std::make_shared<domain::ComponentInstance>(component.getInstanceName(), attributes,
+                                                                        std::make_pair(currentPos.x(), currentPos.y()),
+                                                                        component);
+            schema->componentInstances.push_back(instance);
 
             auto group = new display::ComponentGroup(instance);
             scene.addItem(group);
@@ -128,9 +110,11 @@ namespace display {
         if (event->mimeData()->hasFormat("comdel/bus")) {
             auto bus = library->getBus(event->mimeData()->data("comdel/bus").toStdString());
 
-            auto currentPos = this->mapToScene(event->pos()).toPoint();
+            auto currentPos = this->mapToScene(event->pos());
 
-            auto instance = Application::instance()->addBus(bus, currentPos.x(), currentPos.y());
+            auto instance = std::make_shared<domain::BusInstance>(bus.getName(),
+                                                                  std::make_pair(currentPos.x(), currentPos.y()), bus);
+            schema->busInstances.push_back(instance);
 
             auto group = new display::BusGroup(instance);
             scene.addItem(group);
@@ -232,9 +216,6 @@ 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());

comdel/display/schema_display.h

@@ -46,7 +46,7 @@ namespace display {
         std::vector<BusConnection *> busConnections;
         std::vector<DirectConnection *> directConnections;
 
-        void setSchema(domain::Schema *schema, std::optional<domain::Library> library);
+        void setSchema(domain::Schema *schema, domain::Library *library);
 
         void updateConnections();
 
@@ -65,8 +65,8 @@ namespace display {
     private:
         QGraphicsScene scene;
 
-        domain::Schema *schema{};
+        domain::Schema *schema;
-        std::optional<domain::Library> library;
+        domain::Library *library;
 
         std::vector<domain::BusInstance *>
         getAvailableConnectionBusses(domain::ComponentInstance *instance, domain::Pin &pin);

comdel/domain/bus.cpp

@@ -10,11 +10,6 @@ namespace domain {
         return name;
     }
 
-    std::string Bus::getInstanceName() {
-        return instanceName;
-    }
-
-
     int Wire::getWidth() {
         return width;
     }
@@ -35,9 +30,9 @@ namespace domain {
         return type;
     }
 
-    Bus::Bus(std::string name, std::string instanceName, std::string tooltip, BusType type, std::pair<int, int> count, std::vector<Wire> wires,
+    Bus::Bus(std::string name, std::string tooltip, BusType type, std::pair<int, int> count, std::vector<Wire> wires,
              std::optional<ui::Bus> displayBus)
-            : name(name), instanceName(instanceName), tooltip(tooltip), type(type), count(count), wires(wires), displayBus(displayBus) {}
+            : name(name), tooltip(tooltip), type(type), count(count), wires(wires), displayBus(displayBus) {}
 
     std::string Bus::getName() {
         return name;
@@ -62,4 +57,5 @@ namespace domain {
     std::optional<ui::Bus> Bus::getDisplayBus() {
         return displayBus;
     }
+
 } // namespace domain

comdel/domain/bus.h

@@ -54,7 +54,6 @@ namespace domain {
         };
     private:
         std::string name;
-        std::string instanceName;
         std::string tooltip;
         BusType type;
 
@@ -63,13 +62,11 @@ namespace domain {
         std::vector<Wire> wires;
 
     public:
-        Bus(std::string name, std::string instanceName, std::string tooltip, BusType type, std::pair<int, int> count, std::vector<Wire> wires,
+        Bus(std::string name, 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();

comdel/domain/comdel_validator.cpp

@@ -1,4 +1,3 @@
-#include <set>
 #include "comdel_validator.h"
 #include "library.h"
 
@@ -39,11 +38,11 @@ namespace domain {
                 auto message = populateMessage(
                         "Not enough instances of component '{componentName}' required at least {min}, found {count}",
                         context);
-                errors.emplace_back(Action::ERROR, message);
+                errors.push_back(ValidationError{nullptr, nullptr, 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.emplace_back(Action::ERROR, message);
+                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
             }
         }
 
@@ -65,11 +64,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.emplace_back(Action::ERROR, message);
+                errors.push_back(ValidationError{nullptr, nullptr, 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.emplace_back(Action::ERROR, message);
+                errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
             }
         }
 
@@ -87,7 +86,7 @@ namespace domain {
                         context.instance = inst.get();
                         context.attributes["instanceName"] = Value::fromString(inst->name);
                         auto message = populateMessage(pin.getConnection().getMessage(), context);
-                        errors.emplace_back(Action::ERROR, message);
+                        errors.push_back(ValidationError{nullptr, nullptr, Action::ERROR, message});
                     }
                 }
             }
@@ -153,24 +152,6 @@ 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);
@@ -221,4 +202,5 @@ namespace domain {
             this->validators.insert(std::make_pair(validator->getName(), validator));
         }
     }
+
 }

comdel/domain/comdel_validator.h

@@ -12,10 +12,6 @@ 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 {
@@ -35,8 +31,6 @@ 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>

comdel/domain/schema_creator.cpp

@@ -167,7 +167,8 @@ namespace domain {
         }
 
         for (auto &comp: node.components) {
-            auto component = loadComponent(comp);
+            std::optional<Component> component;
+            component = loadComponent(comp);
             if (component) {
                 components.push_back(*component);
             }
@@ -195,24 +196,13 @@ 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);
@@ -269,7 +259,7 @@ namespace domain {
             return nullopt;
         }
 
-        return Bus(busName, instanceName, tooltip, type, count, wires, displayBus);
+        return Bus(busName, tooltip, type, count, wires, displayBus);
     }
 
 
@@ -507,7 +497,7 @@ namespace domain {
             pop();
             return nullopt;
         }
-        std::string instanceName = node.instanceName->value;
+        std::string instanceName = node.instanceName->asString();
 
         auto count = std::make_pair<int, int>(1, 1);
         if (node.count) {
@@ -960,13 +950,7 @@ namespace domain {
             }
         }
 
-        if(errors.empty()) {
         return schema;
-        } else {
-            delete schema;
-            return nullptr;
-        }
-
     }
 
     shared_ptr<ComponentInstance> SchemaCreator::loadComponentInstance(InstanceNode instance, Library &library) {

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<IdentifierNode> instanceName;
+    std::optional<StringNode> instanceName;
     std::optional<CountNode> count;
     std::optional<DisplayNode> display;
     std::vector<PinNode> pins;
@@ -325,7 +325,6 @@ 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;

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, parseIdentifier());
+            ASSIGN_OR_SET_ERR(component.instanceName, parseString());
         } else if (check(TokenType::KW_TOOLTIP)) {
             bump();
             ASSIGN_OR_SET_ERR(component.tooltip, parseString());
@@ -554,17 +554,14 @@ PResult<BusNode> ComdelParser::parseBus() {
         PResult<poly<AstNode>> err;
         if (check(TokenType::KW_TOOLTIP)) {
             bump();
-            ASSIGN_OR_SET_ERR(bus.tooltip, parseString());
+            ASSIGN_OR_RETURN_IF_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_SET_ERR(bus.count, parseCount());
+            ASSIGN_OR_RETURN_IF_ERR(bus.count, parseCount());
         } else if (check(TokenType::KW_DISPLAY)) {
-            ASSIGN_OR_SET_ERR(bus.display, parseDisplay());
+            ASSIGN_OR_RETURN_IF_ERR(bus.display, parseDisplay());
         } else if (check(TokenType::KW_WIRES)) {
             bump();
-            if(consume(TokenType::LBRACE)) {
+            RETURN_IF_NOT_TOKEN(TokenType::LBRACE);
             while (check(TokenType::IDENTIFIER)) {
                 APPEND_OR_RETURN_IF_ERR(bus.wires, parseWire());
 
@@ -572,12 +569,7 @@ PResult<BusNode> ComdelParser::parseBus() {
                     RETURN_IF_NOT_TOKEN(TokenType::COMMA);
                 }
             }
-            } else {
+            RETURN_IF_NOT_TOKEN(TokenType::RBRACE);
-                err = unexpected();
-            }
-            if(!consume(TokenType::RBRACE)) {
-                err = unexpected();
-            }
         } else {
             err = unexpected();
             bump();

examples/simplified FRISC model/comdel.system

@@ -7,7 +7,7 @@
 component System
 {
   clock 100MHz;
-	//bus
+	//glavnaSabirnica
 	wire<32> ADR;
 	wire<32> DATA;
 	wire READ;
@@ -23,32 +23,31 @@ component System
 	wire --BACK;
 
 
+	//directRam
+	wire INT;
+
+
 	// components --------------------------------------------
-	subcomponent Memorija mem<false, 1, 1024, 8, 1024>(ADR, DATA, READ, WRITE, SIZE, WAIT, 94534054858378, 0, null, null);
+	subcomponent Memorija memorija<false, 1, 65536, 8, 0>(ADR, DATA, READ, WRITE, SIZE, WAIT, INT);
-	subcomponent FRISC procesor_002(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, *, INT) uses memorija;
-	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: 0; y: 0; ref: "procesor_002"; }
+		component { x: -582; y: -296; ref: "procesor"; }
-		component { x: 0; y: 250; ref: "mem"; }
+		component { x: -446; y: -12; ref: "memorija"; }
-		component { x: -89; y: 74; ref: "procesor_001"; }
-		component { x: -175; y: 195; ref: "procesor_000"; }
-		component { x: -195; y: 63; ref: "procesor"; }
 
-		// bus bus
+		// glavnaSabirnica bus
 
 		rectangle {
-			x: 0; y: 200;
+			x: -581; y: -37;
 			w: 100; h: 20;
 		}
 
 
-		line {x1:50; y1:116; x2:50; y2:210;}
+		// directRam bus
-		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:-532; y1:-180; x2:-530; y2:-26;}
-		line {x1:-125; y1:311; x2:50; y2:210;}
+		line {x1:-462; y1:16; x2:-466; y2:-246;}
+		line {x1:-396; y1:-28; x2:-530; y2:-26;}
 	}
 }

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

examples/simplified FRISC model/schema2.csl

@@ -1,7 +1,7 @@
 @source "frisc_library.csl"
 
 @schema {
-	@instance procesor_002 FRISC {
+	@instance proc FRISC {
 		@position (0, 0)
 		@attribute _memory null
 	}
@@ -15,28 +15,11 @@
 		@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) {
 	}
 }

mainwindow.cpp

@@ -1,6 +1,5 @@
 #include "mainwindow.h"
 #include "ui_mainwindow.h"
-#include "application.h"
 
 #include <QFileDialog>
 #include <QHBoxLayout>
@@ -15,13 +14,22 @@
 #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()
@@ -63,123 +71,187 @@ 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()) {
-        std::ostringstream output;
+        librarySource = filename.toStdString();
+
         clear();
 
-        auto librarySource = filename.toStdString();
+        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 instance = Application::instance();
+            for (auto& error : generator.getErrors()) {
-        if(!instance->loadLibrary(librarySource, output)) {
+                parseContext.formatError(error, buffer, "ERROR: ");
-            log->appendPlainText(QString::fromStdString(output.str()));
             }
 
-        libraryDisplay->setLibrary(instance->getLibrary());
+            if(generator.getErrors().empty()) {
-        schemaDisplay->setSchema(instance->getSchema(), instance->getLibrary());
+                libraryDisplay->setLibrary(library);
+
+                // on library load we create a new schema
+                schema = new domain::Schema();
+                schemaDisplay->setSchema(schema, &(*library));
             }
+
+        } 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();
 
-        auto schemaSource = filename.toStdString();
+        ParseContext parseContext;
+        auto schemaNode = load_schema_from_file(&parseContext, filename.toStdString().c_str(), buffer);
 
-        auto instance = Application::instance();
+        if(schemaNode) {
-        if(!instance->loadSchema(schemaSource, output)) {
+            domain::SchemaCreator generator(validators);
-            log->appendPlainText(QString::fromStdString(output.str()));
+            library = generator.loadLibrary(*schemaNode->library);
+
+            librarySource = schemaNode->source->asString();
+
+            for (auto& error : generator.getErrors()) {
+                parseContext.formatError(error, buffer, "ERROR: ");
             }
 
-        libraryDisplay->setLibrary(instance->getLibrary());
+            if(library) {
-        schemaDisplay->setSchema(instance->getSchema(), instance->getLibrary());
+                schema = generator.loadSchema(*schemaNode, *library);
+
+                for (auto& error : generator.getErrors()) {
+                    parseContext.formatError(error, buffer, "ERROR: ");
+                    delete schema;
+                    schema = nullptr;
                 }
+            } 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 output;
+    std::ostringstream buffer;
+
+    domain::generate_schema(librarySource, schema, buffer);
 
-        if(Application::instance()->generateSchema(output)) {
     std::ofstream out(filename.toStdString(), std::ios::out | std::ios::binary);
-            out<<output.str();
+    out<<buffer.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 output;
+    std::ostringstream buffer;
 
-        auto validationErrors = Application::instance()->generateComdel(output);
+    domain::generate_comdel(schema, library.value(), buffer);
 
-        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<<output.str();
+    out<<buffer.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();
 
-    auto errors = Application::instance()->validateSchema();
+    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());
 
     std::ostringstream buff;
-    formatErrors(errors, 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;
+    }
 
     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() {
-    log->clear();
+    validationErrors.clear();
-    this->schemaDisplay->setSchema(nullptr, std::nullopt);
+    if(schema != nullptr) {
-    this->libraryDisplay->setLibrary(std::nullopt);
+        delete schema;
+        schema = nullptr;
+    }
+    library = std::nullopt;
+
+    libraryDisplay->setLibrary(library);
+    schemaDisplay->setSchema(schema, nullptr);
 }
 
 MainWindow::~MainWindow()

mainwindow.h

@@ -24,11 +24,26 @@ 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();
@@ -37,11 +52,10 @@ private slots:
     void onGenerateComdel();
 
 private:
-    display::Library *libraryDisplay;
+    std::string librarySource;
-    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