371 lines
12 KiB
C++
371 lines
12 KiB
C++
//
|
|
// 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()) {
|
|
libraryPath = filename;
|
|
// on library load we create a new schema
|
|
schema = new domain::Schema();
|
|
} else {
|
|
errorOutput << "Failed creating library model" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
} else {
|
|
errorOutput << "Failed parsing library" << std::endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::pair<bool, std::vector<domain::ValidationError>> Application::loadSchema(std::string &filename, std::ostream &errorOutput) {
|
|
clear();
|
|
|
|
std::vector<domain::ValidationError> errors;
|
|
|
|
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, errors};
|
|
}
|
|
} else {
|
|
clear();
|
|
return {false, errors};
|
|
}
|
|
|
|
} else {
|
|
errorOutput << "Failed parsing library" << std::endl;
|
|
return {false, errors};
|
|
}
|
|
|
|
domain::ComdelValidator validator{validators};
|
|
|
|
domain::ValidationContext context;
|
|
context.instance = nullptr;
|
|
context.attribute = nullptr;
|
|
context.addressSpaces = {};
|
|
|
|
auto memoryReferenceValidation = validator.validateMemoryReferences(*schema, *library, context);
|
|
errors.insert(errors.end(), memoryReferenceValidation.begin(), memoryReferenceValidation.end());
|
|
|
|
auto nameValidation = validator.validateInstanceNames(*schema, *library, context);
|
|
errors.insert(errors.end(), nameValidation.begin(), nameValidation.end());
|
|
|
|
if(!errors.empty()) {
|
|
clear();
|
|
return {false, errors};
|
|
}
|
|
|
|
return {true, errors};
|
|
}
|
|
|
|
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 memoryReferenceValidation = validator.validateMemoryReferences(*schema, *library, context);
|
|
errors.insert(errors.end(), memoryReferenceValidation.begin(), memoryReferenceValidation.end());
|
|
|
|
auto nameValidation = validator.validateInstanceNames(*schema, *library, context);
|
|
errors.insert(errors.end(), nameValidation.begin(), nameValidation.end());
|
|
|
|
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());
|
|
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;
|
|
}
|
|
|
|
bool Application::removeComponent(std::string componentName) {
|
|
auto component = findComponentByName(componentName);
|
|
if (component == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
std::set<domain::BusInstance*> automaticBusses;
|
|
|
|
schema->connections.erase(
|
|
std::remove_if(
|
|
schema->connections.begin(),
|
|
schema->connections.end(),
|
|
[component, &automaticBusses](const std::shared_ptr<domain::ConnectionInstance> &conn) {
|
|
auto busConnection = dynamic_cast<domain::BusConnectionInstance *>(conn.get());
|
|
if (busConnection) {
|
|
if (busConnection->instance == component) {
|
|
return true;
|
|
}
|
|
}
|
|
auto directConnection = dynamic_cast<domain::DirectConnectionInstance *>(conn.get());
|
|
if (directConnection) {
|
|
if (directConnection->instance == component || directConnection->secondInstance == component) {
|
|
automaticBusses.insert(directConnection->bus);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}),
|
|
schema->connections.end()
|
|
);
|
|
|
|
schema->busInstances.erase(
|
|
std::remove_if(
|
|
schema->busInstances.begin(),
|
|
schema->busInstances.end(),
|
|
[&automaticBusses](const std::shared_ptr<domain::BusInstance> &bus) {
|
|
return automaticBusses.count(bus.get());
|
|
}),
|
|
schema->busInstances.end()
|
|
);
|
|
|
|
if(component->component.getType() == domain::Component::MEMORY) {
|
|
for(auto& comp: schema->componentInstances) {
|
|
if(comp->component.getType() == domain::Component::PROCESSOR) {
|
|
for(auto& attribute: comp->attributes) {
|
|
if(attribute.value.isType(domain::Value::MEMORY_REFERENCE) && attribute.value.asMemoryReference() == component->name) {
|
|
attribute.value = domain::Value::fromMemoryReference(std::nullopt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for(auto iter = schema->componentInstances.begin(); iter != schema->componentInstances.end(); ++iter) {
|
|
if(iter->get() == component) {
|
|
schema->componentInstances.erase(iter);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Application::removeBus(std::string busName) {
|
|
auto bus = findBusByName(busName);
|
|
if (bus == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
schema->connections.erase(
|
|
std::remove_if(
|
|
schema->connections.begin(),
|
|
schema->connections.end(),
|
|
[bus](const std::shared_ptr<domain::ConnectionInstance> &conn) {
|
|
auto busConnection = dynamic_cast<domain::BusConnectionInstance *>(conn.get());
|
|
if (busConnection) {
|
|
if (busConnection->bus == bus) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}),
|
|
schema->connections.end()
|
|
);
|
|
|
|
for(auto iter = schema->busInstances.begin(); iter != schema->busInstances.end(); ++iter) {
|
|
if(iter->get() == bus) {
|
|
schema->busInstances.erase(iter);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
domain::ComponentInstance *Application::findComponentByName(std::string componentName) {
|
|
for (auto &comp: schema->componentInstances) {
|
|
if (comp->name == componentName) {
|
|
return comp.get();
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
domain::BusInstance *Application::findBusByName(std::string busName) {
|
|
for (auto &bus: schema->busInstances) {
|
|
if (bus->name == busName) {
|
|
return bus.get();
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void Application::renameComponent(std::string currentName, std::string newName) {
|
|
if(currentName == newName) {
|
|
return;
|
|
}
|
|
auto component = findComponentByName(currentName);
|
|
if(component) {
|
|
component->name = newName;
|
|
if(component->component.getType() == domain::Component::MEMORY) {
|
|
for(auto& comp: schema->componentInstances) {
|
|
if(comp.get()->component.getType() == domain::Component::PROCESSOR) {
|
|
for(auto& attribute: comp.get()->attributes) {
|
|
if(attribute.value.isType(domain::Value::MEMORY_REFERENCE) && attribute.value.asMemoryReference() == currentName) {
|
|
attribute.value = domain::Value::fromMemoryReference(newName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Application::renameBus(std::string currentName, std::string newName) {
|
|
if(currentName == newName) {
|
|
return;
|
|
}
|
|
auto bus = findBusByName(currentName);
|
|
if(bus) {
|
|
bus->name = newName;
|
|
}
|
|
}
|