--- /dev/null
+/*
+ Copyright (C) 2012 Modelon AB
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the BSD style license.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ FMILIB_License.txt file for more details.
+
+ You should have received a copy of the FMILIB_License.txt file
+ along with this program. If not, contact Modelon AB <http://www.modelon.com>.
+*/
+
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include <FMI1/fmi1_xml_model_description.h>
+#include <FMI1/fmi1_functions.h>
+
+#include "fmi1_import_impl.h"
+
+/**
+ \brief Collect model information by counting the number of variables with specific properties and fillinf in fmi1_import_model_counts_t struct.
+ \param fmu - An fmu object as returned by fmi1_import_parse_xml().
+ \param counts - a pointer to a preallocated struct.
+*/
+void fmi1_import_collect_model_counts(fmi1_import_t* fmu, fmi1_import_model_counts_t* counts) {
+ jm_vector(jm_voidp)* vars = fmi1_xml_get_variables_original_order(fmu->md);
+ size_t nv, i;
+ memset(counts,0,sizeof(fmi1_import_model_counts_t));
+ if(!vars) return;
+ nv = jm_vector_get_size(jm_voidp)(vars);
+ for(i = 0; i< nv; i++) {
+ fmi1_xml_variable_t* var = (fmi1_xml_variable_t*)jm_vector_get_item(jm_voidp)(vars, i);
+ switch (fmi1_xml_get_variability(var)) {
+ case fmi1_variability_enu_constant:
+ counts->num_constants++;
+ break;
+ case fmi1_variability_enu_parameter:
+ counts->num_parameters++;
+ break;
+ case fmi1_variability_enu_discrete:
+ counts->num_discrete++;
+ break;
+ case fmi1_variability_enu_continuous:
+ counts->num_continuous++;
+ break;
+ default:
+ assert(0);
+ }
+ switch(fmi1_xml_get_causality(var)) {
+ case fmi1_causality_enu_none:
+ counts->num_causality_none++;
+ break;
+ case fmi1_causality_enu_input:
+ counts->num_inputs++;
+ break;
+ case fmi1_causality_enu_output:
+ counts->num_outputs++;
+ break;
+ case fmi1_causality_enu_internal:
+ counts->num_internal++;
+ break;
+ default: assert(0);
+ }
+ switch(fmi1_xml_get_variable_base_type(var)) {
+ case fmi1_base_type_real:
+ counts->num_real_vars++;
+ break;
+ case fmi1_base_type_int:
+ counts->num_integer_vars++;
+ break;
+ case fmi1_base_type_bool:
+ counts->num_bool_vars++;
+ break;
+ case fmi1_base_type_str:
+ counts->num_string_vars++;
+ break;
+ case fmi1_base_type_enum:
+ counts->num_enum_vars++;
+ break;
+ default:
+ assert(0);
+ }
+ }
+ return;
+}
+
+void fmi1_import_expand_variable_references_impl(fmi1_import_t* fmu, const char* msgIn);
+
+void fmi1_import_expand_variable_references(fmi1_import_t* fmu, const char* msgIn, char* msgOut, size_t maxMsgSize) {
+ fmi1_import_expand_variable_references_impl(fmu, msgIn);
+ strncpy(msgOut, jm_vector_get_itemp(char)(&fmu->logMessageBufferExpanded,0),maxMsgSize);
+ msgOut[maxMsgSize - 1] = '\0';
+}
+
+/* Print msgIn into msgOut by expanding variable references of the form #<Type><VR># into variable names
+ and replacing '##' with a single # */
+void fmi1_import_expand_variable_references_impl(fmi1_import_t* fmu, const char* msgIn){
+ jm_vector(char)* msgOut = &fmu->logMessageBufferExpanded;
+ fmi1_xml_model_description_t* md = fmu->md;
+ jm_callbacks* callbacks = fmu->callbacks;
+ char curCh;
+ const char* firstRef;
+ size_t i; /* next char index after curCh in msgIn*/
+ size_t msgLen = strlen(msgIn)+1; /* original message length including terminating 0 */
+
+ if(jm_vector_reserve(char)(msgOut, msgLen + 100) < msgLen + 100) {
+ jm_log(fmu->callbacks,"LOGGER", jm_log_level_warning, "Could not allocate memory for the log message");
+ jm_vector_resize(char)(msgOut, 6);
+ memcpy(jm_vector_get_itemp(char)(msgOut,0),"ERROR",6); /* at least 16 chars are always there */
+ return;
+ }
+
+ /* check if there are any refs at all and copy the head of the string without references */
+ firstRef = strchr(msgIn, '#');
+ if(firstRef) {
+ i = firstRef - msgIn;
+ jm_vector_resize(char)(msgOut, i);
+ if(i) {
+ memcpy(jm_vector_get_itemp(char)(msgOut, 0), msgIn, i);
+ }
+ curCh = msgIn[i++];
+ }
+ else {
+ jm_vector_resize(char)(msgOut, msgLen);
+ memcpy(jm_vector_get_itemp(char)(msgOut, 0), msgIn, msgLen);
+ return;
+ }
+ do {
+ if (curCh!='#') {
+ jm_vector_push_back(char)(msgOut, curCh); /* copy in to out */
+ }
+ else if(msgIn[i] == '#') {
+ jm_vector_push_back(char)(msgOut, '#');
+ i++; /* skip the second # */
+ }
+ else {
+ fmi1_value_reference_t vr = fmi1_undefined_value_reference;
+ char typeChar = msgIn[i++];
+ size_t pastePos = jm_vector_get_size(char)(msgOut);
+ fmi1_base_type_enu_t baseType;
+ size_t num_digits;
+ fmi1_xml_variable_t* var;
+ const char* name;
+ size_t nameLen;
+ switch(typeChar) {
+ case 'r':
+ baseType = fmi1_base_type_real;
+ break;
+ case 'i':
+ baseType = fmi1_base_type_int;
+ break;
+ case 'b':
+ baseType = fmi1_base_type_bool;
+ break;
+ case 's':
+ baseType = fmi1_base_type_str;
+ break;
+ default:
+ jm_vector_push_back(char)(msgOut, 0);
+ jm_log(callbacks,"LOGGER", jm_log_level_warning,
+ "Expected type specification character 'r', 'i', 'b' or 's' in log message here: '%s'",
+ jm_vector_get_itemp(char)(msgOut,0));
+ jm_vector_resize(char)(msgOut, msgLen);
+ memcpy(jm_vector_get_itemp(char)(msgOut,0),msgIn,msgLen);
+ return;
+ }
+ curCh = msgIn[i++];
+ while( isdigit(curCh) ) {
+ jm_vector_push_back(char)(msgOut, curCh);
+ curCh = msgIn[i++];
+ }
+ num_digits = jm_vector_get_size(char)(msgOut) - pastePos;
+ jm_vector_push_back(char)(msgOut, 0);
+ if(num_digits == 0) {
+ jm_log(callbacks,"LOGGER", jm_log_level_warning, "Expected value reference in log message here: '%s'", jm_vector_get_itemp(char)(msgOut,0));
+ jm_vector_resize(char)(msgOut, msgLen);
+ jm_vector_resize(char)(msgOut, msgLen);
+ memcpy(jm_vector_get_itemp(char)(msgOut,0),msgIn,msgLen);
+ return;
+ }
+ else if(curCh != '#') {
+ jm_log(callbacks,"LOGGER", jm_log_level_warning, "Expected terminating '#' in log message here: '%s'", jm_vector_get_itemp(char)(msgOut,0));
+ jm_vector_resize(char)(msgOut, msgLen);
+ jm_vector_resize(char)(msgOut, msgLen);
+ memcpy(jm_vector_get_itemp(char)(msgOut,0),msgIn,msgLen);
+ return;
+ }
+
+ if(sscanf(jm_vector_get_itemp(char)(msgOut, pastePos), "%u",&vr) != 1) {
+ jm_log(callbacks,"LOGGER", jm_log_level_warning, "Could not decode value reference in log message here: '%s'", jm_vector_get_itemp(char)(msgOut,0));
+ jm_vector_resize(char)(msgOut, msgLen);
+ jm_vector_resize(char)(msgOut, msgLen);
+ memcpy(jm_vector_get_itemp(char)(msgOut,0),msgIn,msgLen);
+ return;
+ }
+ var = fmi1_xml_get_variable_by_vr(md,baseType,vr);
+ if(!var) {
+ jm_log(callbacks,"LOGGER", jm_log_level_warning, "Could not find variable referenced in log message here: '%s'", jm_vector_get_itemp(char)(msgOut,0));
+ jm_vector_resize(char)(msgOut, msgLen);
+ jm_vector_resize(char)(msgOut, msgLen);
+ memcpy(jm_vector_get_itemp(char)(msgOut,0),msgIn,msgLen);
+ return;
+ }
+ name = fmi1_xml_get_variable_name(var);
+ nameLen = strlen(name);
+ if(jm_vector_resize(char)(msgOut, pastePos + nameLen) != pastePos + nameLen) {
+ jm_log(callbacks,"LOGGER", jm_log_level_warning, "Could not allocate memory for the log message");
+ jm_vector_resize(char)(msgOut, msgLen);
+ jm_vector_resize(char)(msgOut, msgLen);
+ memcpy(jm_vector_get_itemp(char)(msgOut,0),msgIn,msgLen);
+ return;
+ };
+ memcpy(jm_vector_get_itemp(char)(msgOut, pastePos), name, nameLen);
+ }
+ curCh = msgIn[i++];
+ } while (curCh);
+ jm_vector_push_back(char)(msgOut, 0);
+}
+
+jm_callbacks fmi1_import_active_fmu_store_callbacks;
+
+jm_vector(jm_voidp) fmi1_import_active_fmu_store;
+
+jm_vector(jm_voidp)* fmi1_import_active_fmu = 0;
+
+void fmi1_log_forwarding(fmi1_component_t c, fmi1_string_t instanceName, fmi1_status_t status, fmi1_string_t category, fmi1_string_t message, ...) {
+ va_list args;
+ va_start (args, message);
+ fmi1_log_forwarding_v(c, instanceName, status, category, message, args);
+ va_end (args);
+}
+
+void fmi1_log_forwarding_v(fmi1_component_t c, fmi1_string_t instanceName, fmi1_status_t status, fmi1_string_t category, fmi1_string_t message, va_list args) {
+#define BUFSIZE JM_MAX_ERROR_MESSAGE_SIZE
+ char buffer[BUFSIZE], *buf, *curp, *msg;
+ const char* statusStr;
+ fmi1_import_t* fmu = 0;
+ jm_callbacks* cb = jm_get_default_callbacks();
+ jm_log_level_enu_t logLevel = jm_log_level_error;
+ if(fmi1_import_active_fmu) {
+ size_t n = jm_vector_get_size(jm_voidp)(fmi1_import_active_fmu);
+ size_t i;
+ for(i= 0; i < n; i++) {
+ fmu = (fmi1_import_t*)jm_vector_get_item(jm_voidp)(fmi1_import_active_fmu, i);
+ if(fmu->capi->c == c) {
+ cb = fmu->callbacks;
+ break;
+ }
+ }
+ if(i >= n) { /* Could not find matching FMU -> use default callbacks */
+ fmu = 0;
+ cb = jm_get_default_callbacks();
+ }
+ }
+ if(fmu) {
+ buf = jm_vector_get_itemp(char)(&fmu->logMessageBufferCoded,0);
+ }
+ else {
+ buf = buffer;
+ }
+ switch(status) {
+ case fmi1_status_discard:
+ case fmi1_status_pending:
+ case fmi1_status_ok:
+ logLevel = jm_log_level_info;
+ break;
+ case fmi1_status_warning:
+ logLevel = jm_log_level_warning;
+ break;
+ case fmi1_status_error:
+ logLevel = jm_log_level_error;
+ break;
+ case fmi1_status_fatal:
+ default:
+ logLevel = jm_log_level_fatal;
+ }
+
+ if(logLevel > cb->log_level) return;
+
+ curp = buf;
+ *curp = 0;
+
+ if(category) {
+ curp += jm_snprintf(curp, 100, "[%s]", category);
+ }
+ statusStr = fmi1_status_to_string(status);
+ curp += jm_snprintf(curp, 100,"[FMU status:%s] ", statusStr);
+
+ if(fmu) {
+ int bufsize = jm_vector_get_size(char)(&fmu->logMessageBufferCoded);
+ int len;
+#ifdef JM_VA_COPY
+ va_list argscp;
+ JM_VA_COPY(argscp, args);
+#endif
+ len = jm_vsnprintf(curp, bufsize -(curp-buf), message, args);
+ if(len > (bufsize -(curp-buf+1))) {
+ int offset = (curp-buf);
+ len = jm_vector_resize(char)(&fmu->logMessageBufferCoded, len + offset + 1) - offset;
+ buf = jm_vector_get_itemp(char)(&fmu->logMessageBufferCoded,0);
+ curp = buf + offset;
+#ifdef JM_VA_COPY
+ jm_vsnprintf(curp, len, message, argscp);
+#endif
+ }
+#ifdef JM_VA_COPY
+ va_end(argscp);
+#endif
+ fmi1_import_expand_variable_references(fmu, buf, cb->errMessageBuffer,JM_MAX_ERROR_MESSAGE_SIZE);
+ msg = jm_vector_get_itemp(char)(&fmu->logMessageBufferExpanded,0);
+ }
+ else {
+ jm_vsnprintf(curp, BUFSIZE -(curp-buf), message, args);
+ strncpy(cb->errMessageBuffer, buf, JM_MAX_ERROR_MESSAGE_SIZE);
+ cb->errMessageBuffer[JM_MAX_ERROR_MESSAGE_SIZE - 1] = '\0';
+ msg = cb->errMessageBuffer;
+ }
+ if(cb->logger) {
+ cb->logger(cb, instanceName, logLevel, msg);
+ }
+}
+
+void fmi1_default_callback_logger(fmi1_component_t c, fmi1_string_t instanceName, fmi1_status_t status, fmi1_string_t category, fmi1_string_t message, ...) {
+ va_list args;
+
+ char buf[BUFSIZE], *curp;
+ va_start (args, message);
+ curp = buf;
+ *curp = 0;
+ if(instanceName) {
+ curp += jm_snprintf(curp, 200, "[%s]", instanceName);
+ }
+ if(category) {
+ curp += jm_snprintf(curp, 200, "[%s]", category);
+ }
+ fprintf(stdout, "%s[status=%s]", buf, fmi1_status_to_string(status));
+ vfprintf (stdout, message, args);
+ fprintf(stdout, "\n");
+ va_end (args);
+}
+
+void fmi1_logger(jm_callbacks* cb, jm_string module, jm_log_level_enu_t log_level, jm_string message) {
+ fmi1_callback_functions_t* c = (fmi1_callback_functions_t*)cb->context;
+ fmi1_status_t status;
+ if(!c ||!c->logger) return;
+
+ if(log_level > jm_log_level_all) {
+ assert(0);
+ status = fmi1_status_error;
+ }
+ else if(log_level >= jm_log_level_info)
+ status = fmi1_status_ok;
+ else if(log_level >= jm_log_level_warning)
+ status = fmi1_status_warning;
+ else if(log_level >= jm_log_level_error)
+ status = fmi1_status_error;
+ else if(log_level >= jm_log_level_fatal)
+ status = fmi1_status_fatal;
+ else {
+ status = fmi1_status_ok;
+ }
+
+ c->logger( c, module, status, jm_log_level_to_string(log_level), message);
+}
+
+void fmi1_import_init_logger(jm_callbacks* cb, fmi1_callback_functions_t* fmiCallbacks) {
+ cb->logger = fmi1_logger;
+ cb->context = fmiCallbacks;
+}
Code Review / simantics / fmil.git / blobdiff