--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>\r
+<classpath>\r
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>\r
+ <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>\r
+ <classpathentry kind="src" path="src"/>\r
+ <classpathentry kind="output" path="bin"/>\r
+</classpath>\r
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>\r
+<projectDescription>\r
+ <name>org.simantics.fmil</name>\r
+ <comment></comment>\r
+ <projects>\r
+ </projects>\r
+ <buildSpec>\r
+ <buildCommand>\r
+ <name>org.eclipse.jdt.core.javabuilder</name>\r
+ <arguments>\r
+ </arguments>\r
+ </buildCommand>\r
+ <buildCommand>\r
+ <name>org.eclipse.pde.ManifestBuilder</name>\r
+ <arguments>\r
+ </arguments>\r
+ </buildCommand>\r
+ <buildCommand>\r
+ <name>org.eclipse.pde.SchemaBuilder</name>\r
+ <arguments>\r
+ </arguments>\r
+ </buildCommand>\r
+ </buildSpec>\r
+ <natures>\r
+ <nature>org.eclipse.pde.PluginNature</nature>\r
+ <nature>org.eclipse.jdt.core.javanature</nature>\r
+ </natures>\r
+</projectDescription>\r
--- /dev/null
+eclipse.preferences.version=1\r
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled\r
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8\r
+org.eclipse.jdt.core.compiler.compliance=1.8\r
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error\r
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error\r
+org.eclipse.jdt.core.compiler.source=1.8\r
--- /dev/null
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: FMI Library
+Bundle-SymbolicName: org.simantics.fmil
+Bundle-Version: 1.0.0.qualifier
+Bundle-Vendor: Semantum Oy
+Bundle-RequiredExecutionEnvironment: JavaSE-1.7
+Require-Bundle: org.eclipse.core.runtime;bundle-version="3.7.0",
+ org.simantics.utils;bundle-version="1.1.0",
+ org.simantics;bundle-version="1.0.0"
+Export-Package: org.simantics.fmil
--- /dev/null
+source.. = src/\r
+output.. = bin/\r
+bin.includes = META-INF/,\\r
+ .\r
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup Label="ProjectConfigurations">\r
+ <ProjectConfiguration Include="Debug|Win32">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Debug|x64">\r
+ <Configuration>Debug</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|Win32">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>Win32</Platform>\r
+ </ProjectConfiguration>\r
+ <ProjectConfiguration Include="Release|x64">\r
+ <Configuration>Release</Configuration>\r
+ <Platform>x64</Platform>\r
+ </ProjectConfiguration>\r
+ </ItemGroup>\r
+ <PropertyGroup Label="Globals">\r
+ <ProjectGuid>{9838038D-09A3-43A5-AB97-B5B5C763DF43}</ProjectGuid>\r
+ <Keyword>Win32Proj</Keyword>\r
+ <RootNamespace>FMUSimulator</RootNamespace>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />\r
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <UseDebugLibraries>true</UseDebugLibraries>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ <PlatformToolset>v110</PlatformToolset>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <UseDebugLibraries>true</UseDebugLibraries>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ <PlatformToolset>v110</PlatformToolset>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <UseDebugLibraries>false</UseDebugLibraries>\r
+ <WholeProgramOptimization>false</WholeProgramOptimization>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ <PlatformToolset>v110</PlatformToolset>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">\r
+ <ConfigurationType>DynamicLibrary</ConfigurationType>\r
+ <UseDebugLibraries>false</UseDebugLibraries>\r
+ <WholeProgramOptimization>false</WholeProgramOptimization>\r
+ <CharacterSet>NotSet</CharacterSet>\r
+ <PlatformToolset>v110</PlatformToolset>\r
+ </PropertyGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />\r
+ <ImportGroup Label="ExtensionSettings">\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ </ImportGroup>\r
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ </ImportGroup>\r
+ <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ </ImportGroup>\r
+ <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">\r
+ <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />\r
+ </ImportGroup>\r
+ <PropertyGroup Label="UserMacros" />\r
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">\r
+ <LinkIncremental>false</LinkIncremental>\r
+ <IncludePath>$(SolutionDir)zlib-1.2.6\contrib\minizip;$(OutDir);$(ProjectDir)include;$(IncludePath)</IncludePath>\r
+ <LibraryPath>$(OutDir);$(ProjectDir)include;$(LibraryPath)</LibraryPath>\r
+ <SourcePath>$(SourcePath)</SourcePath>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">\r
+ <LinkIncremental>false</LinkIncremental>\r
+ <IncludePath>$(SolutionDir)zlib-1.2.6\contrib\minizip;$(OutDir);$(ProjectDir)\include\FMIL\ThirdParty;$(ProjectDir)\include\FMIL\CAPI;$(ProjectDir)\include\FMIL\Util;$(ProjectDir)include;$(IncludePath)</IncludePath>\r
+ <LibraryPath>$(OutDir);$(ProjectDir)include;$(LibraryPath)</LibraryPath>\r
+ <SourcePath>$(SourcePath)</SourcePath>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">\r
+ <LinkIncremental>false</LinkIncremental>\r
+ <IncludePath>$(SolutionDir)zlib-1.2.6\contrib\minizip;$(OutDir);$(ProjectDir)include;$(IncludePath)</IncludePath>\r
+ <LibraryPath>$(OutDir);$(ProjectDir)include;$(LibraryPath)</LibraryPath>\r
+ <SourcePath>$(SourcePath)</SourcePath>\r
+ </PropertyGroup>\r
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">\r
+ <LinkIncremental>false</LinkIncremental>\r
+ <IncludePath>$(SolutionDir)zlib-1.2.6\contrib\minizip;$(OutDir);$(ProjectDir)include;$(IncludePath)</IncludePath>\r
+ <LibraryPath>$(OutDir);$(ProjectDir)include;$(LibraryPath)</LibraryPath>\r
+ <SourcePath>$(SourcePath)</SourcePath>\r
+ </PropertyGroup>\r
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">\r
+ <ClCompile>\r
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>\r
+ <WarningLevel>Level3</WarningLevel>\r
+ <Optimization>Disabled</Optimization>\r
+ <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;FMUSIMULATOR_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>\r
+ </ClCompile>\r
+ <Link>\r
+ <SubSystem>Windows</SubSystem>\r
+ <GenerateDebugInformation>true</GenerateDebugInformation>\r
+ <AdditionalDependencies>$(OutDir)zlibwapi.lib;$(OutDir)miniunz.lib;fmilib_shared.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">\r
+ <ClCompile>\r
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>\r
+ <WarningLevel>Level3</WarningLevel>\r
+ <Optimization>Disabled</Optimization>\r
+ <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;FMUSIMULATOR_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>\r
+ </ClCompile>\r
+ <Link>\r
+ <SubSystem>Windows</SubSystem>\r
+ <GenerateDebugInformation>true</GenerateDebugInformation>\r
+ <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">\r
+ <ClCompile>\r
+ <WarningLevel>Level3</WarningLevel>\r
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>\r
+ <Optimization>MaxSpeed</Optimization>\r
+ <FunctionLevelLinking>\r
+ </FunctionLevelLinking>\r
+ <IntrinsicFunctions>false</IntrinsicFunctions>\r
+ <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;FMUSIMULATOR_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ <RuntimeLibrary>MultiThreaded</RuntimeLibrary>\r
+ <AdditionalIncludeDirectories>\r
+ </AdditionalIncludeDirectories>\r
+ </ClCompile>\r
+ <Link>\r
+ <SubSystem>Windows</SubSystem>\r
+ <GenerateDebugInformation>true</GenerateDebugInformation>\r
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>\r
+ <OptimizeReferences>true</OptimizeReferences>\r
+ <AdditionalDependencies>$(OutDir)zlibwapi.lib;$(OutDir)miniunz.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ </Link>\r
+ </ItemDefinitionGroup>\r
+ <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">\r
+ <ClCompile>\r
+ <WarningLevel>Level3</WarningLevel>\r
+ <PrecompiledHeader>NotUsing</PrecompiledHeader>\r
+ <Optimization>MaxSpeed</Optimization>\r
+ <FunctionLevelLinking>\r
+ </FunctionLevelLinking>\r
+ <IntrinsicFunctions>false</IntrinsicFunctions>\r
+ <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;FMUSIMULATOR_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>\r
+ <RuntimeLibrary>MultiThreaded</RuntimeLibrary>\r
+ <AdditionalIncludeDirectories>\r
+ </AdditionalIncludeDirectories>\r
+ </ClCompile>\r
+ <Link>\r
+ <SubSystem>Windows</SubSystem>\r
+ <GenerateDebugInformation>true</GenerateDebugInformation>\r
+ <EnableCOMDATFolding>true</EnableCOMDATFolding>\r
+ <OptimizeReferences>true</OptimizeReferences>\r
+ <AdditionalDependencies>$(OutDir)zlibwapi.lib;$(OutDir)miniunz.lib;%(AdditionalDependencies)</AdditionalDependencies>\r
+ </Link>\r
+ <Manifest>\r
+ <InputResourceManifests>\r
+ </InputResourceManifests>\r
+ </Manifest>\r
+ </ItemDefinitionGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="src\fmu_control.cpp" />\r
+ <ClCompile Include="src\sim_support.c" />\r
+ <ClCompile Include="src\stack.c" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="include\fmi1_cs.h" />\r
+ <ClInclude Include="include\fmiModelFunctions.h" />\r
+ <ClInclude Include="include\fmiModelTypes.h" />\r
+ <ClInclude Include="include\fmi_me.h" />\r
+ <ClInclude Include="include\jni.h" />\r
+ <ClInclude Include="include\org_simantics_fmil_FMILJNI.h" />\r
+ <ClInclude Include="include\sim_support.h" />\r
+ <ClInclude Include="include\xml_parser.h" />\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <Library Include="include\libexpatMT.lib" />\r
+ </ItemGroup>\r
+ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />\r
+ <ImportGroup Label="ExtensionTargets">\r
+ </ImportGroup>\r
+</Project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>\r
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
+ <ItemGroup>\r
+ <Filter Include="Source Files">\r
+ <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>\r
+ <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>\r
+ </Filter>\r
+ <Filter Include="Header Files">\r
+ <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>\r
+ <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>\r
+ </Filter>\r
+ <Filter Include="Resource Files">\r
+ <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>\r
+ <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>\r
+ </Filter>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClCompile Include="src\fmu_control.cpp">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="src\sim_support.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ <ClCompile Include="src\stack.c">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <ClInclude Include="include\sim_support.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="include\fmiModelFunctions.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="include\fmiModelTypes.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="include\fmi_me.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="include\xml_parser.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="include\fmi1_cs.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="include\jni.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="include\org_simantics_fmil_FMILJNI.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
+ </ItemGroup>\r
+ <ItemGroup>\r
+ <Library Include="include\libexpatMT.lib">\r
+ <Filter>Resource Files</Filter>\r
+ </Library>\r
+ </ItemGroup>\r
+</Project>
\ No newline at end of file
--- /dev/null
+/*\r
+ Copyright (C) 2012 Modelon AB\r
+\r
+ This program is free software: you can redistribute it and/or modify\r
+ it under the terms of the BSD style license.\r
+\r
+ This program is distributed in the hope that it will be useful,\r
+ but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
+ FMILIB_License.txt file for more details.\r
+\r
+ You should have received a copy of the FMILIB_License.txt file\r
+ along with this program. If not, contact Modelon AB <http://www.modelon.com>.\r
+*/\r
+\r
+#include <assert.h>\r
+#include <string.h>\r
+#include <stdio.h>\r
+#include <FMI/fmi_util.h>\r
+#include <FMI/fmi_zip_unzip.h>\r
+\r
+char* fmi_construct_dll_dir_name(jm_callbacks* callbacks, const char* fmu_unzipped_path) {\r
+ char* dir_path;\r
+ size_t len;\r
+\r
+ assert( fmu_unzipped_path && callbacks);\r
+\r
+ len = \r
+ strlen(fmu_unzipped_path) + strlen(FMI_FILE_SEP)\r
+ + strlen(FMI_BINARIES) + strlen(FMI_FILE_SEP) \r
+ + strlen(FMI_PLATFORM) + strlen(FMI_FILE_SEP) + 1;\r
+\r
+ dir_path = (char*)callbacks->malloc(len);\r
+ if (dir_path == NULL) {\r
+ jm_log_fatal(callbacks, "FMIUT", "Failed to allocate memory.");\r
+ return NULL;\r
+ }\r
+\r
+ sprintf(dir_path, "%s%s%s%s%s%s", fmu_unzipped_path, FMI_FILE_SEP, FMI_BINARIES, FMI_FILE_SEP, FMI_PLATFORM, FMI_FILE_SEP);/*safe */\r
+\r
+ return dir_path;\r
+}\r
+\r
+char* fmi_construct_dll_file_name(jm_callbacks* callbacks, const char* dll_dir_name, const char* model_identifier) {\r
+ char* fname;\r
+ size_t len;\r
+ assert(callbacks && model_identifier);\r
+ len = \r
+ strlen(dll_dir_name) +\r
+ strlen(model_identifier) \r
+ + strlen(FMI_DLL_EXT) + 1;\r
+ fname = (char*)callbacks->malloc(len);\r
+ if (fname == NULL) {\r
+ jm_log_fatal(callbacks, "FMIUT", "Failed to allocate memory.");\r
+ return NULL;\r
+ }\r
+ sprintf(fname, "%s%s%s", dll_dir_name, model_identifier, FMI_DLL_EXT);/*safe */\r
+\r
+ return fname;\r
+}\r
+\r
+\r
+////\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <stdarg.h>\r
+#include <string.h>\r
+#include <errno.h>\r
+\r
+#include <fmilib.h>\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+typedef struct {\r
+ char *name;\r
+ long vr;\r
+} FMIL_Variable;\r
+\r
+__declspec(dllexport) void* FMI1_CS_LOAD(const char *zipFilePath, const char *unzipFolder);\r
+__declspec(dllexport) int FMI1_CS_UNLOAD(void* fmu);\r
+__declspec(dllexport) FMIL_Variable *FMI1_CS_GET_VARIABLES(void* fmu, int *count);\r
+__declspec(dllexport) int FMI1_CS_INSTANTIATE(void* fmu);\r
+__declspec(dllexport) int FMI1_CS_INITIALIZE(void* fmu);\r
+__declspec(dllexport) int FMI1_CS_STEP(void* fmu, double masterTime, double stepSize);\r
+__declspec(dllexport) int FMI1_CS_SET_REAL(void* fmu, int vr, double value);\r
+__declspec(dllexport) double FMI1_CS_GET_REAL(void* fmu, int vr);\r
+__declspec(dllexport) int FMI1_CS_GET_REALS(void* fmu, int *vrs, double *values, int count);\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+#define BUFFER 4096\r
+\r
+/* Logger function used by the C-API */\r
+void importlogger(jm_callbacks* c, jm_string module, jm_log_level_enu_t log_level, jm_string message)\r
+{\r
+ printf("module = %s, log level = %d: %s\n", module, log_level, message);\r
+}\r
+\r
+/* Logger function used by the FMU internally */\r
+void fmilogger(fmi1_component_t c, fmi1_string_t instanceName, fmi1_status_t status, fmi1_string_t category, fmi1_string_t message, ...)\r
+{\r
+ char msg[BUFFER];\r
+ int len;\r
+ va_list argp; \r
+ va_start(argp, message);\r
+ /*len=jm_vsnprintf(msg, BUFFER, message, argp);\r
+ printf("fmiStatus = %d; %s (%s): %s\n", status, instanceName, category, msg);\r
+ if(len > BUFFER) {\r
+ printf("Warning: message was trancated");\r
+ }*/\r
+}\r
+\r
+void *FMI1_CS_LOAD(char *zipFilePath, char *unzipFolder) {\r
+\r
+ fmi1_callback_functions_t callBackFunctions;\r
+ fmi_import_context_t* context;\r
+ fmi1_fmu_kind_enu_t standard = fmi1_fmu_kind_enu_cs_standalone; \r
+ fmi_version_enu_t version;\r
+ jm_status_enu_t status;\r
+ fmi1_import_t *fmu;\r
+ jm_callbacks* callbacks;\r
+\r
+ callbacks = (jm_callbacks *)calloc(1, sizeof(jm_callbacks));\r
+\r
+ callbacks->malloc = malloc;\r
+ callbacks->calloc = calloc;\r
+ callbacks->realloc = realloc;\r
+ callbacks->free = free;\r
+ callbacks->logger = importlogger;\r
+ callbacks->log_level = jm_log_level_debug;\r
+ callbacks->context = 0;\r
+\r
+ callBackFunctions.logger = fmilogger;\r
+ callBackFunctions.allocateMemory = calloc;\r
+ callBackFunctions.freeMemory = free;\r
+\r
+ context = fmi_import_allocate_context(callbacks);\r
+\r
+ version = fmi_import_get_fmi_version(context, zipFilePath, unzipFolder);\r
+\r
+ fmu = fmi1_import_parse_xml(context, unzipFolder);\r
+\r
+ status = fmi1_import_create_dllfmu(fmu, callBackFunctions, 0);\r
+\r
+ fmi_import_free_context(context);\r
+\r
+ return fmu;\r
+\r
+}\r
+\r
+int FMI1_CS_UNLOAD(void *fmu_) {\r
+\r
+ fmi1_import_t *fmu = (fmi1_import_t *)fmu_;\r
+\r
+ fmi1_import_destroy_dllfmu(fmu);\r
+\r
+ fmi1_import_free(fmu);\r
+\r
+ return 1;\r
+\r
+}\r
+\r
+\r
+FMIL_Variable *FMI1_CS_GET_VARIABLES(void *fmu, int *count) {\r
+\r
+ int i;\r
+ FMIL_Variable *result;\r
+ fmi1_import_variable_list_t* vl = fmi1_import_get_variable_list((fmi1_import_t *)fmu);\r
+\r
+ count[0] = fmi1_import_get_variable_list_size(vl);\r
+\r
+ result = (FMIL_Variable *)malloc(count[0]*sizeof(FMIL_Variable));\r
+\r
+ for(i = 0; i < count[0]; i++) {\r
+\r
+ fmi1_import_variable_t* var = fmi1_import_get_variable(vl, i);\r
+ if(!var) {\r
+\r
+ printf("Something wrong with variable %d \n",i);\r
+ return 0;\r
+\r
+ } else {\r
+\r
+ fmi1_base_type_enu_t bt;\r
+ result[i].name = fmi1_import_get_variable_name(var);\r
+ result[i].vr = fmi1_import_get_variable_vr(var);\r
+\r
+ }\r
+\r
+ }\r
+\r
+ fmi1_import_free_variable_list(vl);\r
+\r
+ return result;\r
+\r
+}\r
+\r
+#define INSTANCE_NAME "kekkeli"\r
+\r
+int FMI1_CS_INSTANTIATE(void *fmu) {\r
+\r
+ fmi1_string_t fmuLocation;\r
+ fmi1_string_t mimeType;\r
+ fmi1_real_t timeout;\r
+ fmi1_boolean_t visible;\r
+ fmi1_boolean_t interactive;\r
+ fmi1_boolean_t loggingOn;\r
+\r
+ fmuLocation = "";\r
+ mimeType = "";\r
+ timeout = 0;\r
+ visible = fmi1_false;\r
+ interactive = fmi1_false;\r
+ loggingOn = fmi1_true;\r
+\r
+ if (fmi1_import_instantiate_slave(fmu, INSTANCE_NAME, NULL, NULL, timeout, fmi1_false, fmi1_false) == NULL) { \r
+ printf("fmi1_capi_instantiate_slave: Failed\n");\r
+ return 0;\r
+ } else {\r
+ printf("fmi1_capi_instantiate_slave: Success\n");\r
+ }\r
+ return 0;\r
+\r
+}\r
+\r
+int FMI1_CS_INITIALIZE(void *fmu) {\r
+\r
+ fmi1_status_t status;\r
+ fmi1_real_t tStart;\r
+ fmi1_real_t tStop;\r
+ fmi1_boolean_t StopTimeDefined;\r
+\r
+ tStart = 0;\r
+ tStop = 10;\r
+ StopTimeDefined = fmi1_false;\r
+\r
+ status = fmi1_import_initialize_slave((fmi1_import_t *)fmu, tStart, StopTimeDefined, tStop);\r
+ if (status == fmi1_status_error || status == fmi1_status_fatal) {\r
+ printf("fmi1_capi_initialize_slave: Failed\n");\r
+ return 0;\r
+ } else {\r
+ printf("fmi1_capi_initialize_slave: Success\n");\r
+ }\r
+ return 0;\r
+\r
+}\r
+\r
+int FMI1_CS_STEP(void *fmu, double masterTime, double stepSize) {\r
+\r
+ fmi1_status_t status;\r
+\r
+ status = fmi1_import_do_step((fmi1_import_t *)fmu, (fmi1_real_t)masterTime, (fmi1_real_t)stepSize, fmi1_true);\r
+ if (status == fmi1_status_error || status == fmi1_status_fatal) {\r
+ printf("fmi1_capi_do_step: Failed\n");\r
+ return 0;\r
+ } else {\r
+ printf("fmi1_capi_do_step: Success\n");\r
+ }\r
+\r
+ return 0;\r
+\r
+}\r
+\r
+int FMI1_CS_SET_REAL(void *fmu, long valueId, double value) {\r
+\r
+ fmi1_value_reference_t vr = valueId;\r
+ fmi1_import_set_real((fmi1_import_t *)fmu, &vr, 1, &value);\r
+\r
+ return 0;\r
+\r
+}\r
+\r
+double FMI1_CS_GET_REAL(void *fmu, int valueReference) {\r
+\r
+ fmi1_value_reference_t vr = valueReference;\r
+ fmi1_real_t value;\r
+ fmi1_import_get_real((fmi1_import_t *)fmu, &vr, 1, &value);\r
+ return value;\r
+\r
+}\r
+\r
+int FMI1_CS_GET_REALS(void *fmu, int *valueReferences, double *result, int count) {\r
+\r
+ fmi1_value_reference_t *vrs = valueReferences;\r
+ fmi1_real_t value;\r
+ fmi1_import_get_real((fmi1_import_t *)fmu, vrs, count, result);\r
+ return 1;\r
+\r
+}\r
--- /dev/null
+Files expat.h, expat_external.h and libexpatMT.lib\r
+\r
+Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd\r
+ and Clark Cooper\r
+Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Expat maintainers.\r
+\r
+Permission is hereby granted, free of charge, to any person obtaining\r
+a copy of this software and associated documentation files (the\r
+"Software"), to deal in the Software without restriction, including\r
+without limitation the rights to use, copy, modify, merge, publish,\r
+distribute, sublicense, and/or sell copies of the Software, and to\r
+permit persons to whom the Software is furnished to do so, subject to\r
+the following conditions:\r
+\r
+The above copyright notice and this permission notice shall be included\r
+in all copies or substantial portions of the Software.\r
+\r
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\r
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\r
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\r
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\r
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
--- /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>.
+*/
+
+
+#ifndef FMI1_CAPI_H_
+#define FMI1_CAPI_H_
+
+#include <FMI1/fmi1_types.h>
+#include <FMI1/fmi1_functions.h>
+#include <FMI1/fmi1_enums.h>
+#include <JM/jm_portability.h>
+#include <JM/jm_callbacks.h>
+\r
+typedef struct fmi1_capi_t fmi1_capi_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \file fmi1_capi.h
+ \brief Public interfaces for the FMI CAPI library.
+ */
+
+/** \addtogroup fmi1_capi Standard FMI 1.0 "C" API\r
+ * \brief The "C" API loads and frees the FMI functions and it is through theise functions all the communcation with the FMU occures. The FMI import library wrappes these functions in a more convenient way.\r
+ * @{\r
+ */
+
+/** \addtogroup fmi1_capi_const_destroy FMI 1.0 Utility functions\r
+ * \brief Utility functions used to load and free the FMI functions.\r
+ * \addtogroup fmi1_capi_me FMI 1.0 (ME) Model Exchange functions\r
+ * \brief List of Model Exchange wrapper functions. Common functions are not listed.\r
+ * \addtogroup fmi1_capi_cs FMI 1.0 (CS) Co-Simulation functions \r
+ * \brief List of Co-Simulation wrapper functions. Common functions are not listed.\r
+ * \addtogroup fmi1_capi_common FMI 1.0 (ME & CS) Common functions\r
+ * \brief List of wrapper functions that are in common for both Model Exchange and Co-Simulation.\r
+ */
+
+
+/** \addtogroup fmi1_capi_const_destroy\r
+ * @{\r
+ */
+
+/**\r
+ * \brief Free a C-API struct. All memory allocated since the struct was created is freed.\r
+ * \r
+ * @param fmu A model description object returned by fmi1_import_allocate.\r
+ */
+void fmi1_capi_destroy_dllfmu(fmi1_capi_t* fmu);
+
+/**\r
+ * \brief Create a C-API struct. The C-API struct is a placeholder for the FMI DLL functions.\r
+ * \r
+ * @param callbacks ::jm_callbacks used to construct library objects.\r
+ * @param dllPath Full path to the FMU shared library.\r
+ * @param modelIdentifier The model indentifier.\r
+ * @param standard FMI standard that the function should load.\r
+ * @param callBackFunctions callbacks passed to the FMU.\r
+ * @return Error status. If the function returns with an error, it is not allowed to call any of the other C-API functions.\r
+ */
+fmi1_capi_t* fmi1_capi_create_dllfmu(jm_callbacks* callbacks, const char* dllPath, const char* modelIdentifier, fmi1_callback_functions_t callBackFunctions, fmi1_fmu_kind_enu_t standard);
+
+/**\r
+ * \brief Loads the FMI functions from the shared library. The shared library must be loaded before this function can be called, see fmi1_import_create_dllfmu().\r
+ * \r
+ * @param fmu A model description object returned by fmi1_import_allocate.\r
+ * @return Error status. If the function returns with an error, no other C-API functions than fmi1_import_free_dll and fmi1_import_destroy_dllfmu are allowed to be called.\r
+ */
+jm_status_enu_t fmi1_capi_load_fcn(fmi1_capi_t* fmu);
+
+/**\r
+ * \brief Loads the FMU´s shared library. The shared library functions are not loaded in this call, see fmi1_import_create_dllfmu.\r
+ * \r
+ * @param fmu A model description object returned by fmi1_import_allocate.\r
+ * @return Error status. If the function returns with an error, no other C-API functions than fmi1_import_destroy_dllfmu are allowed to be called.\r
+ */
+jm_status_enu_t fmi1_capi_load_dll(fmi1_capi_t* fmu);
+
+/**\r
+ * \brief Frees the handle to the FMU´s shared library. After this function returnes, no other C-API functions than fmi1_import_destroy_dllfmu and fmi1_import_create_dllfmu are allowed to be called.\r
+ * \r
+ * @param fmu A model description object returned by fmi1_import_allocate that has loaded the FMU´s shared library, see fmi1_import_load_dll.\r
+ * @return Error status.\r
+ */
+jm_status_enu_t fmi1_capi_free_dll(fmi1_capi_t* fmu);
+
+/**\r
+ * \brief Set CAPI debug mode flag. Setting to non-zero prevents DLL unloading in fmi1_capi_free_dll\r
+ * while all the memory is deallocated. This is to support valgrind debugging. \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param mode The debug mode to set.\r
+ */\r
+void fmi1_capi_set_debug_mode(fmi1_capi_t* fmu, int mode);
+
+/**\r
+ * \brief Get CAPI debug mode flag that was set with fmi1_capi_set_debug_mode()\r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function. */\r
+int fmi1_capi_get_debug_mode(fmi1_capi_t* fmu);
+
+
+/**@} */
+
+/** \addtogroup fmi1_capi_common\r
+ * @{\r
+ */
+
+/**\r
+ * \brief Calls the FMI function fmiGetVersion() \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @return FMI version.\r
+ */
+const char* fmi1_capi_get_version(fmi1_capi_t* fmu);
+
+/**\r
+ * \brief Calls the FMI function fmiSetDebugLogging(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param loggingOn Enable or disable the debug logger.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_set_debug_logging(fmi1_capi_t* fmu, fmi1_boolean_t loggingOn);
+
+/**\r
+ * \brief Calls the FMI function fmiSetReal(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_set_real(fmi1_capi_t* fmu, const fmi1_value_reference_t vr[], size_t nvr, const fmi1_real_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiSetInteger(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_set_integer(fmi1_capi_t* fmu, const fmi1_value_reference_t vr[], size_t nvr, const fmi1_integer_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiSetBoolean(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_set_boolean(fmi1_capi_t* fmu, const fmi1_value_reference_t vr[], size_t nvr, const fmi1_boolean_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiSetString(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_set_string(fmi1_capi_t* fmu, const fmi1_value_reference_t vr[], size_t nvr, const fmi1_string_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiGetReal(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value (Output)Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_real(fmi1_capi_t* fmu, const fmi1_value_reference_t vr[], size_t nvr, fmi1_real_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiGetInteger(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value (Output)Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_integer(fmi1_capi_t* fmu, const fmi1_value_reference_t vr[], size_t nvr, fmi1_integer_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiGetBoolean(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value (Output)Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_boolean(fmi1_capi_t* fmu, const fmi1_value_reference_t vr[], size_t nvr, fmi1_boolean_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiGetString(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value (Output)Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_string(fmi1_capi_t* fmu, const fmi1_value_reference_t vr[], size_t nvr, fmi1_string_t value[]);
+
+/**@} */
+
+/** \addtogroup fmi1_capi_me\r
+ * @{\r
+ */
+
+/**\r
+ * \brief Calls the FMI function fmiGetModelTypesPlatform(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @return The platform the FMU was compiled for.\r
+ */
+const char* fmi1_capi_get_model_types_platform(fmi1_capi_t* fmu);
+
+/**\r
+ * \brief Calls the FMI function fmiInstantiateModel(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param instanceName The name of the instance.\r
+ * @param GUID The GUID identifier.\r
+ * @param loggingOn Enable or disable the debug logger.\r
+ * @return An instance of a model.\r
+ */
+fmi1_component_t fmi1_capi_instantiate_model(fmi1_capi_t* fmu, fmi1_string_t instanceName, fmi1_string_t GUID, fmi1_boolean_t loggingOn);
+
+/**\r
+ * \brief Calls the FMI function fmiFreeModelInstance(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ */
+void fmi1_capi_free_model_instance(fmi1_capi_t* fmu);
+
+/**\r
+ * \brief Calls the FMI function fmiSetTime(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param time Set the current time.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_set_time(fmi1_capi_t* fmu, fmi1_real_t time);
+
+/**\r
+ * \brief Calls the FMI function fmiSetContinuousStates(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param x Array of state values.\r
+ * @param nx Number of states.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_set_continuous_states(fmi1_capi_t* fmu, const fmi1_real_t x[], size_t nx);
+
+/**\r
+ * \brief Calls the FMI function fmiCompletedIntegratorStep(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param callEventUpdate (Output) Call fmiEventUpdate indicator.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_completed_integrator_step(fmi1_capi_t* fmu, fmi1_boolean_t* callEventUpdate);
+
+/**\r
+ * \brief Calls the FMI function fmiInitialize(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param toleranceControlled Enable or disable the use of relativeTolerance in the FMU.\r
+ * @param relativeTolerance A relative tolerance used in the FMU.\r
+ * @param eventInfo (Output) fmiEventInfo struct.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_initialize(fmi1_capi_t* fmu, fmi1_boolean_t toleranceControlled, fmi1_real_t relativeTolerance, fmi1_event_info_t* eventInfo);
+
+/**\r
+ * \brief Calls the FMI function fmiGetDerivatives(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param derivatives (Output) Array of the derivatives.\r
+ * @param nx Number of derivatives.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_derivatives(fmi1_capi_t* fmu, fmi1_real_t derivatives[] , size_t nx);
+
+/**\r
+ * \brief Calls the FMI function fmiGetEventIndicators(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param eventIndicators (Output) The event indicators.\r
+ * @param ni Number of event indicators.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_event_indicators(fmi1_capi_t* fmu, fmi1_real_t eventIndicators[], size_t ni);
+
+/**\r
+ * \brief Calls the FMI function fmiEventUpdate(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param intermediateResults Indicate whether or not the fmiEventUpdate shall return after every internal event interation.\r
+ * @param eventInfo (Output) An fmiEventInfo struct.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_eventUpdate(fmi1_capi_t* fmu, fmi1_boolean_t intermediateResults, fmi1_event_info_t* eventInfo);
+
+/**\r
+ * \brief Calls the FMI function fmiGetContinuousStates(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param states (Output) Array of state values.\r
+ * @param nx Number of states.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_continuous_states(fmi1_capi_t* fmu, fmi1_real_t states[], size_t nx);
+
+/**\r
+ * \brief Calls the FMI function fmiGetNominalContinuousStates(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param x_nominal (Output) The nominal values.\r
+ * @param nx Number of nominal values.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_nominal_continuous_states(fmi1_capi_t* fmu, fmi1_real_t x_nominal[], size_t nx);
+
+/**\r
+ * \brief Calls the FMI function fmiGetStateValueReferences(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vrx (Output) The value-references of the states.\r
+ * @param nx Number of value-references.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_state_value_references(fmi1_capi_t* fmu, fmi1_value_reference_t vrx[], size_t nx);
+
+/**\r
+ * \brief Calls the FMI function fmiTerminate(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_terminate(fmi1_capi_t* fmu);
+
+/**@} */
+
+/** \addtogroup fmi1_capi_cs\r
+ * @{\r
+ */
+
+/**\r
+ * \brief Calls the FMI function fmiGetTypesPlatform(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @return The platform the FMU was compiled for.\r
+ */
+const char* fmi1_capi_get_types_platform(fmi1_capi_t* fmu);
+/**\r
+ * \brief Calls the FMI function fmiInstantiateSlave(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param instanceName The name of the instance.\r
+ * @param fmuGUID The GUID identifier.\r
+ * @param fmuLocation Access path to the FMU archive.\r
+ * @param mimeType MIME type.\r
+ * @param timeout Communication timeout value in milli-seconds.\r
+ * @param visible Indicates whether or not the simulator application window shoule be visible.\r
+ * @param interactive Indicates whether the simulator application must be manually started by the user.\r
+ * @param loggingOn Enable or disable the debug logger.\r
+ * @return An instance of a model.\r
+ */
+fmi1_component_t fmi1_capi_instantiate_slave(fmi1_capi_t* fmu, fmi1_string_t instanceName, fmi1_string_t fmuGUID, fmi1_string_t fmuLocation, fmi1_string_t mimeType,
+ fmi1_real_t timeout, fmi1_boolean_t visible, fmi1_boolean_t interactive, fmi1_boolean_t loggingOn);
+/**\r
+ * \brief Calls the FMI function fmiInitializeSlave(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param tStart Start time of the simulation\r
+ * @param StopTimeDefined Indicates whether or not the stop time is used.\r
+ * @param tStop The stop time of the simulation.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_initialize_slave(fmi1_capi_t* fmu, fmi1_real_t tStart, fmi1_boolean_t StopTimeDefined, fmi1_real_t tStop);
+
+/**\r
+ * \brief Calls the FMI function fmiTerminateSlave(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_terminate_slave(fmi1_capi_t* fmu);
+
+/**\r
+ * \brief Calls the FMI function fmiResetSlave(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_reset_slave(fmi1_capi_t* fmu);
+
+/**\r
+ * \brief Calls the FMI function fmiFreeSlaveInstance(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ */
+void fmi1_capi_free_slave_instance(fmi1_capi_t* fmu);
+
+/**\r
+ * \brief Calls the FMI function fmiSetRealInputDerivatives(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully load the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param order Array of derivative orders.\r
+ * @param value Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_set_real_input_derivatives(fmi1_capi_t* fmu, const fmi1_value_reference_t vr[], size_t nvr, const fmi1_integer_t order[], const fmi1_real_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiGetOutputDerivatives(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param order Array of derivative orders.\r
+ * @param value (Output) Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_real_output_derivatives(fmi1_capi_t* fmu, const fmi1_value_reference_t vr[], size_t nvr, const fmi1_integer_t order[], fmi1_real_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiCancelStep(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_cancel_step(fmi1_capi_t* fmu);
+
+/**\r
+ * \brief Calls the FMI function fmiDoStep(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param currentCommunicationPoint Current communication point of the master.\r
+ * @param communicationStepSize Communication step size.\r
+ * @param newStep Indicates whether or not the last communication step was accepted by the master.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_do_step(fmi1_capi_t* fmu, fmi1_real_t currentCommunicationPoint, fmi1_real_t communicationStepSize, fmi1_boolean_t newStep);
+
+/**\r
+ * \brief Calls the FMI function fmiGetStatus(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param s Kind of status to return the value for.\r
+ * @param value (Output) FMI status value.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_status(fmi1_capi_t* fmu, const fmi1_status_kind_t s, fmi1_status_t* value);
+
+/**\r
+ * \brief Calls the FMI function fmiGetRealStatus(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param s Kind of status to return the value for.\r
+ * @param value (Output) FMI real value.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_real_status(fmi1_capi_t* fmu, const fmi1_status_kind_t s, fmi1_real_t* value);
+\r
+/**\r
+ * \brief Calls the FMI function fmiGetIntegerStatus(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param s Kind of status to return the value for.\r
+ * @param value (Output) FMI integer value.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_integer_status(fmi1_capi_t* fmu, const fmi1_status_kind_t s, fmi1_integer_t* value);
+
+/**\r
+ * \brief Calls the FMI function fmiGetBooleanStatus(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param s Kind of status to return the value for.\r
+ * @param value (Output) FMI boolean value.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_boolean_status(fmi1_capi_t* fmu, const fmi1_status_kind_t s, fmi1_boolean_t* value);
+
+/**\r
+ * \brief Calls the FMI function fmiGetStringStatus(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param s Kind of status to return the value for.\r
+ * @param value (Output) FMI string value.\r
+ * @return FMI status.\r
+ */
+fmi1_status_t fmi1_capi_get_string_status(fmi1_capi_t* fmu, const fmi1_status_kind_t s, fmi1_string_t* value);
+
+/** @}*/
+/** @}*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* End of header file FMI1_CAPI_H_ */
--- /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>.
+*/
+
+
+#ifndef FMI2_CAPI_H_
+#define FMI2_CAPI_H_
+
+#include <FMI2/fmi2_types.h>
+#include <FMI2/fmi2_functions.h>
+#include <FMI2/fmi2_enums.h>
+#include <JM/jm_portability.h>
+#include <JM/jm_callbacks.h>
+\r
+typedef struct fmi2_capi_t fmi2_capi_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \file fmi2_capi.h
+ \brief Public interfaces for the FMI CAPI library.
+ */
+
+/** \addtogroup fmi2_capi Standard FMI 2.0 "C" API\r
+ * \brief The "C" API loads and frees the FMI functions and it is through these functions all the communication with the FMU occurs. The FMI import library wraps these functions in a more convenient way.\r
+ * @{\r
+ */
+
+/** \addtogroup fmi2_capi_const_destroy FMI 2.0 Utility functions\r
+ * \brief Utility functions used to load and free the FMI functions.\r
+ * \addtogroup fmi2_capi_me FMI 2.0 (ME) Model Exchange functions\r
+ * \brief List of Model Exchange wrapper functions. Common functions are not listed.\r
+ * \addtogroup fmi2_capi_cs FMI 2.0 (CS) Co-Simulation functions \r
+ * \brief List of Co-Simulation wrapper functions. Common functions are not listed.\r
+ * \addtogroup fmi2_capi_common FMI 2.0 (ME & CS) Common functions\r
+ * \brief List of wrapper functions that are in common for both Model Exchange and Co-Simulation.\r
+ */
+
+
+/** \addtogroup fmi2_capi_const_destroy\r
+ * @{\r
+ */
+
+/**\r
+ * \brief Free a C-API struct. All memory allocated since the struct was created is freed.\r
+ * \r
+ * @param fmu A model description object returned by fmi2_import_allocate.\r
+ */
+void fmi2_capi_destroy_dllfmu(fmi2_capi_t* fmu);
+
+/**\r
+ * \brief Create a C-API struct. The C-API struct is a placeholder for the FMI DLL functions.\r
+ * \r
+ * @param callbacks ::jm_callbacks used to construct library objects.\r
+ * @param dllPath Full path to the FMU shared library.\r
+ * @param modelIdentifier The model indentifier.\r
+ * @param standard FMI standard that the function should load.\r
+ * @param callBackFunctions callbacks passed to the FMU.\r
+ * @return Error status. If the function returns with an error, it is not allowed to call any of the other C-API functions.\r
+ */
+fmi2_capi_t* fmi2_capi_create_dllfmu(jm_callbacks* callbacks, const char* dllPath, const char* modelIdentifier, const fmi2_callback_functions_t* callBackFunctions, fmi2_fmu_kind_enu_t standard);
+
+/**\r
+ * \brief Loads the FMI functions from the shared library. The shared library must be loaded before this function can be called, see fmi2_import_create_dllfmu.\r
+ * \r
+ * @param fmu A model description object returned by fmi2_import_allocate.\r
+ * @param capabilities An array of capability flags according to fmi2_capabilities_enu_t order.\r
+ * @return Error status. If the function returns with an error, no other C-API functions than fmi2_import_free_dll and fmi2_import_destroy_dllfmu are allowed to be called.\r
+ */
+jm_status_enu_t fmi2_capi_load_fcn(fmi2_capi_t* fmu, unsigned int capabilities[]);
+
+/**\r
+ * \brief Loads the FMU´s shared library. The shared library functions are not loaded in this call, see fmi2_import_create_dllfmu.\r
+ * \r
+ * @param fmu A model description object returned by fmi2_import_allocate.\r
+ * @return Error status. If the function returns with an error, no other C-API functions than fmi2_import_destroy_dllfmu are allowed to be called.\r
+ */
+jm_status_enu_t fmi2_capi_load_dll(fmi2_capi_t* fmu);
+
+/**\r
+ * \brief Frees the handle to the FMU´s shared library. After this function returnes, no other C-API functions than fmi2_import_destroy_dllfmu and fmi2_import_create_dllfmu are allowed to be called.\r
+ * \r
+ * @param fmu A model description object returned by fmi2_import_allocate that has loaded the FMU´s shared library, see fmi2_import_create_dllfmu.\r
+ * @return Error status.\r
+ */
+jm_status_enu_t fmi2_capi_free_dll(fmi2_capi_t* fmu);
+\r
+/**\r
+ * \brief Set CAPI debug mode flag. Setting to non-zero prevents DLL unloading in fmi1_capi_free_dll\r
+ * while all the memory is deallocated. This is to support valgrind debugging. \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param mode The debug mode to set.\r
+ */\r
+void fmi2_capi_set_debug_mode(fmi2_capi_t* fmu, int mode);
+
+/**\r
+ * \brief Get CAPI debug mode flag that was set with fmi1_capi_set_debug_mode()\r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function. */\r
+int fmi2_capi_get_debug_mode(fmi2_capi_t* fmu);
+
+/**\r
+ * \brief Get the FMU kind loaded by the CAPI\r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function. */\r
+fmi2_fmu_kind_enu_t fmi2_capi_get_fmu_kind(fmi2_capi_t* fmu);
+
+
+/**@} */
+
+/** \addtogroup fmi2_capi_common\r
+ * @{\r
+ */
+
+/**\r
+ * \brief Calls the FMI function fmiGetVersion() \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @return FMI version.\r
+ */
+const char* fmi2_capi_get_version(fmi2_capi_t* fmu);
+
+/**\r
+ * \brief Calls the FMI function fmiSetDebugLogging(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param loggingOn Enable or disable the debug logger.\r
+ * @param nCategories Number of categories to log.\r
+ * @param categories Which categories to log.\r
+ *\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_set_debug_logging(fmi2_capi_t* fmu, fmi2_boolean_t loggingOn, size_t nCategories, fmi2_string_t categories[]);
+
+/**
+ * \brief Calls the FMI function fmiInstantiate(...)
+ *
+ * @param fmu C-API struct that has succesfully loaded the FMI function.
+ * @param instanceName The name of the instance.
+ * @param fmuType fmi2_model_exchange or fmi2_cosimulation.
+ * @param fmuGUID The GUID identifier.
+ * @param fmuResourceLocation Access path to the FMU archive resources.
+ * @param visible Indicates whether or not the simulator application window shoule be visible.
+ * @param loggingOn Enable or disable the debug logger.
+ * @return An instance of a model.
+ */
+fmi2_component_t fmi2_capi_instantiate(fmi2_capi_t* fmu,
+ fmi2_string_t instanceName, fmi2_type_t fmuType, fmi2_string_t fmuGUID,
+ fmi2_string_t fmuResourceLocation, fmi2_boolean_t visible,
+ fmi2_boolean_t loggingOn);
+
+/**\r
+ * \brief Calls the FMI function fmiFreeInstance(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ */
+void fmi2_capi_free_instance(fmi2_capi_t* fmu);
+
+
+/**
+ * \brief Calls the FMI function fmiSetupExperiment(...)
+ *
+ * @param fmu C-API struct that has succesfully loaded the FMI function.
+ * @param toleranceDefined True if the @p tolerance argument is to be used
+ * @param tolerance Solvers internal to the FMU should use this tolerance or finer, if @p toleranceDefined is true
+ * @param startTime Start time of the experiment
+ * @param stopTimeDefined True if the @p stopTime argument is to be used
+ * @param stopTime Stop time of the experiment, if @p stopTimeDefined is true
+ * @return FMI status.
+ */
+fmi2_status_t fmi2_capi_setup_experiment(fmi2_capi_t* fmu,
+ fmi2_boolean_t toleranceDefined, fmi2_real_t tolerance,
+ fmi2_real_t startTime, fmi2_boolean_t stopTimeDefined,
+ fmi2_real_t stopTime);
+
+/**
+ * \brief Calls the FMI function fmiEnterInitializationMode(...)
+ *
+ * @param fmu C-API struct that has succesfully loaded the FMI function.
+ * @return FMI status.
+ */
+fmi2_status_t fmi2_capi_enter_initialization_mode(fmi2_capi_t* fmu);
+
+/**
+ * \brief Calls the FMI function fmiExitInitializationMode(...)
+ *
+ * @param fmu C-API struct that has succesfully loaded the FMI function.
+ * @return FMI status.
+ */
+fmi2_status_t fmi2_capi_exit_initialization_mode(fmi2_capi_t* fmu);
+
+/**
+ * \brief Calls the FMI function fmiTerminate(...)
+ *
+ * @param fmu C-API struct that has succesfully loaded the FMI function.
+ * @return FMI status.
+ */
+fmi2_status_t fmi2_capi_terminate(fmi2_capi_t* fmu);
+
+/**
+ * \brief Calls the FMI function fmiReset(...)
+ *
+ * @param fmu C-API struct that has succesfully loaded the FMI function.
+ * @return FMI status.
+ */
+fmi2_status_t fmi2_capi_reset(fmi2_capi_t* fmu);
+
+
+/**\r
+ * \brief Calls the FMI function fmiSetReal(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_set_real(fmi2_capi_t* fmu, const fmi2_value_reference_t vr[], size_t nvr, const fmi2_real_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiSetInteger(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_set_integer(fmi2_capi_t* fmu, const fmi2_value_reference_t vr[], size_t nvr, const fmi2_integer_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiSetBoolean(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_set_boolean(fmi2_capi_t* fmu, const fmi2_value_reference_t vr[], size_t nvr, const fmi2_boolean_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiSetString(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_set_string(fmi2_capi_t* fmu, const fmi2_value_reference_t vr[], size_t nvr, const fmi2_string_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiGetReal(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value (Output)Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_real(fmi2_capi_t* fmu, const fmi2_value_reference_t vr[], size_t nvr, fmi2_real_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiGetInteger(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value (Output)Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_integer(fmi2_capi_t* fmu, const fmi2_value_reference_t vr[], size_t nvr, fmi2_integer_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiGetBoolean(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value (Output)Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_boolean(fmi2_capi_t* fmu, const fmi2_value_reference_t vr[], size_t nvr, fmi2_boolean_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiGetString(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param value (Output)Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_string(fmi2_capi_t* fmu, const fmi2_value_reference_t vr[], size_t nvr, fmi2_string_t value[]);
+
+
+/**\r
+ * \brief Calls the FMI function fmiGetTypesPlatform(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @return The platform the FMU was compiled for.\r
+ */
+const char* fmi2_capi_get_types_platform(fmi2_capi_t* fmu);
+\r
+fmi2_status_t fmi2_capi_get_fmu_state (fmi2_capi_t* fmu, fmi2_FMU_state_t* s);\r
+fmi2_status_t fmi2_capi_set_fmu_state (fmi2_capi_t* fmu, fmi2_FMU_state_t s);\r
+fmi2_status_t fmi2_capi_free_fmu_state (fmi2_capi_t* fmu, fmi2_FMU_state_t* s);\r
+fmi2_status_t fmi2_capi_serialized_fmu_state_size(fmi2_capi_t* fmu, fmi2_FMU_state_t s, size_t* sz);\r
+fmi2_status_t fmi2_capi_serialize_fmu_state (fmi2_capi_t* fmu, fmi2_FMU_state_t s , fmi2_byte_t data[], size_t sz);\r
+fmi2_status_t fmi2_capi_de_serialize_fmu_state (fmi2_capi_t* fmu, const fmi2_byte_t data[], size_t sz, fmi2_FMU_state_t* s);\r
+\r
+/* Getting directional derivatives */
+fmi2_status_t fmi2_capi_get_directional_derivative(fmi2_capi_t* fmu, const fmi2_value_reference_t v_ref[], size_t nv,\r
+ const fmi2_value_reference_t z_ref[], size_t nz,\r
+ const fmi2_real_t dv[], fmi2_real_t dz[]);
+/**@} */
+
+/** \addtogroup fmi2_capi_me\r
+ * @{\r
+ */
+
+/**
+ * \brief Calls the FMI function fmiEnterEventMode(...)
+ *
+ * @param fmu C-API struct that has succesfully loaded the FMI function.
+ * @return FMI status.
+ */
+fmi2_status_t fmi2_capi_enter_event_mode(fmi2_capi_t* fmu);
+
+/**
+ * \brief Calls the FMI function fmiNewDiscreteStates(...)
+ *
+ * @param fmu C-API struct that has succesfully loaded the FMI function.
+ * @param eventInfo Pointer to fmi2_event_info_t structure that will be filled in.
+ * @return FMI status.
+ */
+fmi2_status_t fmi2_capi_new_discrete_states(fmi2_capi_t* fmu, fmi2_event_info_t* eventInfo);
+
+/**
+ * \brief Calls the FMI function fmiEnterContinuousTimeMode(...)
+ *
+ * @param fmu C-API struct that has succesfully loaded the FMI function.
+ * @return FMI status.
+ */
+fmi2_status_t fmi2_capi_enter_continuous_time_mode(fmi2_capi_t* fmu);
+
+
+/**\r
+ * \brief Calls the FMI function fmiSetTime(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param time Set the current time.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_set_time(fmi2_capi_t* fmu, fmi2_real_t time);
+
+/**\r
+ * \brief Calls the FMI function fmiSetContinuousStates(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param x Array of state values.\r
+ * @param nx Number of states.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_set_continuous_states(fmi2_capi_t* fmu, const fmi2_real_t x[], size_t nx);
+
+/**\r
+ * \brief Calls the FMI function fmiCompletedIntegratorStep(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param noSetFMUStatePriorToCurrentPoint True if fmiSetFMUState will no
+ longer be called for time instants prior to current time in this
+ simulation run.
+ * @param enterEventMode (Output) Call fmiEnterEventMode indicator.
+ * @param terminateSimulation (Output) Terminate simulation indicator.
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_completed_integrator_step(fmi2_capi_t* fmu,
+ fmi2_boolean_t noSetFMUStatePriorToCurrentPoint,
+ fmi2_boolean_t* enterEventMode, fmi2_boolean_t* terminateSimulation);
+
+/**\r
+ * \brief Calls the FMI function fmiGetDerivatives(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param derivatives (Output) Array of the derivatives.\r
+ * @param nx Number of derivatives.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_derivatives(fmi2_capi_t* fmu, fmi2_real_t derivatives[] , size_t nx);
+
+/**\r
+ * \brief Calls the FMI function fmiGetEventIndicators(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param eventIndicators (Output) The event indicators.\r
+ * @param ni Number of event indicators.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_event_indicators(fmi2_capi_t* fmu, fmi2_real_t eventIndicators[], size_t ni);
+
+/**\r
+ * \brief Calls the FMI function fmiGetContinuousStates(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param states (Output) Array of state values.\r
+ * @param nx Number of states.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_continuous_states(fmi2_capi_t* fmu, fmi2_real_t states[], size_t nx);
+
+/**\r
+ * \brief Calls the FMI function fmiGetNominalsOfContinuousStates(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param x_nominal (Output) The nominal values.\r
+ * @param nx Number of nominal values.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_nominals_of_continuous_states(fmi2_capi_t* fmu, fmi2_real_t x_nominal[], size_t nx);
+
+/**@} */
+
+/** \addtogroup fmi2_capi_cs\r
+ * @{\r
+ */
+
+/**\r
+ * \brief Calls the FMI function fmiSetRealInputDerivatives(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully load the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param order Array of derivative orders.\r
+ * @param value Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_set_real_input_derivatives(fmi2_capi_t* fmu, const fmi2_value_reference_t vr[], size_t nvr, const fmi2_integer_t order[], const fmi2_real_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiGetOutputDerivatives(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param vr Array of value references.\r
+ * @param nvr Number of array elements.\r
+ * @param order Array of derivative orders.\r
+ * @param value (Output) Array of variable values.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_real_output_derivatives(fmi2_capi_t* fmu, const fmi2_value_reference_t vr[], size_t nvr, const fmi2_integer_t order[], fmi2_real_t value[]);
+
+/**\r
+ * \brief Calls the FMI function fmiCancelStep(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_cancel_step(fmi2_capi_t* fmu);
+
+/**\r
+ * \brief Calls the FMI function fmiDoStep(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param currentCommunicationPoint Current communication point of the master.\r
+ * @param communicationStepSize Communication step size.\r
+ * @param newStep Indicates whether or not the last communication step was accepted by the master.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_do_step(fmi2_capi_t* fmu, fmi2_real_t currentCommunicationPoint, fmi2_real_t communicationStepSize, fmi2_boolean_t newStep);
+
+/**\r
+ * \brief Calls the FMI function fmiGetStatus(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param s Kind of status to return the value for.\r
+ * @param value (Output) FMI status value.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_status(fmi2_capi_t* fmu, const fmi2_status_kind_t s, fmi2_status_t* value);
+
+/**\r
+ * \brief Calls the FMI function fmiGetRealStatus(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param s Kind of status to return the value for.\r
+ * @param value (Output) FMI real value.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_real_status(fmi2_capi_t* fmu, const fmi2_status_kind_t s, fmi2_real_t* value);
+\r
+/**\r
+ * \brief Calls the FMI function fmiGetIntegerStatus(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param s Kind of status to return the value for.\r
+ * @param value (Output) FMI integer value.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_integer_status(fmi2_capi_t* fmu, const fmi2_status_kind_t s, fmi2_integer_t* value);
+
+/**\r
+ * \brief Calls the FMI function fmiGetBooleanStatus(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param s Kind of status to return the value for.\r
+ * @param value (Output) FMI boolean value.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_boolean_status(fmi2_capi_t* fmu, const fmi2_status_kind_t s, fmi2_boolean_t* value);
+
+/**\r
+ * \brief Calls the FMI function fmiGetStringStatus(...) \r
+ * \r
+ * @param fmu C-API struct that has succesfully loaded the FMI function.\r
+ * @param s Kind of status to return the value for.\r
+ * @param value (Output) FMI string value.\r
+ * @return FMI status.\r
+ */
+fmi2_status_t fmi2_capi_get_string_status(fmi2_capi_t* fmu, const fmi2_status_kind_t s, fmi2_string_t* value);
+
+/** @}*/
+/** @}*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* End of header file FMI2_CAPI_H_ */
--- /dev/null
+FMILIB_FMI1_Readme.txt\r
+======================\r
+Note that "fmiPlatformTypes.h" is used for compilation of FMILIB.\r
+It is expected that its contents is consistent with the definitions \r
+in "fmiModelTypes.h". Therefore, make sure to provide all the 4 \r
+header files (both ME and CS interfaces) if you are building for\r
+non-standard platform.\r
+\r
+All the 4 header files are used in FMILIB tests. \r
--- /dev/null
+#ifndef fmiFunctions_h\r
+#define fmiFunctions_h\r
+\r
+/* This header file must be utilized when compiling a FMU.\r
+ It defines all functions of Co-Simulation Interface.\r
+ In order to have unique function names even if several FMUs\r
+ are compiled together (e.g. for embedded systems), every "real" function name\r
+ is constructed by prepending the function name by\r
+ "MODEL_IDENTIFIER" + "_" where "MODEL_IDENTIFIER" is the short name\r
+ of the model used as the name of the zip-file where the model is stored.\r
+ Therefore, the typical usage is:\r
+\r
+ #define MODEL_IDENTIFIER MyModel\r
+ #include "fmiFunctions.h"\r
+\r
+ As a result, a function that is defined as "fmiGetDerivatives" in this header file,\r
+ is actually getting the name "MyModel_fmiGetDerivatives".\r
+\r
+ Revisions:\r
+ - November 4, 2010: Adapted to specification text:\r
+ o fmiGetModelTypesPlatform renamed to fmiGetTypesPlatform\r
+ o fmiInstantiateSlave: Argument GUID replaced by fmuGUID\r
+ Argument mimetype replaced by mimeType\r
+ o tabs replaced by spaces\r
+ - October 16, 2010: First public Version\r
+\r
+\r
+ Copyright © 2008-2010, MODELISAR consortium. All rights reserved.\r
+ This file is licensed by the copyright holders under the BSD License\r
+ (http://www.opensource.org/licenses/bsd-license.html):\r
+\r
+ ----------------------------------------------------------------------------\r
+ Redistribution and use in source and binary forms, with or without\r
+ modification, are permitted provided that the following conditions are met:\r
+\r
+ - Redistributions of source code must retain the above copyright notice,\r
+ this list of conditions and the following disclaimer.\r
+ - Redistributions in binary form must reproduce the above copyright notice,\r
+ this list of conditions and the following disclaimer in the documentation\r
+ and/or other materials provided with the distribution.\r
+ - Neither the name of the copyright holders nor the names of its\r
+ contributors may be used to endorse or promote products derived\r
+ from this software without specific prior written permission.\r
+\r
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\r
+ TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\r
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\r
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;\r
+ OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\r
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\r
+ OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\r
+ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ ----------------------------------------------------------------------------\r
+*/\r
+\r
+#include "fmiPlatformTypes.h"\r
+#include <stdlib.h>\r
+\r
+/* Export fmi functions on Windows */\r
+#ifdef _MSC_VER\r
+#define DllExport __declspec( dllexport )\r
+#else\r
+#define DllExport\r
+#endif\r
+\r
+/* Macros to construct the real function name\r
+ (prepend function name by MODEL_IDENTIFIER + "_") */\r
+\r
+#define fmiPaste(a,b) a ## b\r
+#define fmiPasteB(a,b) fmiPaste(a,b)\r
+#define fmiFullName(name) fmiPasteB(MODEL_IDENTIFIER, name)\r
+\r
+/***************************************************\r
+Common Functions\r
+****************************************************/\r
+#define fmiGetTypesPlatform fmiFullName(_fmiGetTypesPlatform)\r
+#define fmiGetVersion fmiFullName(_fmiGetVersion)\r
+#define fmiSetDebugLogging fmiFullName(_fmiSetDebugLogging)\r
+\r
+/*Data Exchange*/\r
+#define fmiSetReal fmiFullName(_fmiSetReal)\r
+#define fmiSetInteger fmiFullName(_fmiSetInteger)\r
+#define fmiSetBoolean fmiFullName(_fmiSetBoolean)\r
+#define fmiSetString fmiFullName(_fmiSetString)\r
+\r
+#define fmiGetReal fmiFullName(_fmiGetReal)\r
+#define fmiGetInteger fmiFullName(_fmiGetInteger)\r
+#define fmiGetBoolean fmiFullName(_fmiGetBoolean)\r
+#define fmiGetString fmiFullName(_fmiGetString)\r
+\r
+/***************************************************\r
+Functions for FMI for Co-Simulation\r
+****************************************************/\r
+#define fmiInstantiateSlave fmiFullName(_fmiInstantiateSlave)\r
+#define fmiInitializeSlave fmiFullName(_fmiInitializeSlave)\r
+#define fmiTerminateSlave fmiFullName(_fmiTerminateSlave)\r
+#define fmiResetSlave fmiFullName(_fmiResetSlave)\r
+#define fmiFreeSlaveInstance fmiFullName(_fmiFreeSlaveInstance)\r
+#define fmiSetRealInputDerivatives fmiFullName(_fmiSetRealInputDerivatives)\r
+#define fmiGetRealOutputDerivatives fmiFullName(_fmiGetRealOutputDerivatives)\r
+#define fmiDoStep fmiFullName(_fmiDoStep)\r
+#define fmiCancelStep fmiFullName(_fmiCancelStep)\r
+#define fmiGetStatus fmiFullName(_fmiGetStatus)\r
+#define fmiGetRealStatus fmiFullName(_fmiGetRealStatus)\r
+#define fmiGetIntegerStatus fmiFullName(_fmiGetIntegerStatus)\r
+#define fmiGetBooleanStatus fmiFullName(_fmiGetBooleanStatus)\r
+#define fmiGetStringStatus fmiFullName(_fmiGetStringStatus)\r
+\r
+/* Version number */\r
+#define fmiVersion "1.0"\r
+\r
+/* make sure all compiler use the same alignment policies for structures */\r
+#ifdef WIN32\r
+#pragma pack(push,8)\r
+#endif\r
+\r
+\r
+/* Type definitions */\r
+ typedef enum {fmiOK,\r
+ fmiWarning,\r
+ fmiDiscard,\r
+ fmiError,\r
+ fmiFatal,\r
+ fmiPending} fmiStatus;\r
+\r
+ typedef void (*fmiCallbackLogger) (fmiComponent c, fmiString instanceName, fmiStatus status,\r
+ fmiString category, fmiString message, ...);\r
+ typedef void* (*fmiCallbackAllocateMemory)(size_t nobj, size_t size);\r
+ typedef void (*fmiCallbackFreeMemory) (void* obj);\r
+ typedef void (*fmiStepFinished) (fmiComponent c, fmiStatus status);\r
+\r
+ typedef struct {\r
+ fmiCallbackLogger logger;\r
+ fmiCallbackAllocateMemory allocateMemory;\r
+ fmiCallbackFreeMemory freeMemory;\r
+ fmiStepFinished stepFinished;\r
+ } fmiCallbackFunctions;\r
+\r
+ typedef struct {\r
+ fmiBoolean iterationConverged;\r
+ fmiBoolean stateValueReferencesChanged;\r
+ fmiBoolean stateValuesChanged;\r
+ fmiBoolean terminateSimulation;\r
+ fmiBoolean upcomingTimeEvent;\r
+ fmiReal nextEventTime;\r
+ } fmiEventInfo;\r
+\r
+/* reset alignment policy to the one set before reading this file */\r
+#ifdef WIN32\r
+#pragma pack(pop)\r
+#endif\r
+\r
+/***************************************************\r
+Common Functions\r
+****************************************************/\r
+\r
+/* Inquire version numbers of header files */\r
+ DllExport const char* fmiGetTypesPlatform();\r
+ DllExport const char* fmiGetVersion();\r
+\r
+ DllExport fmiStatus fmiSetDebugLogging (fmiComponent c, fmiBoolean loggingOn);\r
+\r
+/* Data Exchange Functions*/\r
+ DllExport fmiStatus fmiGetReal (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiReal value[]);\r
+ DllExport fmiStatus fmiGetInteger(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiInteger value[]);\r
+ DllExport fmiStatus fmiGetBoolean(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiBoolean value[]);\r
+ DllExport fmiStatus fmiGetString (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiString value[]);\r
+\r
+ DllExport fmiStatus fmiSetReal (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiReal value[]);\r
+ DllExport fmiStatus fmiSetInteger (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiInteger value[]);\r
+ DllExport fmiStatus fmiSetBoolean (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiBoolean value[]);\r
+ DllExport fmiStatus fmiSetString (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiString value[]);\r
+\r
+/***************************************************\r
+Functions for FMI for Co-Simulation\r
+****************************************************/\r
+\r
+/* Creation and destruction of slave instances and setting debug status */\r
+ DllExport fmiComponent fmiInstantiateSlave(fmiString instanceName,\r
+ fmiString fmuGUID,\r
+ fmiString fmuLocation,\r
+ fmiString mimeType,\r
+ fmiReal timeout,\r
+ fmiBoolean visible,\r
+ fmiBoolean interactive,\r
+ fmiCallbackFunctions functions,\r
+ fmiBoolean loggingOn);\r
+\r
+ DllExport fmiStatus fmiInitializeSlave(fmiComponent c,\r
+ fmiReal tStart,\r
+ fmiBoolean StopTimeDefined,\r
+ fmiReal tStop);\r
+\r
+ DllExport fmiStatus fmiTerminateSlave (fmiComponent c);\r
+ DllExport fmiStatus fmiResetSlave (fmiComponent c);\r
+ DllExport void fmiFreeSlaveInstance(fmiComponent c);\r
+\r
+ DllExport fmiStatus fmiSetRealInputDerivatives(fmiComponent c,\r
+ const fmiValueReference vr[],\r
+ size_t nvr,\r
+ const fmiInteger order[],\r
+ const fmiReal value[]);\r
+\r
+ DllExport fmiStatus fmiGetRealOutputDerivatives(fmiComponent c,\r
+ const fmiValueReference vr[],\r
+ size_t nvr,\r
+ const fmiInteger order[],\r
+ fmiReal value[]);\r
+\r
+ DllExport fmiStatus fmiCancelStep(fmiComponent c);\r
+ DllExport fmiStatus fmiDoStep (fmiComponent c,\r
+ fmiReal currentCommunicationPoint,\r
+ fmiReal communicationStepSize,\r
+ fmiBoolean newStep);\r
+\r
+\r
+ typedef enum {fmiDoStepStatus,\r
+ fmiPendingStatus,\r
+ fmiLastSuccessfulTime} fmiStatusKind;\r
+\r
+ DllExport fmiStatus fmiGetStatus (fmiComponent c, const fmiStatusKind s, fmiStatus* value);\r
+ DllExport fmiStatus fmiGetRealStatus (fmiComponent c, const fmiStatusKind s, fmiReal* value);\r
+ DllExport fmiStatus fmiGetIntegerStatus(fmiComponent c, const fmiStatusKind s, fmiInteger* value);\r
+ DllExport fmiStatus fmiGetBooleanStatus(fmiComponent c, const fmiStatusKind s, fmiBoolean* value);\r
+ DllExport fmiStatus fmiGetStringStatus (fmiComponent c, const fmiStatusKind s, fmiString* value);\r
+\r
+\r
+#endif // fmiFunctions_h\r
--- /dev/null
+#ifndef fmiModelFunctions_h\r
+#define fmiModelFunctions_h\r
+\r
+/* This header file must be utilized when compiling a model.\r
+ It defines all functions of the Model Execution Interface.\r
+ In order to have unique function names even if several models\r
+ are compiled together (e.g. for embedded systems), every "real" function name\r
+ is constructed by prepending the function name by\r
+ "MODEL_IDENTIFIER" + "_" where "MODEL_IDENTIFIER" is the short name\r
+ of the model used as the name of the zip-file where the model is stored.\r
+ Therefore, the typical usage is:\r
+\r
+ #define MODEL_IDENTIFIER MyModel\r
+ #include "fmiModelFunctions.h"\r
+\r
+ As a result, a function that is defined as "fmiGetDerivatives" in this header file,\r
+ is actually getting the name "MyModel_fmiGetDerivatives".\r
+\r
+ Revisions:\r
+ - Jan. 20, 2010: stateValueReferencesChanged added to struct fmiEventInfo (ticket #27)\r
+ (by M. Otter, DLR)\r
+ Added WIN32 pragma to define the struct layout (ticket #34)\r
+ (by J. Mauss, QTronic)\r
+ - Jan. 4, 2010: Removed argument intermediateResults from fmiInitialize\r
+ Renamed macro fmiGetModelFunctionsVersion to fmiGetVersion\r
+ Renamed macro fmiModelFunctionsVersion to fmiVersion\r
+ Replaced fmiModel by fmiComponent in decl of fmiInstantiateModel\r
+ (by J. Mauss, QTronic)\r
+ - Dec. 17, 2009: Changed extension "me" to "fmi" (by Martin Otter, DLR).\r
+ - Dez. 14, 2009: Added eventInfo to meInitialize and added\r
+ meGetNominalContinuousStates (by Martin Otter, DLR)\r
+ - Sept. 9, 2009: Added DllExport (according to Peter Nilsson's suggestion)\r
+ (by A. Junghanns, QTronic)\r
+ - Sept. 9, 2009: Changes according to FMI-meeting on July 21:\r
+ meInquireModelTypesVersion -> meGetModelTypesPlatform\r
+ meInquireModelFunctionsVersion -> meGetModelFunctionsVersion\r
+ meSetStates -> meSetContinuousStates\r
+ meGetStates -> meGetContinuousStates\r
+ removal of meInitializeModelClass\r
+ removal of meGetTime\r
+ change of arguments of meInstantiateModel\r
+ change of arguments of meCompletedIntegratorStep\r
+ (by Martin Otter, DLR):\r
+ - July 19, 2009: Added "me" as prefix to file names (by Martin Otter, DLR).\r
+ - March 2, 2009: Changed function definitions according to the last design\r
+ meeting with additional improvements (by Martin Otter, DLR).\r
+ - Dec. 3 , 2008: First version by Martin Otter (DLR) and Hans Olsson (Dynasim).\r
+\r
+\r
+ Copyright © 2008-2009, MODELISAR consortium. All rights reserved.\r
+ This file is licensed by the copyright holders under the BSD License\r
+ (http://www.opensource.org/licenses/bsd-license.html):\r
+\r
+ ----------------------------------------------------------------------------\r
+ Redistribution and use in source and binary forms, with or without\r
+ modification, are permitted provided that the following conditions are met:\r
+\r
+ - Redistributions of source code must retain the above copyright notice,\r
+ this list of conditions and the following disclaimer.\r
+ - Redistributions in binary form must reproduce the above copyright notice,\r
+ this list of conditions and the following disclaimer in the documentation\r
+ and/or other materials provided with the distribution.\r
+ - Neither the name of the copyright holders nor the names of its\r
+ contributors may be used to endorse or promote products derived\r
+ from this software without specific prior written permission.\r
+\r
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\r
+ TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\r
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\r
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;\r
+ OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\r
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\r
+ OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\r
+ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ ----------------------------------------------------------------------------\r
+\r
+ with the extension:\r
+\r
+ You may distribute or publicly perform any modification only under the\r
+ terms of this license.\r
+*/\r
+\r
+#include "fmiModelTypes.h"\r
+#include <stdlib.h>\r
+\r
+/* Export fmi functions on Windows */\r
+#ifdef _MSC_VER\r
+#define DllExport __declspec( dllexport )\r
+#else\r
+#define DllExport\r
+#endif\r
+\r
+/* Macros to construct the real function name\r
+ (prepend function name by MODEL_IDENTIFIER + "_") */\r
+\r
+#define fmiPaste(a,b) a ## b\r
+#define fmiPasteB(a,b) fmiPaste(a,b)\r
+#define fmiFullName(name) fmiPasteB(MODEL_IDENTIFIER, name)\r
+\r
+#define fmiGetModelTypesPlatform fmiFullName(_fmiGetModelTypesPlatform)\r
+#define fmiGetVersion fmiFullName(_fmiGetVersion)\r
+#define fmiInstantiateModel fmiFullName(_fmiInstantiateModel)\r
+#define fmiFreeModelInstance fmiFullName(_fmiFreeModelInstance)\r
+#define fmiSetDebugLogging fmiFullName(_fmiSetDebugLogging)\r
+#define fmiSetTime fmiFullName(_fmiSetTime)\r
+#define fmiSetContinuousStates fmiFullName(_fmiSetContinuousStates)\r
+#define fmiCompletedIntegratorStep fmiFullName(_fmiCompletedIntegratorStep)\r
+#define fmiSetReal fmiFullName(_fmiSetReal)\r
+#define fmiSetInteger fmiFullName(_fmiSetInteger)\r
+#define fmiSetBoolean fmiFullName(_fmiSetBoolean)\r
+#define fmiSetString fmiFullName(_fmiSetString)\r
+#define fmiInitialize fmiFullName(_fmiInitialize)\r
+#define fmiGetDerivatives fmiFullName(_fmiGetDerivatives)\r
+#define fmiGetEventIndicators fmiFullName(_fmiGetEventIndicators)\r
+#define fmiGetReal fmiFullName(_fmiGetReal)\r
+#define fmiGetInteger fmiFullName(_fmiGetInteger)\r
+#define fmiGetBoolean fmiFullName(_fmiGetBoolean)\r
+#define fmiGetString fmiFullName(_fmiGetString)\r
+#define fmiEventUpdate fmiFullName(_fmiEventUpdate)\r
+#define fmiGetContinuousStates fmiFullName(_fmiGetContinuousStates)\r
+#define fmiGetNominalContinuousStates fmiFullName(_fmiGetNominalContinuousStates)\r
+#define fmiGetStateValueReferences fmiFullName(_fmiGetStateValueReferences)\r
+#define fmiTerminate fmiFullName(_fmiTerminate)\r
+\r
+\r
+/* Version number */\r
+#define fmiVersion "1.0"\r
+\r
+/* Inquire version numbers of header files */\r
+ DllExport const char* fmiGetModelTypesPlatform();\r
+ DllExport const char* fmiGetVersion();\r
+\r
+/* make sure all compiler use the same alignment policies for structures */\r
+#ifdef WIN32\r
+#pragma pack(push,8)\r
+#endif\r
+\r
+/* Type definitions */\r
+ typedef enum {fmiOK,\r
+ fmiWarning,\r
+ fmiDiscard,\r
+ fmiError,\r
+ fmiFatal} fmiStatus;\r
+\r
+ typedef void (*fmiCallbackLogger) (fmiComponent c, fmiString instanceName, fmiStatus status,\r
+ fmiString category, fmiString message, ...);\r
+ typedef void* (*fmiCallbackAllocateMemory)(size_t nobj, size_t size);\r
+ typedef void (*fmiCallbackFreeMemory) (void* obj);\r
+\r
+ typedef struct {\r
+ fmiCallbackLogger logger;\r
+ fmiCallbackAllocateMemory allocateMemory;\r
+ fmiCallbackFreeMemory freeMemory;\r
+ } fmiCallbackFunctions;\r
+\r
+ typedef struct {\r
+ fmiBoolean iterationConverged;\r
+ fmiBoolean stateValueReferencesChanged;\r
+ fmiBoolean stateValuesChanged;\r
+ fmiBoolean terminateSimulation;\r
+ fmiBoolean upcomingTimeEvent;\r
+ fmiReal nextEventTime;\r
+ } fmiEventInfo;\r
+\r
+/* reset alignment policy to the one set before reading this file */\r
+#ifdef WIN32\r
+#pragma pack(pop)\r
+#endif\r
+\r
+/* Creation and destruction of model instances and setting debug status */\r
+ DllExport fmiComponent fmiInstantiateModel (fmiString instanceName,\r
+ fmiString GUID,\r
+ fmiCallbackFunctions functions,\r
+ fmiBoolean loggingOn);\r
+ DllExport void fmiFreeModelInstance(fmiComponent c);\r
+ DllExport fmiStatus fmiSetDebugLogging (fmiComponent c, fmiBoolean loggingOn);\r
+\r
+\r
+/* Providing independent variables and re-initialization of caching */\r
+ DllExport fmiStatus fmiSetTime (fmiComponent c, fmiReal time);\r
+ DllExport fmiStatus fmiSetContinuousStates (fmiComponent c, const fmiReal x[], size_t nx);\r
+ DllExport fmiStatus fmiCompletedIntegratorStep(fmiComponent c, fmiBoolean* callEventUpdate);\r
+ DllExport fmiStatus fmiSetReal (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiReal value[]);\r
+ DllExport fmiStatus fmiSetInteger (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiInteger value[]);\r
+ DllExport fmiStatus fmiSetBoolean (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiBoolean value[]);\r
+ DllExport fmiStatus fmiSetString (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiString value[]);\r
+\r
+\r
+/* Evaluation of the model equations */\r
+ DllExport fmiStatus fmiInitialize(fmiComponent c, fmiBoolean toleranceControlled,\r
+ fmiReal relativeTolerance, fmiEventInfo* eventInfo);\r
+\r
+ DllExport fmiStatus fmiGetDerivatives (fmiComponent c, fmiReal derivatives[] , size_t nx);\r
+ DllExport fmiStatus fmiGetEventIndicators(fmiComponent c, fmiReal eventIndicators[], size_t ni);\r
+\r
+ DllExport fmiStatus fmiGetReal (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiReal value[]);\r
+ DllExport fmiStatus fmiGetInteger(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiInteger value[]);\r
+ DllExport fmiStatus fmiGetBoolean(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiBoolean value[]);\r
+ DllExport fmiStatus fmiGetString (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiString value[]);\r
+\r
+ DllExport fmiStatus fmiEventUpdate (fmiComponent c, fmiBoolean intermediateResults, fmiEventInfo* eventInfo);\r
+ DllExport fmiStatus fmiGetContinuousStates (fmiComponent c, fmiReal states[], size_t nx);\r
+ DllExport fmiStatus fmiGetNominalContinuousStates(fmiComponent c, fmiReal x_nominal[], size_t nx);\r
+ DllExport fmiStatus fmiGetStateValueReferences (fmiComponent c, fmiValueReference vrx[], size_t nx);\r
+ DllExport fmiStatus fmiTerminate (fmiComponent c);\r
+\r
+#endif // fmiModelFunctions_h\r
--- /dev/null
+#ifndef fmiModelTypes_h\r
+#define fmiModelTypes_h\r
+\r
+/* Standard header file to define the argument types of the\r
+ functions of the Model Execution Interface.\r
+ This header file must be utilized both by the model and\r
+ by the simulation engine.\r
+\r
+ Revisions:\r
+ - Jan. 4, 2010: Renamed meModelTypes_h to fmiModelTypes_h (by Mauss, QTronic)\r
+ - Dec. 21, 2009: Changed "me" to "fmi" and "meModel" to "fmiComponent"\r
+ according to meeting on Dec. 18 (by Martin Otter, DLR)\r
+ - Dec. 6, 2009: Added meUndefinedValueReference (by Martin Otter, DLR)\r
+ - Sept. 9, 2009: Changes according to FMI-meeting on July 21:\r
+ Changed "version" to "platform", "standard" to "standard32",\r
+ Added a precise definition of "standard32" as comment\r
+ (by Martin Otter, DLR)\r
+ - July 19, 2009: Added "me" as prefix to file names, added meTrue/meFalse,\r
+ and changed meValueReferenced from int to unsigned int\r
+ (by Martin Otter, DLR).\r
+ - March 2, 2009: Moved enums and function pointer definitions to\r
+ ModelFunctions.h (by Martin Otter, DLR).\r
+ - Dec. 3, 2008 : First version by Martin Otter (DLR) and\r
+ Hans Olsson (Dynasim).\r
+\r
+\r
+ Copyright © 2008-2010, MODELISAR consortium. All rights reserved.\r
+ This file is licensed by the copyright holders under the BSD License\r
+ (http://www.opensource.org/licenses/bsd-license.html)\r
+\r
+ ----------------------------------------------------------------------------\r
+ Redistribution and use in source and binary forms, with or without\r
+ modification, are permitted provided that the following conditions are met:\r
+\r
+ - Redistributions of source code must retain the above copyright notice,\r
+ this list of conditions and the following disclaimer.\r
+ - Redistributions in binary form must reproduce the above copyright notice,\r
+ this list of conditions and the following disclaimer in the documentation\r
+ and/or other materials provided with the distribution.\r
+ - Neither the name of the copyright holders nor the names of its\r
+ contributors may be used to endorse or promote products derived\r
+ from this software without specific prior written permission.\r
+\r
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\r
+ TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\r
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\r
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;\r
+ OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\r
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\r
+ OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\r
+ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ ----------------------------------------------------------------------------\r
+\r
+ with the extension:\r
+\r
+ You may distribute or publicly perform any modification only under the\r
+ terms of this license.\r
+*/\r
+\r
+/* Platform (combination of machine, compiler, operating system) */\r
+#define fmiModelTypesPlatform "standard32"\r
+\r
+/* Type definitions of variables passed as arguments\r
+ Version "standard32" means:\r
+\r
+ fmiComponent : 32 bit pointer\r
+ fmiValueReference: 32 bit\r
+ fmiReal : 64 bit\r
+ fmiInteger : 32 bit\r
+ fmiBoolean : 8 bit\r
+ fmiString : 32 bit pointer\r
+\r
+*/\r
+ typedef void* fmiComponent;\r
+ typedef unsigned int fmiValueReference;\r
+ typedef double fmiReal ;\r
+ typedef int fmiInteger;\r
+ typedef char fmiBoolean;\r
+ typedef const char* fmiString ;\r
+\r
+/* Values for fmiBoolean */\r
+#define fmiTrue 1\r
+#define fmiFalse 0\r
+\r
+/* Undefined value for fmiValueReference (largest unsigned int value) */\r
+#define fmiUndefinedValueReference (fmiValueReference)(-1)\r
+\r
+#endif\r
--- /dev/null
+#ifndef fmiPlatformTypes_h\r
+#define fmiPlatformTypes_h\r
+\r
+/* Standard header file to define the argument types of the\r
+ functions of the Model Execution Interface.\r
+ This header file must be utilized both by the model and\r
+ by the simulation engine.\r
+\r
+ Revisions:\r
+ - October 2010: First public Version\r
+\r
+\r
+ Copyright © 2008-2010, MODELISAR consortium. All rights reserved.\r
+ This file is licensed by the copyright holders under the BSD License\r
+ (http://www.opensource.org/licenses/bsd-license.html):\r
+\r
+\r
+ ----------------------------------------------------------------------------\r
+ Redistribution and use in source and binary forms, with or without\r
+ modification, are permitted provided that the following conditions are met:\r
+\r
+ - Redistributions of source code must retain the above copyright notice,\r
+ this list of conditions and the following disclaimer.\r
+ - Redistributions in binary form must reproduce the above copyright notice,\r
+ this list of conditions and the following disclaimer in the documentation\r
+ and/or other materials provided with the distribution.\r
+ - Neither the name of the copyright holders nor the names of its\r
+ contributors may be used to endorse or promote products derived\r
+ from this software without specific prior written permission.\r
+\r
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\r
+ TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\r
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\r
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;\r
+ OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\r
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\r
+ OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\r
+ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ ----------------------------------------------------------------------------\r
+*/\r
+\r
+/* Platform (combination of machine, compiler, operating system) */\r
+#define fmiPlatform "standard32"\r
+\r
+/* Type definitions of variables passed as arguments\r
+ Version "standard32" means:\r
+\r
+ fmiComponent : 32 bit pointer\r
+ fmiValueReference: 32 bit\r
+ fmiReal : 64 bit\r
+ fmiInteger : 32 bit\r
+ fmiBoolean : 8 bit\r
+ fmiString : 32 bit pointer\r
+\r
+*/\r
+ typedef void* fmiComponent;\r
+ typedef unsigned int fmiValueReference;\r
+ typedef double fmiReal ;\r
+ typedef int fmiInteger;\r
+ typedef char fmiBoolean;\r
+ typedef const char* fmiString ;\r
+\r
+/* Values for fmiBoolean */\r
+#define fmiTrue 1\r
+#define fmiFalse 0\r
+\r
+/* Undefined value for fmiValueReference (largest unsigned int value) */\r
+#define fmiUndefinedValueReference (fmiValueReference)(-1)\r
+\r
+#endif\r
--- /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>.
+*/
+
+#ifndef FMI_UTIL_H
+#define FMI_UTIL_H
+#include <fmilib_config.h>
+#include <JM/jm_callbacks.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ @file fmi_util.h
+ \brief Some low-level utility functions suitable for all standards.
+
+ */
+/** \addtogroup jm_utils
+ * @{
+*/
+/** \brief Given directory name fmu_unzipped_path and construct the directory path for Dll/so\r
+ \param fmu_unzipped_path Directory name where FMU is unpacked.\r
+ \param callbacks Callbacks for memory allocation.\r
+ @return Pointer to a string with the directory name (last symbol is directory separator). Caller is responsible for freeing the memory.\r
+*/\r
+FMILIB_EXPORT char* fmi_construct_dll_dir_name(jm_callbacks* callbacks, const char* fmu_unzipped_path);
+
+/** \brief Given model_identifier construct the dll/so name by adding platform suffix\r
+ \param callbacks Callbacks for memory allocation.\r
+ \param dll_dir_name Directory path for Dll/so as returned by fmi_construct_dll_dir_name\r
+ \param model_identifier The FMU model identifier.\r
+ @return Pointer to a string with the file name. Caller is responsible for freeing the memory.\r
+*/\r
+FMILIB_EXPORT char* fmi_construct_dll_file_name(jm_callbacks* callbacks, const char* dll_dir_name, const char* model_identifier);
+
+/** @} */
+#ifdef __cplusplus
+}
+#endif
+
+/* FMI_UTIL_H */
+#endif
--- /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>.
+*/
+
+#ifndef FMI_VERSION_H
+#define FMI_VERSION_H
+#include <fmilib_config.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ @file fmi_version.h
+ \brief Enum defining supported FMI versions.
+
+ */
+/** \addtogroup jm_utils
+ * @{
+*/
+
+/** \brief Suported versions of FMI standard */\r
+typedef enum\r
+{ \r
+ fmi_version_unknown_enu = 0,\r
+ fmi_version_1_enu,\r
+ fmi_version_2_0_enu,\r
+ fmi_version_unsupported_enu\r
+} fmi_version_enu_t;\r
+
+/** Convert version enum into string */
+FMILIB_EXPORT
+const char * fmi_version_to_string(fmi_version_enu_t v);
+
+/** @} */
+#ifdef __cplusplus
+}
+#endif
+
+/* JM_TYPES_H */
+#endif
--- /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>.
+*/\r
+\r
+#ifndef FMI1_ENUMS_H_\r
+#define FMI1_ENUMS_H_\r
+\r
+#include <fmilib_config.h>\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+/** \file fmi1_enums.h \r
+ \brief Definions the enum types used with FMI 1.0 libs\r
+*/\r
+\r
+/** \addtogroup fmi1_utils\r
+ @{\r
+ \addtogroup fmi1_enums\r
+ @}\r
+*/
+/** \addtogroup fmi1_enums Enum types used with FMI 1.0 libs\r
+ @{\r
+*/\r
+/** \brief Naming convention for the variables in XML file*/\r
+typedef enum fmi1_variable_naming_convension_enu_t\r
+{ \r
+ fmi1_naming_enu_flat,\r
+ fmi1_naming_enu_structured,\r
+ fmi1_naming_enu_unknown\r
+} fmi1_variable_naming_convension_enu_t;\r
+\r
+/** \brief Convert a #fmi1_variable_naming_convension_enu_t constant into string */\r
+FMILIB_EXPORT const char* fmi1_naming_convention_to_string(fmi1_variable_naming_convension_enu_t convention);\r
+\r
+/** \brief FMU 1.0 kinds */\r
+typedef enum fmi1_fmu_kind_enu_t\r
+{\r
+ fmi1_fmu_kind_enu_me = 0,\r
+ fmi1_fmu_kind_enu_cs_standalone,\r
+ fmi1_fmu_kind_enu_cs_tool,\r
+ fmi1_fmu_kind_enu_unknown\r
+} fmi1_fmu_kind_enu_t;\r
+\r
+/** \brief Convert a #fmi1_fmu_kind_enu_t constant into string */\r
+FMILIB_EXPORT const char* fmi1_fmu_kind_to_string(fmi1_fmu_kind_enu_t kind);\r
+\r
+/** \brief Variability property for variables */\r
+typedef enum fmi1_variability_enu_t {
+ fmi1_variability_enu_constant,
+ fmi1_variability_enu_parameter,
+ fmi1_variability_enu_discrete,
+ fmi1_variability_enu_continuous,
+ fmi1_variability_enu_unknown
+} fmi1_variability_enu_t;
+
+/** \brief Convert a #fmi1_variability_enu_t constant into string */
+FMILIB_EXPORT const char* fmi1_variability_to_string(fmi1_variability_enu_t v);
+
+/** \brief Causality property for variables */
+typedef enum fmi1_causality_enu_t {
+ fmi1_causality_enu_input,
+ fmi1_causality_enu_output,
+ fmi1_causality_enu_internal,
+ fmi1_causality_enu_none,
+ fmi1_causality_enu_unknown
+} fmi1_causality_enu_t;
+
+/** \brief Convert a #fmi1_causality_enu_t constant into string */
+FMILIB_EXPORT const char* fmi1_causality_to_string(fmi1_causality_enu_t c);
+\r
+/** \brief Alias property for variables */\r
+typedef enum fmi1_variable_alias_kind_enu_t {
+ fmi1_variable_is_negated_alias = -1,
+ fmi1_variable_is_not_alias = 0,
+ fmi1_variable_is_alias = 1
+} fmi1_variable_alias_kind_enu_t;
+
+/** \brief Base types used in type definitions */
+typedef enum fmi1_base_type_enu_t
+{
+ fmi1_base_type_real,
+ fmi1_base_type_int,
+ fmi1_base_type_bool,
+ fmi1_base_type_str,
+ fmi1_base_type_enum
+} fmi1_base_type_enu_t;
+
+/** \brief Convert base type constant to string
+ \param bt Base type identifier.
+ \return Corresponding base type name.
+ */
+FMILIB_EXPORT const char* fmi1_base_type_to_string(fmi1_base_type_enu_t bt);
+
+/** \r
+ @}\r
+*/
+#ifdef __cplusplus\r
+}\r
+#endif\r
+
+#endif /* End of header file FMI1_ENUMS_H_ */
--- /dev/null
+/*\r
+ Copyright (C) 2012 Modelon AB\r
+\r
+ This program is free software: you can redistribute it and/or modify\r
+ it under the terms of the BSD style license.\r
+\r
+ This program is distributed in the hope that it will be useful,\r
+ but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
+ FMILIB_License.txt file for more details.\r
+\r
+ You should have received a copy of the FMILIB_License.txt file\r
+ along with this program. If not, contact Modelon AB <http://www.modelon.com>.\r
+*/\r
+\r
+#ifndef FMI1_FUNCTIONS_H_\r
+#define FMI1_FUNCTIONS_H_\r
+\r
+#include <fmilib_config.h>\r
+\r
+#include "fmi1_types.h"\r
+#include <string.h>\r
+/** \file fmi1_functions.h\r
+ Mapping for the standard FMI 1.0 functions into fmi1_ namespace.\r
+\r
+ \addtogroup fmi1_utils\r
+ @{\r
+*/\r
+\r
+/** FMI 1.0 status codes */\r
+typedef enum {\r
+ fmi1_status_ok,\r
+ fmi1_status_warning,\r
+ fmi1_status_discard,\r
+ fmi1_status_error,\r
+ fmi1_status_fatal,\r
+ fmi1_status_pending\r
+} fmi1_status_t;\r
+\r
+/** Convert #fmi1_status_t variable to string */\r
+FMILIB_EXPORT const char* fmi1_status_to_string(fmi1_status_t status);\r
+\r
+/** FMI 1.0 logger function type */\r
+typedef void (*fmi1_callback_logger_ft) (fmi1_component_t c, fmi1_string_t instanceName, fmi1_status_t status, fmi1_string_t category, fmi1_string_t message, ...);\r
+/** FMI 1.0 allocate memory function type */\r
+typedef void* (*fmi1_callback_allocate_memory_ft)(size_t nobj, size_t size);\r
+/** FMI 1.0 free memory function type */\r
+typedef void (*fmi1_callback_free_memory_ft) (void* obj);\r
+/** FMI 1.0 step finished callback function type */\r
+typedef void (*fmi1_step_finished_ft) (fmi1_component_t c, fmi1_status_t status);\r
+\r
+/** Functions for FMI 1.0 ME */\r
+typedef struct {\r
+ fmi1_callback_logger_ft logger;\r
+ fmi1_callback_allocate_memory_ft allocateMemory;\r
+ fmi1_callback_free_memory_ft freeMemory;\r
+} fmi1_me_callback_functions_t;\r
+\r
+/** The FMI 1.0 CS strcuture adds one field to the ME, otherwize compatible */\r
+typedef struct {\r
+ fmi1_callback_logger_ft logger;\r
+ fmi1_callback_allocate_memory_ft allocateMemory;\r
+ fmi1_callback_free_memory_ft freeMemory;\r
+ fmi1_step_finished_ft stepFinished;\r
+} fmi1_callback_functions_t;\r
+\r
+/** Event info structure as used in FMI 1.0 ME */\r
+typedef struct {\r
+ fmi1_boolean_t iterationConverged;\r
+ fmi1_boolean_t stateValueReferencesChanged;\r
+ fmi1_boolean_t stateValuesChanged;\r
+ fmi1_boolean_t terminateSimulation;\r
+ fmi1_boolean_t upcomingTimeEvent;\r
+ fmi1_real_t nextEventTime;\r
+} fmi1_event_info_t;\r
+\r
+/** FMI 1.0 asyncronous co-simulation status */\r
+typedef enum {\r
+ fmi1_do_step_status,\r
+ fmi1_pending_status,\r
+ fmi1_last_successful_time\r
+} fmi1_status_kind_t;\r
+\r
+/* FMI 1.0 common functions */\r
+typedef const char* (*fmi1_get_version_ft) (void);\r
+typedef fmi1_status_t (*fmi1_set_debug_logging_ft) (fmi1_component_t c, fmi1_boolean_t loggingOn);\r
+typedef fmi1_status_t (*fmi1_set_real_ft) (fmi1_component_t c, const fmi1_value_reference_t vr[], size_t nvr, const fmi1_real_t value[]);\r
+typedef fmi1_status_t (*fmi1_set_integer_ft) (fmi1_component_t c, const fmi1_value_reference_t vr[], size_t nvr, const fmi1_integer_t value[]);\r
+typedef fmi1_status_t (*fmi1_set_boolean_ft) (fmi1_component_t c, const fmi1_value_reference_t vr[], size_t nvr, const fmi1_boolean_t value[]);\r
+typedef fmi1_status_t (*fmi1_set_string_ft) (fmi1_component_t c, const fmi1_value_reference_t vr[], size_t nvr, const fmi1_string_t value[]);\r
+typedef fmi1_status_t (*fmi1_get_real_ft) (fmi1_component_t c, const fmi1_value_reference_t vr[], size_t nvr, fmi1_real_t value[]);\r
+typedef fmi1_status_t (*fmi1_get_integer_ft) (fmi1_component_t c, const fmi1_value_reference_t vr[], size_t nvr, fmi1_integer_t value[]);\r
+typedef fmi1_status_t (*fmi1_get_boolean_ft) (fmi1_component_t c, const fmi1_value_reference_t vr[], size_t nvr, fmi1_boolean_t value[]);\r
+typedef fmi1_status_t (*fmi1_get_string_ft) (fmi1_component_t c, const fmi1_value_reference_t vr[], size_t nvr, fmi1_string_t value[]);\r
+\r
+/* FMI ME 1.0 functions */\r
+typedef const char* (*fmi1_get_model_typesPlatform_ft) (void);\r
+typedef fmi1_component_t (*fmi1_instantiate_model_ft) (fmi1_string_t instanceName, fmi1_string_t GUID, fmi1_me_callback_functions_t functions, fmi1_boolean_t loggingOn);\r
+typedef void (*fmi1_free_model_instance_ft) (fmi1_component_t c);\r
+typedef fmi1_status_t (*fmi1_set_time_ft) (fmi1_component_t c, fmi1_real_t time);\r
+typedef fmi1_status_t (*fmi1_set_continuous_states_ft) (fmi1_component_t c, const fmi1_real_t x[], size_t nx);\r
+typedef fmi1_status_t (*fmi1_completed_integrator_step_ft) (fmi1_component_t c, fmi1_boolean_t* callEventUpdate);\r
+typedef fmi1_status_t (*fmi1_initialize_ft) (fmi1_component_t c, fmi1_boolean_t toleranceControlled, fmi1_real_t relativeTolerance, fmi1_event_info_t* eventInfo);\r
+typedef fmi1_status_t (*fmi1_get_derivatives_ft) (fmi1_component_t c, fmi1_real_t derivatives[] , size_t nx);\r
+typedef fmi1_status_t (*fmi1_get_event_indicators_ft) (fmi1_component_t c, fmi1_real_t eventIndicators[], size_t ni);\r
+typedef fmi1_status_t (*fmi1_event_update_ft) (fmi1_component_t c, fmi1_boolean_t intermediateResults, fmi1_event_info_t* eventInfo);\r
+typedef fmi1_status_t (*fmi1_get_continuous_states_ft) (fmi1_component_t c, fmi1_real_t states[], size_t nx);\r
+typedef fmi1_status_t (*fmi1_get_nominal_continuousStates_ft) (fmi1_component_t c, fmi1_real_t x_nominal[], size_t nx);\r
+typedef fmi1_status_t (*fmi1_get_state_valueReferences_ft) (fmi1_component_t c, fmi1_value_reference_t vrx[], size_t nx);\r
+typedef fmi1_status_t (*fmi1_terminate_ft) (fmi1_component_t c); \r
+\r
+\r
+/* FMI CS 1.0 functions */\r
+typedef const char* (*fmi1_get_types_platform_ft) (void );\r
+typedef fmi1_component_t (*fmi1_instantiate_slave_ft) (fmi1_string_t instanceName, fmi1_string_t fmuGUID, fmi1_string_t fmuLocation, \r
+ fmi1_string_t mimeType, fmi1_real_t timeout, fmi1_boolean_t visible, fmi1_boolean_t interactive, \r
+ fmi1_callback_functions_t functions, fmi1_boolean_t loggingOn);\r
+typedef fmi1_status_t (*fmi1_initialize_slave_ft) (fmi1_component_t c, fmi1_real_t tStart, fmi1_boolean_t StopTimeDefined, fmi1_real_t tStop);\r
+typedef fmi1_status_t (*fmi1_terminate_slave_ft) (fmi1_component_t c);\r
+typedef fmi1_status_t (*fmi1_reset_slave_ft) (fmi1_component_t c);\r
+typedef void (*fmi1_free_slave_instance_ft) (fmi1_component_t c);\r
+typedef fmi1_status_t (*fmi1_set_real_inputDerivatives_ft) (fmi1_component_t c, const fmi1_value_reference_t vr[], size_t nvr, const fmi1_integer_t order[], const fmi1_real_t value[]); \r
+typedef fmi1_status_t (*fmi1_get_real_outputDerivatives_ft) (fmi1_component_t c, const fmi1_value_reference_t vr[], size_t nvr, const fmi1_integer_t order[], fmi1_real_t value[]); \r
+typedef fmi1_status_t (*fmi1_cancel_step_ft) (fmi1_component_t c);\r
+typedef fmi1_status_t (*fmi1_do_step_ft) (fmi1_component_t c, fmi1_real_t currentCommunicationPoint, fmi1_real_t communicationStepSize, fmi1_boolean_t newStep);\r
+\r
+typedef fmi1_status_t (*fmi1_get_status_ft) (fmi1_component_t c, const fmi1_status_kind_t s, fmi1_status_t* value);\r
+typedef fmi1_status_t (*fmi1_get_real_status_ft) (fmi1_component_t c, const fmi1_status_kind_t s, fmi1_real_t* value);\r
+typedef fmi1_status_t (*fmi1_get_integer_status_ft) (fmi1_component_t c, const fmi1_status_kind_t s, fmi1_integer_t* value);\r
+typedef fmi1_status_t (*fmi1_get_boolean_status_ft) (fmi1_component_t c, const fmi1_status_kind_t s, fmi1_boolean_t* value);\r
+typedef fmi1_status_t (*fmi1_get_string_status_ft) (fmi1_component_t c, const fmi1_status_kind_t s, fmi1_string_t* value); \r
+\r
+/** @}\r
+*/\r
+\r
+#endif /* End of header file FMI_FUNCTIONS_H_ */\r
--- /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>.
+*/\r
+\r
+#ifndef FMI1_TYPES_H_\r
+#define FMI1_TYPES_H_\r
+/** \file fmi1_types.h\r
+ Transformation of the standard FMI type names into fmi1_ prefixed.\r
+*/\r
+/**\r
+ \addtogroup jm_utils\r
+ @{\r
+ \addtogroup fmi1_utils\r
+ @}\r
+*/\r
+\r
+/** \addtogroup fmi1_utils Functions and types supporting FMI 1.0 processing.\r
+ @{\r
+*/\r
+/** \name Renaming of typedefs \r
+@{*/\r
+#define fmiComponent fmi1_component_t\r
+#define fmiValueReference fmi1_value_reference_t\r
+#define fmiReal fmi1_real_t\r
+#define fmiInteger fmi1_integer_t\r
+#define fmiBoolean fmi1_boolean_t\r
+#define fmiString fmi1_string_t\r
+/** @}*/\r
+/* Standard FMI 1.0 ME and CS types */\r
+#ifdef fmiPlatformTypes_h\r
+#undef fmiPlatformTypes_h\r
+#endif\r
+#include <FMI1/fmiPlatformTypes.h>\r
+#undef fmiPlatformTypes_h\r
+\r
+/** FMI platform name constant string.*/\r
+static const char * fmi1_get_platform(void) {\r
+ return fmiPlatform;\r
+}\r
+\r
+#undef fmiPlatform\r
+\r
+/** FMI boolean constants.*/\r
+typedef enum {\r
+ fmi1_true=fmiTrue,\r
+ fmi1_false=fmiFalse\r
+} fmi1_boolean_enu_t;\r
+\r
+#undef fmiTrue\r
+#undef fmiFalse\r
+\r
+/** Undefined value for fmiValueReference (largest unsigned int value) */\r
+typedef enum fmi1_value_reference_enu_t {\r
+ fmi1_undefined_value_reference = (int)fmiUndefinedValueReference\r
+} fmi1_value_reference_enu_t;\r
+\r
+/** \r
+ @}\r
+*/\r
+\r
+#undef fmiComponent\r
+#undef fmiValueReference\r
+#undef fmiReal\r
+#undef fmiInteger\r
+#undef fmiBoolean\r
+#undef fmiString\r
+#undef fmiUndefinedValueReference\r
+\r
+#endif /* End of header file FMI1_TYPES_H_ */
--- /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>.
+*/\r
+\r
+#ifndef FMI2_ENUMS_H_\r
+#define FMI2_ENUMS_H_\r
+\r
+#include <fmilib_config.h>\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+/** \file fmi2_enums.h \r
+ \brief Definions the enum types used with FMI 2.0 libs\r
+*/\r
+\r
+/** \addtogroup fmi2_utils\r
+ @{\r
+ \addtogroup fmi2_enums\r
+ @}\r
+*/
+/** \addtogroup fmi2_enums Enum types used with FMI 2.0 libs\r
+ @{\r
+*/\r
+/** \brief Naming convention for the variables in XML file*/\r
+typedef enum fmi2_variable_naming_convension_enu_t\r
+{ \r
+ fmi2_naming_enu_flat,\r
+ fmi2_naming_enu_structured,\r
+ fmi2_naming_enu_unknown\r
+} fmi2_variable_naming_convension_enu_t;\r
+\r
+/** \brief Convert a #fmi2_variable_naming_convension_enu_t constant into string */\r
+FMILIB_EXPORT const char* fmi2_naming_convention_to_string(fmi2_variable_naming_convension_enu_t convention);\r
+\r
+/** \brief FMU 2.0 kinds */\r
+typedef enum fmi2_fmu_kind_enu_t\r
+{\r
+ fmi2_fmu_kind_unknown = 0,\r
+ fmi2_fmu_kind_me = 1,\r
+ fmi2_fmu_kind_cs = 2,\r
+ fmi2_fmu_kind_me_and_cs = 3 /* defined to be equal to (fmi2_fmu_kind_me|fmi2_fmu_kind_cs) */\r
+} fmi2_fmu_kind_enu_t;\r
+\r
+/** \brief Convert a #fmi2_fmu_kind_enu_t constant into string */\r
+FMILIB_EXPORT const char* fmi2_fmu_kind_to_string(fmi2_fmu_kind_enu_t kind);\r
+\r
+/** \brief Variability property for variables */\r
+typedef enum fmi2_variability_enu_t {
+ fmi2_variability_enu_constant = 0,
+ fmi2_variability_enu_fixed = 1,
+ fmi2_variability_enu_tunable = 2,
+ fmi2_variability_enu_discrete = 3,
+ fmi2_variability_enu_continuous = 4,
+ fmi2_variability_enu_unknown = 5
+} fmi2_variability_enu_t;
+
+/** \brief Convert a #fmi2_variability_enu_t constant into string */
+FMILIB_EXPORT const char* fmi2_variability_to_string(fmi2_variability_enu_t v);
+
+/** \brief Causality property for variables */
+typedef enum fmi2_causality_enu_t {
+ fmi2_causality_enu_parameter = 0,
+ fmi2_causality_enu_calculated_parameter = 1,
+ fmi2_causality_enu_input = 2,
+ fmi2_causality_enu_output = 3,
+ fmi2_causality_enu_local = 4,
+ fmi2_causality_enu_independent = 5,
+ fmi2_causality_enu_unknown = 6
+} fmi2_causality_enu_t;
+
+/** \brief Convert a #fmi2_causality_enu_t constant into string */
+FMILIB_EXPORT const char* fmi2_causality_to_string(fmi2_causality_enu_t c);
+\r
+/** \brief Initial property for variables */
+typedef enum fmi2_initial_enu_t {
+ fmi2_initial_enu_exact,
+ fmi2_initial_enu_approx,
+ fmi2_initial_enu_calculated,
+ fmi2_initial_enu_unknown /* must be last*/
+} fmi2_initial_enu_t;
+
+/** \brief Convert a #fmi2_initial_enu_t constant into string */
+FMILIB_EXPORT const char* fmi2_initial_to_string(fmi2_initial_enu_t c);
+\r
+/** \r
+ \brief Get default initial attribute value for the given variability and causality combination.\r
+ \return The default initial attribute or fmi2_initial_enu_unknown if combination of causality\r
+ and variability is not valid.\r
+*/\r
+FMILIB_EXPORT fmi2_initial_enu_t fmi2_get_default_initial(fmi2_variability_enu_t v, fmi2_causality_enu_t c);\r
+\r
+/** \r
+ \brief Check if the combination of variability, causality and initial is valid.\r
+ \return Same initial as submitted if the combination is valid. Otherwise, same as fmi2_get_default_initial.\r
+*/\r
+FMILIB_EXPORT fmi2_initial_enu_t fmi2_get_valid_initial(fmi2_variability_enu_t v, fmi2_causality_enu_t c, fmi2_initial_enu_t i);\r
+\r
+/** \brief Alias property for variables */\r
+typedef enum fmi2_variable_alias_kind_enu_t {
+ fmi2_variable_is_not_alias = 0,
+ fmi2_variable_is_alias = 1
+} fmi2_variable_alias_kind_enu_t;
+
+/** \brief Base types used in type definitions */
+typedef enum fmi2_base_type_enu_t
+{
+ fmi2_base_type_real,
+ fmi2_base_type_int,
+ fmi2_base_type_bool,
+ fmi2_base_type_str,
+ fmi2_base_type_enum
+} fmi2_base_type_enu_t;
+
+/** \brief Convert base type constant to string
+ \param bt Base type identifier.
+ \return Corresponding base type name.
+ */
+FMILIB_EXPORT const char* fmi2_base_type_to_string(fmi2_base_type_enu_t bt);
+
+/** \brief List of capability flags for ModelExchange */
+#define FMI2_ME_CAPABILITIES(H) \
+ H(needsExecutionTool) \\r
+ H(completedIntegratorStepNotNeeded) \\r
+ H(canBeInstantiatedOnlyOncePerProcess) \\r
+ H(canNotUseMemoryManagementFunctions) \\r
+ H(canGetAndSetFMUstate) \\r
+ H(canSerializeFMUstate) \\r
+ H(providesDirectionalDerivatives)\\r
+ H(completedEventIterationIsProvided)\r
+
+/** \brief List of capability flags for CoSimulation */
+#define FMI2_CS_CAPABILITIES(H) \
+ H(needsExecutionTool) \\r
+ H(canHandleVariableCommunicationStepSize) \\r
+ H(canInterpolateInputs) \\r
+ H(maxOutputDerivativeOrder) \\r
+ H(canRunAsynchronuously) \\r
+ H(canBeInstantiatedOnlyOncePerProcess) \\r
+ H(canNotUseMemoryManagementFunctions) \\r
+ H(canGetAndSetFMUstate) \\r
+ H(canSerializeFMUstate) \\r
+ H(providesDirectionalDerivatives)\r
+
+/** \brief Capability flags for ModelExchange and CoSimulation */
+typedef enum fmi2_capabilities_enu_t {
+#define FMI2_EXPAND_ME_CAPABILITIES_ENU(c) fmi2_me_ ## c,
+#define FMI2_EXPAND_CS_CAPABILITIES_ENU(c) fmi2_cs_ ## c,
+ FMI2_ME_CAPABILITIES(FMI2_EXPAND_ME_CAPABILITIES_ENU)
+ FMI2_CS_CAPABILITIES(FMI2_EXPAND_CS_CAPABILITIES_ENU)
+ fmi2_capabilities_Num
+} fmi2_capabilities_enu_t;
+
+/** \brief Convert capability flag to a string
+ \param id Capability flag ID.
+ \return Name of the flag or Unknown if the id is out of range.
+*/
+FMILIB_EXPORT const char * fmi2_capability_to_string(fmi2_capabilities_enu_t id);
+
+/** \brief List of SI base units used in Unit defitions*/
+#define FMI2_SI_BASE_UNITS(H) \
+ H(kg) H(m) H(s) H(A) H(K) H(mol) H(cd) H(rad)
+
+/** \brief SI base units used in Unit defitions*/
+typedef enum fmi2_SI_base_units_enu_t {
+#define FMI2_EXPAND_SI_BASE_UNIT_ENU(c) fmi2_SI_base_unit_ ## c,
+ FMI2_SI_BASE_UNITS(FMI2_EXPAND_SI_BASE_UNIT_ENU)
+ fmi2_SI_base_units_Num
+} fmi2_SI_base_units_enu_t;
+
+/** \brief Convert SI base unit ID a string
+ \param id SI base unit ID.
+ \return Name of the base unit or "unknown" if the id is out of range.
+*/
+FMILIB_EXPORT const char * fmi2_SI_base_unit_to_string(fmi2_SI_base_units_enu_t id);
+
+/** \brief Convert a list of SI base unit exponents (corresponding to the IDs from fmi2_SI_base_units_enu_t)
+ to a string of the form kg*m^2/s^2. Prints '-' if all the exponents are zero.
+ \param exp An array of SI base units exponents.
+ \param bufSize Size of the buffer to store the string.
+ \param buf Buffer to store the string
+ \return Required size of the buffer to store the string. This most likely be under [8*fmi2_SI_base_units_Num].
+ If the return value is larger or equal than bufSize than the string could not be fitted in the buffer.
+*/
+FMILIB_EXPORT size_t fmi2_SI_base_unit_exp_to_string(const int exp[fmi2_SI_base_units_Num], size_t bufSize, char buf[]);
+
+
+/** \brief Dependency factor kinds are used as part of ModelStructure definition */
+typedef enum fmi2_dependency_factor_kind_enu_t
+{
+ fmi2_dependency_factor_kind_dependent = 0,
+ fmi2_dependency_factor_kind_constant,
+ fmi2_dependency_factor_kind_fixed,
+ fmi2_dependency_factor_kind_tunable,
+ fmi2_dependency_factor_kind_discrete,
+ fmi2_dependency_factor_kind_num
+} fmi2_dependency_factor_kind_enu_t;
+
+/** \brief Convert dependency factor kind constant to string
+ \param fc Dependency factor kind identifier.
+ \return Corresponding factor kind as string.
+ */
+FMILIB_EXPORT const char* fmi2_dependency_factor_kind_to_string(fmi2_dependency_factor_kind_enu_t fc);
+/** \r
+ @}\r
+*/
+#ifdef __cplusplus\r
+}\r
+#endif\r
+
+#endif /* End of header file FMI2_ENUMS_H_ */
--- /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>.
+*/\r
+\r
+#ifndef _FMI2_FUNCTION_TYPES_H_\r
+#define _FMI2_FUNCTION_TYPES_H_\r
+\r
+#include <string.h>\r
+#include <fmilib_config.h>\r
+\r
+#include "fmi2_types.h"\r
+/** \file fmi2_functions.h\r
+ Mapping for the standard FMI 2.0 functions into fmi2_ namespace.\r
+\r
+ \addtogroup fmi2_utils\r
+ @{\r
+*/
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+/* make sure all compiler use the same alignment policies for structures */\r
+#if defined _MSC_VER || defined __GNUC__\r
+#pragma pack(push,8)\r
+#endif\r
+\r
+\r
+/** FMI 2.0 status codes */\r
+typedef enum {\r
+ fmi2_status_ok,\r
+ fmi2_status_warning,\r
+ fmi2_status_discard,\r
+ fmi2_status_error,\r
+ fmi2_status_fatal,\r
+ fmi2_status_pending\r
+} fmi2_status_t;\r
+
+typedef enum {
+ fmi2_model_exchange,
+ fmi2_cosimulation
+} fmi2_type_t;
+
+
+/* Type definitions */\r
+\r
+/** Convert #fmi2_status_t variable to string */\r
+FMILIB_EXPORT const char* fmi2_status_to_string(fmi2_status_t status);\r
+\r
+/** FMI 2.0 logger function type */\r
+typedef void (*fmi2_callback_logger_ft) (fmi2_component_environment_t env, fmi2_string_t instanceName, fmi2_status_t status, fmi2_string_t category, fmi2_string_t message, ...);\r
+/** FMI 2.0 allocate memory function type */\r
+typedef void* (*fmi2_callback_allocate_memory_ft)(size_t nobj, size_t size);\r
+/** FMI 2.0 free memory function type */\r
+typedef void (*fmi2_callback_free_memory_ft) (void* obj);\r
+/** FMI 2.0 step finished callback function type */\r
+typedef void (*fmi2_step_finished_ft) (fmi2_component_environment_t env, fmi2_status_t status);\r
+\r
+/** The FMI 2.0 callbacks */\r
+typedef struct {\r
+ fmi2_callback_logger_ft logger;\r
+ fmi2_callback_allocate_memory_ft allocateMemory;\r
+ fmi2_callback_free_memory_ft freeMemory;\r
+ fmi2_step_finished_ft stepFinished;\r
+ fmi2_component_environment_t componentEnvironment;\r
+} fmi2_callback_functions_t;\r
+\r
+/** Event info structure as used in FMI 2.0 ME */\r
+/* TODO: reuse from fmiFunctions.h */
+typedef struct {
+ fmi2_boolean_t newDiscreteStatesNeeded;
+ fmi2_boolean_t terminateSimulation;
+ fmi2_boolean_t nominalsOfContinuousStatesChanged;
+ fmi2_boolean_t valuesOfContinuousStatesChanged;
+ fmi2_boolean_t nextEventTimeDefined;
+ fmi2_real_t nextEventTime;
+} fmi2_event_info_t;
+
+/** Co-simulation status for FMI 2.0 CS */\r
+/* TODO: reuse from fmiFunctions.h */
+typedef enum {\r
+ fmi2_do_step_status,\r
+ fmi2_pending_status,\r
+ fmi2_last_successful_time,\r
+ fmi2_terminated\r
+} fmi2_status_kind_t;\r
+\r
+\r
+\r
+/* reset alignment policy to the one set before reading this file */\r
+#if defined _MSC_VER || defined __GNUC__\r
+#pragma pack(pop)\r
+#endif\r
+\r
+/* Define fmi function pointer types to simplify dynamic loading */\r
+\r
+/***************************************************\r
+Types for Common Functions\r
+****************************************************/\r
+\r
+/* Inquire version numbers of header files and setting logging status */\r
+ typedef const char* (*fmi2_get_types_platform_ft)();\r
+ typedef const char* (*fmi2_get_version_ft)();\r
+ typedef fmi2_status_t (*fmi2_set_debug_logging_ft)(fmi2_component_t, fmi2_boolean_t,size_t nCategories, const fmi2_string_t categories[]);\r
+\r
+/* Creation and destruction of fmu instances and setting debug status */
+ typedef fmi2_component_t (*fmi2_instantiate_ft) (fmi2_string_t, fmi2_type_t, fmi2_string_t, fmi2_string_t, const fmi2_callback_functions_t*, fmi2_boolean_t, fmi2_boolean_t);
+ typedef void (*fmi2_free_instance_ft)(fmi2_component_t);
+
+/* Enter and exit initialization mode, terminate and reset */
+ typedef fmi2_status_t (*fmi2_setup_experiment_ft) (fmi2_component_t, fmi2_boolean_t, fmi2_real_t, fmi2_real_t, fmi2_boolean_t, fmi2_real_t);
+ typedef fmi2_status_t (*fmi2_enter_initialization_mode_ft) (fmi2_component_t);
+ typedef fmi2_status_t (*fmi2_exit_initialization_mode_ft) (fmi2_component_t);
+ typedef fmi2_status_t (*fmi2_terminate_ft) (fmi2_component_t);
+ typedef fmi2_status_t (*fmi2_reset_ft) (fmi2_component_t);
+
+/* Getting and setting variable values */\r
+ typedef fmi2_status_t (*fmi2_get_real_ft) (fmi2_component_t, const fmi2_value_reference_t[], size_t, fmi2_real_t []);\r
+ typedef fmi2_status_t (*fmi2_get_integer_ft)(fmi2_component_t, const fmi2_value_reference_t[], size_t, fmi2_integer_t[]);\r
+ typedef fmi2_status_t (*fmi2_get_boolean_ft)(fmi2_component_t, const fmi2_value_reference_t[], size_t, fmi2_boolean_t[]);\r
+ typedef fmi2_status_t (*fmi2_get_string_ft) (fmi2_component_t, const fmi2_value_reference_t[], size_t, fmi2_string_t []);\r
+\r
+ typedef fmi2_status_t (*fmi2_set_real_ft) (fmi2_component_t, const fmi2_value_reference_t[], size_t, const fmi2_real_t []);\r
+ typedef fmi2_status_t (*fmi2_set_integer_ft)(fmi2_component_t, const fmi2_value_reference_t[], size_t, const fmi2_integer_t[]);\r
+ typedef fmi2_status_t (*fmi2_set_boolean_ft)(fmi2_component_t, const fmi2_value_reference_t[], size_t, const fmi2_boolean_t[]);\r
+ typedef fmi2_status_t (*fmi2_set_string_ft) (fmi2_component_t, const fmi2_value_reference_t[], size_t, const fmi2_string_t []);\r
+\r
+/* Getting and setting the internal _fmu_ state */\r
+ typedef fmi2_status_t (*fmi2_get_fmu_state_ft) (fmi2_component_t, fmi2_FMU_state_t*);\r
+ typedef fmi2_status_t (*fmi2_set_fmu_state_ft) (fmi2_component_t, fmi2_FMU_state_t);\r
+ typedef fmi2_status_t (*fmi2_free_fmu_state_ft) (fmi2_component_t, fmi2_FMU_state_t*);\r
+ typedef fmi2_status_t (*fmi2_serialized_fmu_state_size_ft)(fmi2_component_t, fmi2_FMU_state_t, size_t*);\r
+ typedef fmi2_status_t (*fmi2_serialize_fmu_state_ft) (fmi2_component_t, fmi2_FMU_state_t, fmi2_byte_t[], size_t);\r
+ typedef fmi2_status_t (*fmi2_de_serialize_fmu_state_ft) (fmi2_component_t, const fmi2_byte_t[], size_t, fmi2_FMU_state_t*);\r
+\r
+/* Getting directional derivatives */
+ typedef fmi2_status_t (*fmi2_get_directional_derivative_ft)(fmi2_component_t, const fmi2_value_reference_t[], size_t,\r
+ const fmi2_value_reference_t[], size_t,\r
+ const fmi2_real_t[], fmi2_real_t[]);\r
+\r
+/***************************************************\r
+Types for Functions for FMI for Model Exchange\r
+****************************************************/\r
+\r
+/* Enter and exit the different modes */
+ typedef fmi2_status_t (*fmi2_enter_event_mode_ft) (fmi2_component_t);
+ typedef fmi2_status_t (*fmi2_new_discrete_states_ft) (fmi2_component_t, fmi2_event_info_t*);
+ typedef fmi2_status_t (*fmi2_enter_continuous_time_mode_ft)(fmi2_component_t);
+ typedef fmi2_status_t (*fmi2_completed_integrator_step_ft) (fmi2_component_t, fmi2_boolean_t, fmi2_boolean_t*, fmi2_boolean_t*);
+
+/* Providing independent variables and re-initialization of caching */\r
+ typedef fmi2_status_t (*fmi2_set_time_ft) (fmi2_component_t, fmi2_real_t);\r
+ typedef fmi2_status_t (*fmi2_set_continuous_states_ft) (fmi2_component_t, const fmi2_real_t[], size_t);\r
+\r
+/* Evaluation of the model equations */\r
+ typedef fmi2_status_t (*fmi2_get_derivatives_ft) (fmi2_component_t, fmi2_real_t[], size_t);\r
+ typedef fmi2_status_t (*fmi2_get_event_indicators_ft) (fmi2_component_t, fmi2_real_t[], size_t);\r
+ typedef fmi2_status_t (*fmi2_get_continuous_states_ft) (fmi2_component_t, fmi2_real_t[], size_t);\r
+ typedef fmi2_status_t (*fmi2_get_nominals_of_continuous_states_ft)(fmi2_component_t, fmi2_real_t[], size_t);\r
+\r
+\r
+/***************************************************\r
+Types for_functions for FMI for Co-_simulation\r
+****************************************************/\r
+\r
+/* Simulating the slave */\r
+ typedef fmi2_status_t (*fmi2_set_real_input_derivatives_ft) (fmi2_component_t, const fmi2_value_reference_t [], size_t, const fmi2_integer_t [], const fmi2_real_t []);\r
+ typedef fmi2_status_t (*fmi2_get_real_output_derivatives_ft)(fmi2_component_t, const fmi2_value_reference_t [], size_t, const fmi2_integer_t [], fmi2_real_t []);\r
+\r
+ typedef fmi2_status_t (*fmi2_do_step_ft) (fmi2_component_t, fmi2_real_t, fmi2_real_t, fmi2_boolean_t);\r
+ typedef fmi2_status_t (*fmi2_cancel_step_ft) (fmi2_component_t);\r
+\r
+/* Inquire slave status */\r
+ typedef fmi2_status_t (*fmi2_get_status_ft) (fmi2_component_t, const fmi2_status_kind_t, fmi2_status_t* );\r
+ typedef fmi2_status_t (*fmi2_get_real_status_ft) (fmi2_component_t, const fmi2_status_kind_t, fmi2_real_t* );\r
+ typedef fmi2_status_t (*fmi2_get_integer_status_ft)(fmi2_component_t, const fmi2_status_kind_t, fmi2_integer_t*);\r
+ typedef fmi2_status_t (*fmi2_get_boolean_status_ft)(fmi2_component_t, const fmi2_status_kind_t, fmi2_boolean_t*);\r
+ typedef fmi2_status_t (*fmi2_get_string_status_ft) (fmi2_component_t, const fmi2_status_kind_t, fmi2_string_t* );\r
+\r
+/** @}\r
+*/
+\r
+#ifdef __cplusplus\r
+} /* end of extern "C" { */\r
+#endif\r
+\r
+#endif /* fmi2_function_types_h */\r
--- /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>.
+*/\r
+\r
+#ifndef FMI2_TYPES_H_\r
+#define FMI2_TYPES_H_\r
+/** \file fmi2_types.h\r
+ Transformation of the standard FMI type names into fmi2_ prefixed.\r
+*/\r
+/**\r
+ \addtogroup jm_utils\r
+ @{\r
+ \addtogroup fmi2_utils\r
+ @}\r
+*/\r
+\r
+/** \addtogroup fmi2_utils Functions and types supporting FMI 2.0 processing.\r
+ @{\r
+*/\r
+/** \name Renaming of typedefs \r
+@{*/\r
+#define fmi2Component fmi2_component_t\r
+#define fmi2ComponentEnvironment fmi2_component_environment_t\r
+#define fmi2FMUstate fmi2_FMU_state_t\r
+#define fmi2ValueReference fmi2_value_reference_t\r
+#define fmi2Real fmi2_real_t\r
+#define fmi2Integer fmi2_integer_t\r
+#define fmi2Boolean fmi2_boolean_t\r
+#define fmi2Char fmi2_char_t\r
+#define fmi2String fmi2_string_t\r
+#define fmi2Byte fmi2_byte_t\r
+\r
+/** @}*/\r
+/* Standard FMI 2.0 types */\r
+#ifdef fmi2TypesPlatform_h\r
+#undef fmi2TypesPlatform_h\r
+#endif\r
+#include <FMI2/fmi2TypesPlatform.h>\r
+#undef fmi2TypesPlatform_h\r
+\r
+/** FMI platform name constant string.*/\r
+static const char * fmi2_get_types_platform(void) {\r
+ return fmi2TypesPlatform;\r
+}\r
+\r
+#undef fmi2TypesPlatform\r
+\r
+/** FMI boolean constants.*/\r
+typedef enum {\r
+ fmi2_true=fmi2True,\r
+ fmi2_false=fmi2False\r
+} fmi2_boolean_enu_t;\r
+\r
+#undef fmi2True\r
+#undef fmi2False\r
+\r
+/** \r
+ @}\r
+*/\r
+\r
+#undef fmi2Component\r
+#undef fmi2ValueReference\r
+#undef fmi2Real\r
+#undef fmi2Integer\r
+#undef fmi2Boolean\r
+#undef fmi2String\r
+#undef fmi2UndefinedValueReference\r
+\r
+#endif /* End of header file FMI2_TYPES_H_ */
--- /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>.
+*/
+
+#ifndef FMI2_XML_CALLBACKS_H
+#define FMI2_XML_CALLBACKS_H
+
+#include <fmilib_config.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/** \file fmi2_xml_callbacks.h Definition of ::fmi2_xml_callbacks_t and supporting functions
+ *
+ * \addtogroup fmi2_utils
+ * @{
+ \addtogroup fmi2_xml_callbacks
+ * @}
+*/
+/** \addtogroup fmi2_xml_callbacks Definition of XML callbacks struct
+* @{ */
+typedef struct fmi2_xml_callbacks_t fmi2_xml_callbacks_t;
+
+/** \name XML handling callbacks
+* @{
+*/
+/** \brief Handle start of an XML element within tool annotation in a SAX parser.
+*
+* @param context as specified when setting up the callbacks,
+* @param parentName - tool name as given by name attibute to the Tool elelent,
+* @param parent - NULL for model level annotations; fmi2_import_variable_t * variable pointer for variable annotations.
+* @param elm - name of the element,
+* @param attr - attributes (names and values).
+* The function should return 0 on success or error code on exit (in which case parsing will be aborted).
+*/
+typedef int (*fmi2_xml_element_start_handle_ft)( void *context, const char *toolName, void *parent, const char *elm, const char **attr);
+
+/** \brief Handle data of an XML element within tool annotation in a SAX parser.
+*
+* @param context as specified when setting up the callbacks
+* @param s - data string
+* @param len - length of the data.
+* The function should return 0 on success or error code on exit (in which case parsing will be aborted).
+*/
+typedef int (*fmi2_xml_element_data_handle_ft)(void* context, const char *s, int len);
+
+/** \brief Handle end of an XML element within tool annotation in a SAX parser.
+*
+* @param context as specified when setting up the callbacks
+* @param elm - name of the element.
+* The function should return 0 on success or error code on exit (in which case parsing will be aborted).
+*/
+typedef int (*fmi2_xml_element_end_handle_ft)(void *context, const char *elm);
+
+/** \brief XML callbacks are used to process parts of XML that are not handled by the library */
+struct fmi2_xml_callbacks_t {
+ fmi2_xml_element_start_handle_ft startHandle; /** \brief Handle start of an XML element within tool annotation in a SAX parser. */
+ fmi2_xml_element_data_handle_ft dataHandle; /** \brief Handle data of an XML element within tool annotation in a SAX parser. */
+ fmi2_xml_element_end_handle_ft endHandle; /** \brief Handle end of an XML element within tool annotation in a SAX parser. */
+ void* context; /** \breif Context ponter is forwarded to the handle functions. */
+};
+/* @}
+*/
+
+#ifdef __cplusplus
+}
+#endif
+/* JM_CONTEXT_H */
+#endif
--- /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>.
+*/
+
+#ifndef JM_CALLBACKS_H
+#define JM_CALLBACKS_H
+#include <stddef.h>
+#include <stdarg.h>
+
+#include <fmilib_config.h>
+
+#include "jm_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/** \file jm_callbacks.h Definition of ::jm_callbacks and supporting functions
+ *
+ * \addtogroup jm_utils
+ * @{
+ \addtogroup jm_callbacks
+ * @}
+*/
+/** \addtogroup jm_callbacks Definition of callbacks struct and supporting functions
+* @{ */
+typedef struct jm_callbacks jm_callbacks;
+
+/** \name Memory management callbacks\r
+* jm_malloc_f, jm_realloc_f, jm_calloc_f, jm_free_f function
+* types correspond to the standard C memory management functions
+* @{ \r
+*/
+/** \brief Allocation function type. */
+typedef jm_voidp (*jm_malloc_f)(size_t size);
+
+/** \brief Re-allocation function type. */
+typedef jm_voidp (*jm_realloc_f)(void *ptr, size_t size);
+
+/** \brief Zero-initialized allocation function type. */
+typedef jm_voidp (*jm_calloc_f)(size_t numitems, size_t itemsize);
+
+/** \brief Free memory function type. */
+typedef void (*jm_free_f)(jm_voidp p);
+/** @}\r
+*/
+
+/**
+*
+* \brief Logger callback type.
+*
+* The logger callback is used to report errors. Note that this function is
+* by default only used in FMI standard intependent code (e.g., fmi_import_get_fmi_version()).
+* Since logging functions are different between different standard versions separate
+* logging functions are necessary for each fmi implementation.\n
+* Defaults are provided for each standard.
+*/
+typedef void (*jm_logger_f)(jm_callbacks* c, jm_string module, jm_log_level_enu_t log_level, jm_string message);
+
+/** \brief Maximum message size that can be stored in the ::jm_callbacks struct */
+#define JM_MAX_ERROR_MESSAGE_SIZE 2000\r
+
+/** \brief The callbacks struct is sent to all the modules in the library */
+struct jm_callbacks {
+ /** \brief Allocate non-initialized memory */
+ jm_malloc_f malloc;
+ /** \brief Allocate zero initialized memory */
+ jm_calloc_f calloc;
+ /** \brief Re-allocate memory */
+ jm_realloc_f realloc;
+ /** \brief Free-allocated memory */
+ jm_free_f free;
+ /** \brief Logging callback */
+ jm_logger_f logger;
+ /** \brief Logging level */
+ jm_log_level_enu_t log_level;
+ /** \brief Arbitrary context pointer passed to the logger function */
+ jm_voidp context;
+ /** \brief The buffer used along with jm_get_last_error() */
+ char errMessageBuffer[JM_MAX_ERROR_MESSAGE_SIZE];
+};
+
+/**
+* \brief Get the last log message produced by the library.
+*
+* An alternative way to get error information is to use jm_get_last_error(). This is only meaningful
+* if logger function is not present.
+*/
+static jm_string jm_get_last_error(jm_callbacks* cb) {return cb->errMessageBuffer; }
+
+/**
+ \brief Clear the last generated log message.
+*/
+static void jm_clear_last_error(jm_callbacks* cb) { cb->errMessageBuffer[0] = 0; }
+
+/**
+\brief Set the structure to be returned by jm_get_default_callbacks().
+
+@param c - a pointer to initialized struct to be used as default later on. If this is NULL
+ library default implementation will be used.
+*/
+FMILIB_EXPORT
+void jm_set_default_callbacks(jm_callbacks* c);
+
+/**
+\brief Get default callbacks. The function never returns NULL.
+\return Default ::jm_callbacks struture. Either the one supplied by the library of the one set with jm_set_default_callbacks().
+*/
+FMILIB_EXPORT
+jm_callbacks* jm_get_default_callbacks(void);
+
+/**
+\brief The default logger implementation prints messages to stderr.
+*/
+FMILIB_EXPORT
+void jm_default_logger(jm_callbacks* c, jm_string module, jm_log_level_enu_t log_level, jm_string message);
+
+/**
+\brief Send a message to the logger function.
+ @param cb - callbacks to be used for reporting;
+ @param module - a name of reporting module;
+ @param log_level - message kind;
+ @param fmt - "printf" type of format followed by the arguments.
+*/
+FMILIB_EXPORT
+void jm_log(jm_callbacks* cb, const char* module, jm_log_level_enu_t log_level, const char* fmt, ...);
+
+/** \copydoc jm_log()
+ @param ap - variable size argument list.
+*/
+FMILIB_EXPORT
+void jm_log_v(jm_callbacks* cb, const char* module, jm_log_level_enu_t log_level, const char* fmt, va_list ap);
+
+/** \brief Send a fatal error message to the logger function. See jm_log() for details.
+*/
+FMILIB_EXPORT
+void jm_log_fatal_v(jm_callbacks* cb, const char* module, const char* fmt, va_list ap);
+/** \brief Send a fatal error message to the logger function. See jm_log() for details.
+*/
+FMILIB_EXPORT
+void jm_log_fatal(jm_callbacks* cb, const char* module, const char* fmt, ...);
+
+/** \brief Send a error message to the logger function. See jm_log() for details.
+*/
+FMILIB_EXPORT
+void jm_log_error_v(jm_callbacks* cb, const char* module, const char* fmt, va_list ap);
+
+/** \brief Send a error message to the logger function. See jm_log() for details.
+*/
+FMILIB_EXPORT
+void jm_log_error(jm_callbacks* cb, const char* module, const char* fmt, ...);
+
+/** \brief Send a warning message to the logger function. See jm_log() for details.
+*/
+FMILIB_EXPORT
+void jm_log_warning_v(jm_callbacks* cb, const char* module, const char* fmt, va_list ap);
+
+/** \brief Send a warning message to the logger function. See jm_log() for details.
+*/
+FMILIB_EXPORT
+void jm_log_warning(jm_callbacks* cb, const char* module, const char* fmt, ...);
+
+/** \brief Send an info message to the logger function. See jm_log() for details.
+*/
+FMILIB_EXPORT
+void jm_log_info_v(jm_callbacks* cb, const char* module, const char* fmt, va_list ap);
+/** \brief Send an info message to the logger function. See jm_log() for details.
+*/
+FMILIB_EXPORT
+void jm_log_info(jm_callbacks* cb, const char* module, const char* fmt, ...);
+
+/** \brief Send a verbose message to the logger function. See jm_log() for details.
+*/
+FMILIB_EXPORT
+void jm_log_verbose_v(jm_callbacks* cb, const char* module, const char* fmt, va_list ap);
+/** \brief Send a verbose message to the logger function. See jm_log() for details.
+*/
+FMILIB_EXPORT
+void jm_log_verbose(jm_callbacks* cb, const char* module, const char* fmt, ...);
+
+#ifdef FMILIB_ENABLE_LOG_LEVEL_DEBUG
+/** \brief Send a debug message to the logger function. See jm_log() for details.
+
+ Note that the function is only active if the library is configure with FMILIB_ENABLE_LOG_LEVEL_DEBUG=ON
+*/
+FMILIB_EXPORT
+void jm_log_debug_v(jm_callbacks* cb, const char* module, const char* fmt, va_list ap);
+/** \brief Send a debug message to the logger function. See jm_log() for details.
+
+ Note that the function is only active if the library is configure with FMILIB_ENABLE_LOG_LEVEL_DEBUG=ON
+*/
+FMILIB_EXPORT
+void jm_log_debug(jm_callbacks* cb, const char* module, const char* fmt, ...);
+#else
+/** \brief Send a debug message to the logger function. See jm_log() for details.
+
+ Note that the function is only active if the library is configure with FMILIB_ENABLE_LOG_LEVEL_DEBUG=ON
+*/
+static void jm_log_debug_v(jm_callbacks* cb, const char* module, const char* fmt, va_list ap) {}
+/** \brief Send a debug message to the logger function. See jm_log() for details.
+
+ Note that the function is only active if the library is configure with FMILIB_ENABLE_LOG_LEVEL_DEBUG=ON
+*/
+static void jm_log_debug(jm_callbacks* cb, const char* module, const char* fmt, ...) {}
+#endif
+
+
+/* @}\r
+*/
+
+#ifdef __cplusplus
+}
+#endif
+/* JM_CONTEXT_H */
+#endif
--- /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>.
+*/
+
+#ifndef JM_NAMED_PTR_H
+#define JM_NAMED_PTR_H
+
+#include "jm_vector.h"
+#include "jm_callbacks.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \file jm_named_ptr.h Definition of ::jm_named_ptr and supporting functions
+ *
+ * \addtogroup jm_utils
+ * @{
+ \addtogroup jm_named_ptr
+ * @}
+*/
+/** \addtogroup jm_named_ptr Named objects
+ @{
+*/
+/** \brief Name and object pointer pair */
+typedef struct jm_named_ptr jm_named_ptr;
+
+/** \brief Name and object pointer pair */
+struct jm_named_ptr {
+ jm_voidp ptr; /** \brief Object pointer */
+ jm_string name; /** \brief Name string */
+};
+
+/**
+\brief Allocate memory for the object and the name string and sets pointer to it packed together with the name pointer.
+ \param name Name for the object.
+ \param size Size of the data structure.
+ \param nameoffset Offset of the name field within the data structure.
+ \param c Callbacks to be used for memory allocation.
+
+The function jm_named_alloc() is intended for types defined as:
+\code
+struct T {
+ < some data fields>
+ char name[1];
+}
+\endcode
+The "name" is copied into the allocated memory.
+*/
+jm_named_ptr jm_named_alloc(jm_string name, size_t size, size_t nameoffset, jm_callbacks* c);
+
+/** \brief Same as jm_named_alloc() but name is given as a jm_vector(char) pointer */
+jm_named_ptr jm_named_alloc_v(jm_vector(char)* name, size_t size, size_t nameoffset, jm_callbacks* c);
+
+/** \brief Free the memory allocated for the object pointed by jm_named_ptr */
+static void jm_named_free(jm_named_ptr np, jm_callbacks* c) { c->free(np.ptr); }
+
+jm_vector_declare_template(jm_named_ptr)
+
+/** \brief Helper to construct comparison operation */
+#define jm_diff_named(a, b) strcmp(a.name,b.name)
+
+jm_define_comp_f(jm_compare_named, jm_named_ptr, jm_diff_named)
+
+/** \brief Release the data allocated by the items
+ in a vector and then clears the memory used by the vector as well.
+
+ This should be used for vectors initialized with jm_vector_init.
+*/
+static void jm_named_vector_free_data(jm_vector(jm_named_ptr)* v) {
+ jm_vector_foreach_c(jm_named_ptr)(v, (void (*)(jm_named_ptr, void*))jm_named_free,v->callbacks);
+ jm_vector_free_data(jm_named_ptr)(v);
+}
+
+/** \brief Release the data allocated by the items
+ in a vector and then clears the memory used by the vector as well.
+
+ This should be used for vectors created with jm_vector_alloc.
+*/
+static void jm_named_vector_free(jm_vector(jm_named_ptr)* v) {
+ jm_vector_foreach_c(jm_named_ptr)(v,(void (*)(jm_named_ptr, void*))jm_named_free,v->callbacks);
+ jm_vector_free(jm_named_ptr)(v);
+}
+/** @} */
+#ifdef __cplusplus
+}
+#endif
+
+/* JM_NAMED_PTR_H */
+#endif
--- /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>.
+*/\r
+\r
+#ifndef JM_PORTABILITY_H_\r
+#define JM_PORTABILITY_H_\r
+#include <fmilib_config.h>\r
+#include "jm_callbacks.h"\r
+\r
+/* Include platform dependent headers */\r
+#if defined(_MSC_VER) || defined(WIN32) || defined(__MINGW32__)\r
+#include <windows.h> /* Microsoft Windows API */\r
+#define DLL_HANDLE HANDLE\r
+#else\r
+#define DLL_HANDLE void*\r
+#include <dlfcn.h> /* Standard POSIX/UNIX API */\r
+#endif\r
+\r
+#include "jm_types.h"\r
+/** \file jm_portability.h\r
+ Handling platform specific defines and functions.\r
+*/\r
+/**\r
+ \addtogroup jm_utils\r
+ @{\r
+ \addtogroup jm_portability\r
+ @}\r
+*/\r
+/** \addtogroup jm_portability Handling platform specific defines and functions\r
+@{*/\r
+/** \brief Load a dll/so library into the process and return a handle. */\r
+DLL_HANDLE jm_portability_load_dll_handle (const char* dll_file_path);\r
+\r
+/** \brief Unload a Dll and release the handle*/\r
+jm_status_enu_t jm_portability_free_dll_handle (DLL_HANDLE dll_handle);\r
+\r
+/** \brief A function pointer as returned when DLL symbol is loaded.*/
+#ifdef WIN32
+#define jm_dll_function_ptr FARPROC
+#else
+typedef void* jm_dll_function_ptr;
+#endif
+\r
+/** \brief Find a function in the Dll and return a function pointer */\r
+jm_status_enu_t jm_portability_load_dll_function (DLL_HANDLE dll_handle, char* dll_function_name, jm_dll_function_ptr* dll_function_ptrptr);\r
+\r
+/** \brief Return error associated with Dll handling */\r
+char* jm_portability_get_last_dll_error (void);\r
+\r
+/** \brief Get current working directory name */\r
+jm_status_enu_t jm_portability_get_current_working_directory(char* buffer, size_t len);\r
+\r
+/** \brief Set current working directory*/\r
+jm_status_enu_t jm_portability_set_current_working_directory(const char* cwd);\r
+\r
+/** \brief Get system-wide temporary directory */\r
+const char* jm_get_system_temp_dir();\r
+\r
+/** \r
+ \brief Create a unique file name \r
+ \param tmplt File name template ending with XXXXXX.\r
+ \return A pointer to the modified template. The function returns NULL if \r
+ template is badly formed or no more unique names can be created from the given template.\r
+*/\r
+char* jm_mktemp(char* tmplt);\r
+\r
+\r
+/** \r
+ \brief Get absolute path to an existing directory\r
+ \param cb - callbacks for memory allocation and logging. Default callbacks are used if this parameter is NULL.\r
+ \param dir - path to a directory (relative or absolute).\r
+ \param outPath - buffer for storing the directory\r
+ \param len - of the buffer (if size is larger than FILENAME_MAX + 1 then the path will always fit in)\r
+ \return Pointer to outPath on success, 0 - on error in which case a message is send to the logger. \r
+*/\r
+char* jm_get_dir_abspath(jm_callbacks* cb, const char* dir, char* outPath, size_t len);\r
+\r
+/** \r
+ \brief Create a unique temporary directory\r
+ \param cb - callbacks for memory allocation and logging. Default callbacks are used if this parameter is NULL.\r
+ \param systemTempDir - directory where the temp dir should be located both absolute and relative path are accepted.\r
+ System-wide directory is used if this parameter is NULL.\r
+ \param tempPrefix - File name template prefix used when creating temporaty directories. "jm" is used if this is NULL.\r
+ \return A pointer to the temporary directory name (absolute path, no terminating '/'). Caller is responsible for freeing the memory.\r
+ The function returns NULL if there were errors in which case a message is send to the logger. \r
+*/\r
+char* jm_mk_temp_dir(jm_callbacks* cb, const char* systemTempDir, const char* tempPrefix);\r
+\r
+/** \r
+ \brief Create a file:// URL from absolute path\r
+ \param cb - callbacks for memory allocation and logging. Default callbacks are used if this parameter is NULL.\r
+ \param absPath - absolute path to be converted into the URL\r
+ \return A pointer to the URL. Caller is responsible for freeing the memory.\r
+ The function returns NULL if there were errors in which case a message is send to the logger. \r
+*/\r
+char* jm_create_URL_from_abs_path(jm_callbacks* cb, const char* absPath);\r
+\r
+/**\r
+ \brief Make a directory.\r
+*/\r
+jm_status_enu_t jm_mkdir(jm_callbacks* cb, const char* dir);\r
+\r
+/**\r
+\brief Remove directory and all it contents.\r
+*/\r
+jm_status_enu_t jm_rmdir(jm_callbacks* cb, const char* dir);\r
+\r
+/**\r
+\brief C89 compatible implementation of C99 vsnprintf. \r
+*/\r
+FMILIB_EXPORT
+int jm_vsnprintf(char * str, size_t size, const char * fmt, va_list al);
+
+/**\r
+\brief C89 compatible implementation of C99 snprintf. \r
+*/\r
+FMILIB_EXPORT\r
+int jm_snprintf(char * str, size_t size, const char * fmt, ...);
+\r
+#ifdef HAVE_VA_COPY
+#define JM_VA_COPY va_copy
+#elif defined(HAVE___VA_COPY)\r
+#define JM_VA_COPY __va_copy
+#elif defined(WIN32)
+#define JM_VA_COPY(dest,src) dest=src
+#endif
+\r
+/*@}*/\r
+#endif /* End of header file JM_PORTABILITY_H_ */\r
--- /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>.
+*/
+
+#ifndef jm_stack_h_
+#define jm_stack_h_
+
+#include "jm_vector.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** \file jm_named_ptr.h Definition of ::jm_named_ptr and supporting functions
+ *
+ * \addtogroup jm_utils
+ * @{
+ * \defgroup jm_stack_grp A basic stack
+ * @}
+ */
+
+ /** \addtogroup jm_stack_grp
+ @{
+ */
+/**
+ \brief A basic stack of items.
+
+ Stack is implemented on top of jm_vector right now. There is a couple of extra methonds that are convenient.
+
+ */
+#define jm_stack(T) jm_mangle(jm_stack, T)
+
+/**
+* \brief Allocates a stack with the given reserved memory
+* \code
+* jm_stack(T)* jm_stack_alloc(T)(size_t capacity,jm_callbacks*c );
+* \endcode
+* @param capacity - initial stack capacity, can be 0
+* @param c - jm_callbacks callbacks, can be zero
+* @return Newly allocated stack
+*/
+#define jm_stack_alloc(T) jm_mangle(jm_stack_alloc, T)
+
+/**
+* \brief Release memory allocated for a stack.
+\code
+extern void jm_stack_free(T)(jm_stack(T)* a);
+\endcode
+*/
+#define jm_stack_free(T) jm_mangle(jm_stack_free, T)
+
+/**
+* \brief Initializes a #jm_stack allocated on stack.
+* \param a - pointer to the stack to be initialized;
+* \param c - ::jm_callbacks callbacks, can be zero
+*
+* \code
+void jm_stack_init(T)(jm_stack(T)* a, jm_callbacks* c)
+ \endcode
+*/
+#define jm_stack_init(T) jm_mangle(jm_stack_init, T)
+
+/**
+* \brief Releases memory allocated for stack data.
+*
+* This only needs to be called both for stack allocated #jm_stack structs.
+*\code
+inline void jm_stack_free_data(T)(jm_stack(T)* a)
+\endcode
+*\param a - pointer to the stack.
+*
+*/
+#define jm_stack_free_data(T) jm_mangle(jm_stack_free_data, T)
+
+/**
+\brief Get the number of elements in the stack.
+
+\code
+inline size_t jm_stack_get_size(T)(jm_stack(T)* a)
+\endcode
+*/
+#define jm_stack_get_size(T) jm_mangle(jm_stack_get_size, T)
+
+/**
+* \brief Preallocate memory for the stack (to speed up consequent push).
+*
+* \return The actually reserved space. Can be smaller than "capacity" if memory allocation failed.
+* Can be larger than "capacity" if more memory was previously allocated.
+* size_t jm_stack_reserve(T)(jm_stack(T)* a, size_t capacity)
+*/
+#define jm_stack_reserve(T) jm_mangle(jm_stack_reserve, T)
+
+/**
+* \brief Put an element on the stack.
+* \return A pointer to the inserted element or zero pointer if failed.
+*
+\code
+T* jm_stack_push_back(jm_stack(T)* a, T item);
+\endcode
+*/
+#define jm_stack_push(T) jm_mangle(jm_stack_push, T)
+
+/**
+ jm_stack_is_empty returns 1 if the stack is empty and 0 otherwize.
+ int jm_stack_is_empty(jm_stack(T)*)
+ */
+#define jm_stack_is_empty(T) jm_mangle(jm_stack_is_empty, T)
+
+/**
+* jm_stack_pop gets the stack head and moves to the next element. Popping an empty stack gives assertion failure.
+* T jm_stack_pop(jm_stack(T)* a)
+*/
+#define jm_stack_pop(T) jm_mangle(jm_stack_pop, T)
+
+/**
+* jm_stack_top gets the stack top. Call on an empty stack gives assertion failure.
+* T jm_stack_top(jm_stack(T)* a)
+*/
+#define jm_stack_top(T) jm_mangle(jm_stack_top, T)
+
+/**
+* jm_stack_foreach calls f for each element in the stack. "data" parameter
+* is forwarded to the function as the second argument.
+* void jm_stack_foreach(T)(jm_stack(T)* a, void (*f)(T, void*), void * data)
+*/
+#define jm_stack_foreach(T) jm_mangle(jm_stack_foreach, T)
+
+
+/** minimal number of items always allocated for the stack */
+#define JM_STACK_MINIMAL_CAPACITY JM_VECTOR_MINIMAL_CAPACITY
+
+/** maximum memory chunk (in items) to be allocated in push. */
+#define JM_STACK_MAX_MEMORY_CHUNK JM_VECTOR_MAX_MEMORY_CHUNK
+
+/** Declare stack for the specific type. */
+#define jm_stack_declare_template(T) \
+typedef jm_vector(T) jm_stack(T); \
+ \
+static jm_stack(T)* jm_stack_alloc(T)(size_t capacity,jm_callbacks* c) { return jm_vector_alloc(T)(0, capacity, c); } \
+ \
+static void jm_stack_free(T)(jm_stack(T) * a) { jm_vector_free(T)(a); } \
+ \
+static void jm_stack_init(T)(jm_stack(T)* a, jm_callbacks* c) { jm_vector_init(T)(a,0,c); } \
+\
+static void jm_stack_free_data(T)(jm_stack(T)* a) { jm_vector_free_data(T)(a); } \
+\
+static size_t jm_stack_get_size(T)(jm_stack(T)* a) { return jm_vector_get_size(T)(a); } \
+\
+static size_t jm_stack_reserve(T)(jm_stack(T)* a, size_t capacity) { return jm_vector_reserve(T)(a, capacity); } \
+ \
+static T* jm_stack_push(T)(jm_stack(T)* a, T item) { return jm_vector_push_back(T)(a, item); }\
+ \
+static int jm_stack_is_empty(T)(jm_stack(T)* a) { return ((jm_stack_get_size(T)(a) > 0)? 0:1); } \
+ \
+static T jm_stack_top(T)(jm_stack(T)* a) { \
+ assert(!jm_stack_is_empty(T)(a)); \
+ return jm_vector_get_item(T)(a,jm_vector_get_size(T)(a)-1) ; \
+} \
+ \
+static T jm_stack_pop(T)(jm_stack(T)* a) { \
+ T ret; \
+ ret = jm_stack_top(T)(a); \
+ jm_vector_resize(T)(a, jm_vector_get_size(T)(a) - 1); \
+ return ret; \
+} \
+\
+static void jm_stack_foreach(T)(jm_stack(T)* a, void (*f)(T, void*), void * data) { jm_vector_foreach_c(T)(a,f,data); }
+
+/** @} */
+
+jm_stack_declare_template(char)
+jm_stack_declare_template(int)
+jm_stack_declare_template(double)
+jm_stack_declare_template(jm_voidp)
+jm_stack_declare_template(size_t)
+jm_stack_declare_template(jm_string)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /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>.
+*/
+
+#ifndef JM_STRING_SET_H
+#define JM_STRING_SET_H
+
+#include <string.h>
+
+#include "jm_types.h"
+#include "jm_vector.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+/** \file jm_string_set.h Definition of ::jm_string_set and supporting functions
+ *
+ * \addtogroup jm_utils
+ * @{
+ * \addtogroup jm_string_set_group
+ * @}
+ */
+
+ /** \addtogroup jm_string_set_group A set of strings
+ @{
+ */
+
+/**
+ \brief Set of string is based on a vector
+
+*/
+typedef struct jm_vector_jm_string jm_string_set; /* equivalent to "typedef jm_vector(jm_string) jm_string_set" which Doxygen does not understand */
+
+/**
+\brief Find a string in a set.
+
+\param s A string set.
+\param str Search string.
+\return If found returns a pointer to the string saved in the set. If not found returns NULL.
+*/
+static jm_string jm_string_set_find(jm_string_set* s, jm_string str) {
+ jm_string* found = jm_vector_find(jm_string)(s,&str,jm_compare_string);
+ if(found) return *found;
+ return 0;
+}
+
+/**
+* \brief Put an element in the set if it is not there yet.
+*
+* @param s A string set.
+* \param str String to put.
+* @return A pointer to the inserted (or found) element or zero pointer if failed.
+*/
+static jm_string jm_string_set_put(jm_string_set* s, jm_string str) {
+ jm_string found = jm_string_set_find(s, str);
+ if(found) return found;
+ {
+ char* newstr = 0;
+ size_t len = strlen(str) + 1;
+ jm_string* pnewstr = jm_vector_push_back(jm_string)(s, newstr);
+ if(pnewstr) *pnewstr = newstr = s->callbacks->malloc(len);
+ if(!pnewstr || !newstr) return 0;
+ memcpy(newstr, str, len);
+ jm_vector_qsort(jm_string)(s, jm_compare_string);
+ found = newstr;
+ }
+ return found;
+}
+/** @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* JM_STRING_SET_H */
--- /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>.
+*/
+
+#ifndef JM_TYPES_H
+#define JM_TYPES_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <fmilib_config.h>
+
+/**
+ @file jm_types.h Types used in the Utils module.
+
+ */
+/**
+\defgroup jm_utils Utilities
+\addtogroup jm_utils
+ * @{
+*/
+/** \brief A constant string.*/
+typedef const char* jm_string;
+/** \brief A void pointer.*/
+typedef void* jm_voidp;
+
+/** \brief Mapping between a string and an integer ID */
+typedef struct jm_name_ID_map_t {
+ jm_string name;
+ unsigned int ID;
+} jm_name_ID_map_t;
+
+/** \brief Return status codes */
+typedef enum {
+ jm_status_error = -1,
+ jm_status_success = 0,
+ jm_status_warning = 1
+} jm_status_enu_t;
+
+/** \brief Log levels supported via the logger functions in ::jm_callbacks */
+typedef enum {
+ jm_log_level_nothing = 0, /** \brief Must be first in this enum. May be usefull in application relying solely on jm_get_last_error() */
+ jm_log_level_fatal, /** \brief Unrecoverable errors */
+ jm_log_level_error, /** \brief Errors that may be not critical for some FMUs. */
+ jm_log_level_warning, /** \brief Non-critical issues */
+ jm_log_level_info, /** \brief Informative messages */
+ jm_log_level_verbose, /** \brief Verbose messages */
+ jm_log_level_debug, /** \brief Debug messages. Only enabled if library is configured with FMILIB_ENABLE_LOG_LEVEL_DEBUG */
+ jm_log_level_all /** \brief Must be last in this enum. */
+} jm_log_level_enu_t;
+
+/** \brief Convert log level into a string */
+FMILIB_EXPORT
+const char* jm_log_level_to_string(jm_log_level_enu_t level);
+
+/** @} */
+#ifdef __cplusplus
+}
+#endif
+
+/* JM_TYPES_H */
+#endif
--- /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>.
+*/
+
+#ifndef jm_vector_h_
+#define jm_vector_h_
+#include <assert.h>
+#include <string.h>
+
+#include "jm_callbacks.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+\file jm_vector.h Definition of ::jm_vector and supporting functions
+*/
+/**
+\addtogroup jm_utils
+ @{
+ \addtogroup jm_vector
+ @}
+*/
+
+/**
+\addtogroup jm_vector A vector of items (dynamic array)
+@{
+*/
+
+/** \brief jm_mange macro is used to construct names for the template instances
+ Extra level (jm_mange_ex) is needed to force argument expansion (pre-scan)
+*/
+#define jm_mangle_ex(name, type) name## _ ##type
+#define jm_mangle(name, type) jm_mangle_ex(name,type)
+
+/** \brief jm_vector(T) is the type name (i.e., to be used as jm_vector(int) vi;) */
+#define jm_vector(T) jm_mangle(jm_vector, T)
+
+/**
+* \name Vector handling functions.
+*
+* \brief Allocates a vector on heap with the specified size and specified number of preallocated items (can be larger than size).
+
+* extern jm_vector(T)* jm_vector_alloc(T)(size_t size, size_t capacity, jm_callbacks*c );
+* Note that there is no need to call jm_vector_init for a vector allocated with this function.
+* @param size - initial size of the vector, can be 0
+* @param capacity - initial capacity of the vector, can be 0. At least initSize elements are allocated.
+* @param c - jm_callbacks callbacks, can be zero
+* @return Newly allocated vector
+*/
+#define jm_vector_alloc(T) jm_mangle(jm_vector_alloc, T)
+
+/**
+ jm_vector_free releases the memory allocated by jm_vector_alloc.
+extern void jm_vector_free(T)(jm_vector(T)* a);
+*/
+#define jm_vector_free(T) jm_mangle(jm_vector_free, T)
+
+/**
+* \brief jm_vector_init initializes a vector allocated on stack.
+*
+* Input:
+* a - pointer to the vector to be initialized;
+* size - initial size of the vector, can be 0
+* c - jm_callbacks callbacks, can be zero
+* Returns:
+* size of the vector (can be zero for non-zero size if memory allocation failed)
+* Note that for initSize < JM_VECTOR_MINIMAL_CAPACITY no heap memory allocation is needed
+* size_t jm_vector_init(T)(jm_vector(T)* a, size_t initSize, jm_callbacks* c)
+*/
+#define jm_vector_init(T) jm_mangle(jm_vector_init, T)
+
+/**
+* jm_vector_free_data releases memory allocated for vector data
+* This only needs to be called for stack allocated vectors
+* (jm_vector_free does the job for heap vectors automatically)
+* inline void jm_vector_free_data(T)(jm_vector(T)* a)
+*/
+#define jm_vector_free_data(T) jm_mangle(jm_vector_free_data, T)
+
+/**
+ jm_vector_get_size get the vector size
+inline size_t jm_vector_get_size(T)(jm_vector(T)* a)
+*/
+#define jm_vector_get_size(T) jm_mangle(jm_vector_get_size, T)
+
+/**
+ jm_vector_get_item returns the specified item. Range checking is done with an assert.
+inline T jm_vector_get_item(jm_vector(T)* a, size_t index)
+*/
+#define jm_vector_get_item(T) jm_mangle(jm_vector_get_item, T)
+
+/**
+ jm_vector_get_itemp returns a pointer to the specified item. Range checking is done with an assert.
+inline T* jm_vector_get_itemp(jm_vector(T)* a, size_t index)
+*/
+#define jm_vector_get_itemp(T) jm_mangle(jm_vector_get_itemp, T)
+
+
+/**
+ jm_vector_get_lastp returns a pointer to the last item in the vector. It is an error to call this if size=0
+inline T jm_vector_get_last(jm_vector(T)* a)
+*/
+#define jm_vector_get_last(T) jm_mangle(jm_vector_get_last, T)
+
+/**
+ jm_vector_get_lastp returns a pointer to the last item in the vector. Zero pointer is returned if size=0
+inline T* jm_vector_get_lastp(jm_vector(T)* a)
+*/
+#define jm_vector_get_lastp(T) jm_mangle(jm_vector_get_lastp, T)
+
+/**
+\brief Function type for item comparison. Can be generated with jm_define_comp_f.
+
+*/
+typedef int (*jm_compare_ft) (const void* , const void*);
+
+/**
+\brief A conveniece macro for comparison function definition
+
+#define jm_define_comp_f(F, T, COMPAR_OP) is a conveniece macro for comparison function definition to be used in sort/search operations.
+Here F - is the defined function name;
+ T - type of the argument;
+ COMPAR_OP(A,B) is a macro that returns an integer less than, equal to, or greater than zero if the first argument
+is considered to be respectively less than, equal to, or greater than the second. If two members compare as
+equal, their order in the sorted array is undefined.
+Default definition below is jm_diff and is implemented as (int)(first-second)
+*/
+#define jm_define_comp_f(F, T, COMPAR_OP) \
+ static int F (const void* first, const void* second) { \
+ return COMPAR_OP( (*(T*)first), (*(T*)second)); \
+ } \
+
+#define jm_diff(first, second) (int)(first-second)
+
+/**
+ \brief jm_vector_find functions use linear search to find items in a vector. JM_COMPAR_OP is used for comparison.
+
+ T* jm_vector_find(T)(jm_vector(T)* a, T item, jm_compare_ft f)
+
+ size_t jm_vector_find_index(T)(jm_vector(T)* a, T item, jm_compare_ft f)
+
+ @param a - the vector;
+ @param item - the searched item;
+
+ Return:
+ T* jm_vector_find(T)(jm_vector(T)* a, T item, jm_compare_ft f) returns a pointer to the found item or NULL if not found
+ size_t jm_vector_find_index(T)(jm_vector(T)* a, T item, jm_compare_ft f) return the index of the found item or size of the vector if not found.
+*/
+#define jm_vector_find(T) jm_mangle(jm_vector_find, T)
+#define jm_vector_find_index(T) jm_mangle(jm_vector_find_index, T)
+
+/*
+ jm_vector_qsort uses standard quick sort to sort the vector contents.
+ JM_COMPAR_OP is used for comparison.
+
+ void jm_vector_qsort(T)(jm_vector(T)* v, jm_compare_ft f);
+*/
+#define jm_vector_qsort(T) jm_mangle(jm_vector_qsort, T)
+
+/**
+ jm_vector_bsearch uses standard binary search (bsearch) to find elements in a sorted vector.
+ It returns the index of an item in the vector or vector's size if not found.
+ JM_COMPAR_OP is used for comparison.
+
+ T* jm_vector_bsearch(T)(jm_vector(T)* v, T* key, jm_compare_ft f)
+ size_t jm_vector_bsearch_index(T)(jm_vector(T)* v, T* key, jm_compare_ft f)
+*/
+#define jm_vector_bsearch(T) jm_mangle(jm_vector_bsearch, T)
+#define jm_vector_bsearch_index(T) jm_mangle(jm_vector_bsearch_index, T)
+
+/**
+ jm_vector_set_item sets the specified item. Range checking is done with an assert.
+ void jm_vector_set_item(T)(jm_vector(T)* a, size_t index, T item)
+*/
+#define jm_vector_set_item(T) jm_mangle(jm_vector_set_item, T)
+
+/**
+ jm_vector_zero sets all elements in the vector to zero
+ void jm_vector_zero(T)(jm_vector(T)* a);
+ */
+#define jm_vector_zero(T) jm_mangle(jm_vector_zero, T)
+
+/**
+* jm_vector_resize resizes the vector
+* Input:
+* a - the vector
+* size - new size
+* Return:
+* size of the vector after operation. Can be less than size if memory allocation failed.
+* Note: resizing to smaller vector does not release memory.
+* size_t jm_vector_resize(T)(jm_vector(T)* a, size_t size)
+*/
+#define jm_vector_resize(T) jm_mangle(jm_vector_resize, T)
+
+/**
+* jm_vector_reserve preallocates memory for the vector (to speed up consequent push_back)
+* Returns: the actually reserved space. Can be smaller than requested "capacity" if memory allocation failed.
+* Can be larger than "capacity" if more memory was previously allocated.
+* size_t jm_vector_reserve(T)(jm_vector(T)* a, size_t capacity)
+*/
+#define jm_vector_reserve(T) jm_mangle(jm_vector_reserve, T)
+
+/**
+* jm_vector_copy copies source vector into destination.
+* Returns the number of elements actually copied (may be less than the source size if allocation failed).
+* size_t jm_vector_copy(T)(jm_vector(T)* destination, jm_vector(T)* source)
+*/
+#define jm_vector_copy(T) jm_mangle(jm_vector_copy, T)
+
+/**
+* jm_vector_clone creates a copy of the provided vector on heap and returns it.
+* Allocated capacity matches the size of the given vector. Returns the vector pointer or zero if memory allocation failed.
+* jm_vector(T)* jm_vector_clone(T)(jm_vector(T)* source)
+*/
+#define jm_vector_clone(T) jm_mangle(jm_vector_clone, T)
+
+/**
+* jm_vector_append appends source vector into destination.
+* Returns the number of elements actually appended (may be less than the source size if allocation failed).
+* size_t jm_vector_append(T)(jm_vector(T)* destination, jm_vector(T)* source)
+*/
+#define jm_vector_append(T) jm_mangle(jm_vector_append, T)
+
+/**
+* jm_vector_insert inserts an element at a given location.
+* Returns a pointer to the inserted element or zero pointer if failed
+* T* jm_vector_insert(T)(jm_vector(T)* a, size_t index, T item)
+*/
+#define jm_vector_insert(T) jm_mangle(jm_vector_insert, T)
+
+/**
+* jm_vector_remove_item removes an item from the vector.
+* Vector size is reduced by 1. Supplying index > size gives assertion fault.
+* void jm_vector_remove_item(T)(jm_vector(T)* v, size_t index)
+*/
+#define jm_vector_remove_item(T) jm_mangle(jm_vector_remove_item, T)
+
+/**
+* T* jm_vector_resize1(jm_vector(T)* a)
+* Increase the size of the vector by 1 and return a pointer to the last item.
+* Return 0 if memory allocation failed.
+*/
+#define jm_vector_resize1(T) jm_mangle(jm_vector_resize1, T)
+
+/**
+* jm_vector_push_back
+* Returns a pointer to the inserted element or zero pointer if failed.
+* T* jm_vector_push_back(jm_vector(T)* a, T item)
+*/
+#define jm_vector_push_back(T) jm_mangle(jm_vector_push_back, T)
+
+/**
+* jm_vector_foreach calls f for each element in the vector. "contect" parameter
+* is passed directly to the function as the second argument for the second version.
+* void jm_vector_foreach(T)(jm_vector(T)* a, void (*f)(T))
+* void jm_vector_foreach_c(T)(jm_vector(T)* a, void (*f)(T, void*), void * context)
+*/
+#define jm_vector_foreach(T) jm_mangle(jm_vector_foreach, T)
+#define jm_vector_foreach_c(T) jm_mangle(jm_vector_foreach_c, T)
+
+/** @} */
+
+/** number of items always allocated on the stack */
+#define JM_VECTOR_MINIMAL_CAPACITY 16
+
+/** maximum memory chunk (in items) to be allocated in push_back. */
+#define JM_VECTOR_MAX_MEMORY_CHUNK 1024
+
+/** Declare the struct and functions for the specified type. */
+#define jm_vector_declare_template(T) \
+typedef struct jm_vector(T) { \
+ jm_callbacks* callbacks; \
+ T *items; \
+ size_t size; \
+ size_t capacity; \
+ T preallocated[JM_VECTOR_MINIMAL_CAPACITY]; \
+} jm_vector(T); \
+ \
+extern jm_vector(T)* jm_vector_alloc(T)(size_t size,size_t capacity, jm_callbacks*); \
+ \
+extern size_t jm_vector_copy(T)(jm_vector(T)* destination, jm_vector(T)* source); \
+static jm_vector(T)* jm_vector_clone(T)(jm_vector(T)* v) { \
+ jm_vector(T)* ret = jm_vector_alloc(T)(v->size, v->size, v->callbacks);\
+ if(ret) jm_vector_copy(T)(ret, v) ; \
+ return ret; \
+}\
+ \
+extern void jm_vector_free(T)(jm_vector(T) * a); \
+ \
+extern size_t jm_vector_init(T)(jm_vector(T)* a, size_t size,jm_callbacks*); \
+\
+static void jm_vector_free_data(T)(jm_vector(T)* a) { \
+ if(a) { \
+ if(a->items != a->preallocated) { \
+ a->callbacks->free((void*)(a->items)); \
+ a->items = a->preallocated; \
+ a->capacity=JM_VECTOR_MINIMAL_CAPACITY;\
+ } \
+ a->size=0; \
+ } \
+} \
+ \
+static size_t jm_vector_get_size(T)(jm_vector(T)* a) { return a->size; } \
+\
+static T jm_vector_get_item(T)(jm_vector(T)* a, size_t index) { \
+ assert(index < a->size); \
+ return a->items[index]; \
+}\
+static T* jm_vector_get_itemp(T)(jm_vector(T)* a, size_t index) { \
+ assert(index < a->size); \
+ return (a->items+index); \
+}\
+ static T jm_vector_get_last(T)(jm_vector(T)* a) { \
+ assert(a->size); \
+ return (a->items[a->size-1]); \
+} \
+static T* jm_vector_get_lastp(T)(jm_vector(T)* a) { \
+ if(a->size) return (a->items+(a->size-1)); \
+ else return 0; \
+} \
+ static void jm_vector_set_item(T)(jm_vector(T)* a, size_t index, T item) {\
+ *(jm_vector_get_itemp(T)(a, index)) = item; \
+} \
+extern size_t jm_vector_resize(T)(jm_vector(T)* a, size_t size); \
+extern size_t jm_vector_reserve(T)(jm_vector(T)* a, size_t capacity); \
+extern size_t jm_vector_append(T)(jm_vector(T)* destination, jm_vector(T)* source); \
+extern T* jm_vector_insert(T)(jm_vector(T)* a, size_t index, T item);\
+extern T* jm_vector_push_back(T)(jm_vector(T)* a, T item);\
+extern T* jm_vector_resize1(T)(jm_vector(T)* a);\
+extern void jm_vector_remove_item(T)(jm_vector(T)* v, size_t index); \
+extern size_t jm_vector_find_index(T)(jm_vector(T)* a, T *itemp, jm_compare_ft f); \
+extern T* jm_vector_find(T)(jm_vector(T)* a, T *itemp, jm_compare_ft f); \
+extern void jm_vector_qsort(T)(jm_vector(T)* v, jm_compare_ft f); \
+extern size_t jm_vector_bsearch_index(T)(jm_vector(T)* v, T* key, jm_compare_ft f); \
+extern T* jm_vector_bsearch(T)(jm_vector(T)* v, T* key, jm_compare_ft f); \
+extern void jm_vector_foreach(T)(jm_vector(T)* a, void (*f)(T)); \
+extern void jm_vector_foreach_c(T)(jm_vector(T)* a, void (*f)(T, void*), void * data); \
+extern void jm_vector_zero(T)(jm_vector(T)* a);
+
+jm_vector_declare_template(char)
+static jm_string jm_vector_char2string(jm_vector(char)* v) {
+ jm_string str = "";
+ if(v->size) return v->items;
+ return str;
+}
+
+jm_vector_declare_template(int)
+jm_vector_declare_template(double)
+jm_vector_declare_template(jm_voidp)
+jm_vector_declare_template(size_t)
+jm_vector_declare_template(jm_string)
+jm_vector_declare_template(jm_name_ID_map_t)
+
+
+jm_define_comp_f(jm_compare_voidp, int*, jm_diff)
+jm_define_comp_f(jm_compare_int, int, jm_diff)
+jm_define_comp_f(jm_compare_char, char, jm_diff)
+jm_define_comp_f(jm_compare_double, double, jm_diff)
+jm_define_comp_f(jm_compare_size_t, size_t, jm_diff)
+jm_define_comp_f(jm_compare_string, jm_string, strcmp)
+
+#define jm_diff_name(a, b) strcmp(a.name,b.name)
+jm_define_comp_f(jm_compare_name, jm_name_ID_map_t, jm_diff_name)
+
+/**
+@}
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- /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>.
+*/
+
+/**
+* \file jm_vector_template.h
+* \brief Vector template definition.
+*
+* This file is supposed to be included into a C-file that instantiate the template.
+* jm_vector.h must be included before this file.
+* It expects JM_TEMPLATE_INSTANCE_TYPE to be defined to the template type to be instantiated.
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include "jm_vector.h"
+
+/** \addtogroup jm_vector A vector of items (dynamic array)*/
+/** @{
+*/
+
+#ifndef JM_TEMPLATE_INSTANCE_TYPE
+#error "JM_TEMPLATE_INSTANCE_TYPE must be defined before including this file"
+#endif
+
+jm_vector(JM_TEMPLATE_INSTANCE_TYPE) * jm_vector_alloc(JM_TEMPLATE_INSTANCE_TYPE) (size_t size, size_t capacity, jm_callbacks* c) {
+ size_t reserve;
+ jm_callbacks* cc;
+ jm_vector(JM_TEMPLATE_INSTANCE_TYPE) * v;
+ if(c)
+ cc = c;
+ else
+ cc = jm_get_default_callbacks();
+
+ reserve = capacity;
+ if(reserve < size) reserve = size;
+ if(reserve > JM_VECTOR_MINIMAL_CAPACITY) {
+ v = (jm_vector(JM_TEMPLATE_INSTANCE_TYPE)*)cc->malloc(
+ sizeof(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)) +
+ sizeof(JM_TEMPLATE_INSTANCE_TYPE) * (reserve -JM_VECTOR_MINIMAL_CAPACITY));
+ if(!v) return 0;
+ v->capacity = reserve;
+ }
+ else {
+ v = (jm_vector(JM_TEMPLATE_INSTANCE_TYPE)*)cc->malloc(sizeof(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)));
+ if(!v) return 0;
+ v->capacity = JM_VECTOR_MINIMAL_CAPACITY;
+ }
+ v->callbacks = cc;
+ v->items = &(v->preallocated[0]);
+ v->size = size;
+ return v;
+}
+
+void jm_vector_free(JM_TEMPLATE_INSTANCE_TYPE) (jm_vector(JM_TEMPLATE_INSTANCE_TYPE) * a) {
+ if(!a) return;
+ jm_vector_free_data(JM_TEMPLATE_INSTANCE_TYPE)(a);
+ a->callbacks->free(a);
+}
+
+size_t jm_vector_init(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* a, size_t initSize, jm_callbacks* c) {
+ if(c)
+ a->callbacks = c;
+ else
+ a->callbacks = jm_get_default_callbacks();
+ a->items = a->preallocated;
+ a->size = 0;
+ a->capacity = JM_VECTOR_MINIMAL_CAPACITY;
+
+ if(initSize > a->size)
+ return jm_vector_resize(JM_TEMPLATE_INSTANCE_TYPE)(a, initSize);
+ return 0;
+}
+
+size_t jm_vector_resize(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* a, size_t size) {
+ if(size > a->capacity) {
+ if(jm_vector_reserve(JM_TEMPLATE_INSTANCE_TYPE)(a, size) < size) {
+ a->size = a->capacity;
+ return a->capacity;
+ }
+ }
+ a->size = size;
+ return size;
+}
+
+size_t jm_vector_reserve(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* a, size_t size) {
+ void* newmem;
+ if(size <= a->capacity) return a->capacity;
+ newmem = a->callbacks->malloc(size * sizeof(JM_TEMPLATE_INSTANCE_TYPE));
+ if(!newmem) return a->capacity;
+ memcpy(newmem, a->items, a->size * sizeof(JM_TEMPLATE_INSTANCE_TYPE));
+ if(a->items != a->preallocated) a->callbacks->free((void*)(a->items));
+ a->items = newmem;
+ a->capacity = size;
+ return a->capacity;
+}
+
+size_t jm_vector_copy(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* destination, jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* source) {
+ size_t destsize = jm_vector_resize(JM_TEMPLATE_INSTANCE_TYPE)(destination, source->size);
+ memcpy((void*)destination->items, (void*)source->items, sizeof(JM_TEMPLATE_INSTANCE_TYPE)*destsize);
+ return destination->size;
+}
+
+size_t jm_vector_append(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* destination, jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* source) {
+ size_t oldsize, newsize;
+ oldsize = jm_vector_get_size(JM_TEMPLATE_INSTANCE_TYPE)(destination);
+ newsize = jm_vector_resize(JM_TEMPLATE_INSTANCE_TYPE)(destination, source->size + oldsize);
+ memcpy((void*)(destination->items + oldsize), (void*)source->items, sizeof(JM_TEMPLATE_INSTANCE_TYPE)*(newsize - oldsize));
+ return (newsize - oldsize);
+}
+
+JM_TEMPLATE_INSTANCE_TYPE* jm_vector_insert(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* a, size_t index, JM_TEMPLATE_INSTANCE_TYPE item) {
+ size_t reserve;
+ JM_TEMPLATE_INSTANCE_TYPE* pitem;
+ if(index >= a->size) return 0;
+ if(a->size == a->capacity) {
+ if(a->capacity > JM_VECTOR_MAX_MEMORY_CHUNK)
+ reserve = JM_VECTOR_MAX_MEMORY_CHUNK + a->capacity;
+ else
+ reserve = a->capacity * 2;
+ if( jm_vector_reserve(JM_TEMPLATE_INSTANCE_TYPE)(a, reserve) != reserve) return 0;
+ }
+ assert(a->size < a->capacity);
+ memmove((void*)(a->items+index+1),(void*)(a->items+index), a->size - index);
+ a->items[index] = item;
+ pitem = &(a->items[index]);
+ a->size++;
+ return pitem;
+}
+
+JM_TEMPLATE_INSTANCE_TYPE* jm_vector_resize1(JM_TEMPLATE_INSTANCE_TYPE) (jm_vector(JM_TEMPLATE_INSTANCE_TYPE) * a) {
+ size_t reserve;
+ JM_TEMPLATE_INSTANCE_TYPE* pitem;
+ if(a->size == a->capacity) {
+ if(a->capacity > JM_VECTOR_MAX_MEMORY_CHUNK)
+ reserve = JM_VECTOR_MAX_MEMORY_CHUNK + a->capacity;
+ else
+ reserve = a->capacity * 2;
+ if( jm_vector_reserve(JM_TEMPLATE_INSTANCE_TYPE)(a, reserve) != reserve) return 0;
+ }
+ assert(a->size < a->capacity);
+ pitem = &(a->items[a->size]);
+ a->size++;
+ return pitem;
+}
+
+JM_TEMPLATE_INSTANCE_TYPE* jm_vector_push_back(JM_TEMPLATE_INSTANCE_TYPE) (jm_vector(JM_TEMPLATE_INSTANCE_TYPE) * a, JM_TEMPLATE_INSTANCE_TYPE item) {
+ JM_TEMPLATE_INSTANCE_TYPE* pitem= jm_vector_resize1(JM_TEMPLATE_INSTANCE_TYPE) (a);
+ if(!pitem) return 0;
+ *pitem = item;
+ return pitem;
+}
+
+void jm_vector_remove_item(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* v, size_t index) {
+ size_t n =v->size - index -1;
+ assert(index < v->size);
+ if(n) {
+ memmove((void*)&(v->items[index]),(void*) &(v->items[index+1]), n * sizeof(JM_TEMPLATE_INSTANCE_TYPE));
+ }
+ v->size--;
+}
+
+void jm_vector_zero(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* a) {
+ if(jm_vector_get_size(JM_TEMPLATE_INSTANCE_TYPE)(a) > 0) {
+ memset((void*)a->items,0,a->size * sizeof(JM_TEMPLATE_INSTANCE_TYPE));
+ }
+}
+
+void jm_vector_foreach_c(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* a,
+ void (*f)(JM_TEMPLATE_INSTANCE_TYPE, void*), void * data) {
+ size_t i;
+ for(i = 0; i < jm_vector_get_size(JM_TEMPLATE_INSTANCE_TYPE)(a); i++)
+ f(jm_vector_get_item(JM_TEMPLATE_INSTANCE_TYPE)(a, i), data);
+}
+
+void jm_vector_foreach(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* a,
+ void (*f)(JM_TEMPLATE_INSTANCE_TYPE)) {
+ size_t i;
+ for(i = 0; i < jm_vector_get_size(JM_TEMPLATE_INSTANCE_TYPE)(a); i++)
+ f(jm_vector_get_item(JM_TEMPLATE_INSTANCE_TYPE)(a, i));
+}
+
+void jm_vector_qsort(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* v, jm_compare_ft f) {
+ if(jm_vector_get_size(JM_TEMPLATE_INSTANCE_TYPE)(v) > 1) {
+ qsort((void*)v->items, jm_vector_get_size(JM_TEMPLATE_INSTANCE_TYPE)(v), sizeof(JM_TEMPLATE_INSTANCE_TYPE),f);
+ }
+}
+
+#define jm_vector_ptr2index(T) jm_mangle(jm_vector_ptr2index, T)
+
+static size_t jm_vector_ptr2index(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* v, JM_TEMPLATE_INSTANCE_TYPE* itemp) {
+ if(itemp)
+ return (itemp - v->items);
+ else
+ return jm_vector_get_size(JM_TEMPLATE_INSTANCE_TYPE)(v);
+}
+
+
+size_t jm_vector_bsearch_index(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* v, JM_TEMPLATE_INSTANCE_TYPE* key, jm_compare_ft f) {
+ return jm_vector_ptr2index(JM_TEMPLATE_INSTANCE_TYPE)(v, jm_vector_bsearch(JM_TEMPLATE_INSTANCE_TYPE)(v, key,f));
+}
+
+JM_TEMPLATE_INSTANCE_TYPE* jm_vector_bsearch(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* v, JM_TEMPLATE_INSTANCE_TYPE* key, jm_compare_ft f) {
+ return bsearch(key, v->items,
+ jm_vector_get_size(JM_TEMPLATE_INSTANCE_TYPE)(v),
+ sizeof(JM_TEMPLATE_INSTANCE_TYPE),
+ f);
+}
+
+JM_TEMPLATE_INSTANCE_TYPE* jm_vector_find(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* a, JM_TEMPLATE_INSTANCE_TYPE* itemp, jm_compare_ft f) {
+ size_t i = jm_vector_get_size(JM_TEMPLATE_INSTANCE_TYPE)(a);
+ while(i--) {
+ JM_TEMPLATE_INSTANCE_TYPE* cur = jm_vector_get_itemp(JM_TEMPLATE_INSTANCE_TYPE)(a, i);
+ if(f(cur, itemp) == 0)
+ return cur;
+ };
+ return 0;
+}
+
+size_t jm_vector_find_index(JM_TEMPLATE_INSTANCE_TYPE)(jm_vector(JM_TEMPLATE_INSTANCE_TYPE)* v, JM_TEMPLATE_INSTANCE_TYPE* itemp, jm_compare_ft f) {
+ return jm_vector_ptr2index(JM_TEMPLATE_INSTANCE_TYPE)(v,jm_vector_find(JM_TEMPLATE_INSTANCE_TYPE)(v, itemp, f));
+}
+
+/** @}
+*/
\ No newline at end of file
--- /dev/null
+/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd\r
+ See the file COPYING for copying permission.\r
+*/\r
+\r
+#ifndef Expat_INCLUDED\r
+#define Expat_INCLUDED 1\r
+\r
+#ifdef __VMS\r
+/* 0 1 2 3 0 1 2 3\r
+ 1234567890123456789012345678901 1234567890123456789012345678901 */\r
+#define XML_SetProcessingInstructionHandler XML_SetProcessingInstrHandler\r
+#define XML_SetUnparsedEntityDeclHandler XML_SetUnparsedEntDeclHandler\r
+#define XML_SetStartNamespaceDeclHandler XML_SetStartNamespcDeclHandler\r
+#define XML_SetExternalEntityRefHandlerArg XML_SetExternalEntRefHandlerArg\r
+#endif\r
+\r
+#include <stdlib.h>\r
+#include "expat_external.h"\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+struct XML_ParserStruct;\r
+typedef struct XML_ParserStruct *XML_Parser;\r
+\r
+/* Should this be defined using stdbool.h when C99 is available? */\r
+typedef unsigned char XML_Bool;\r
+#define XML_TRUE ((XML_Bool) 1)\r
+#define XML_FALSE ((XML_Bool) 0)\r
+\r
+/* The XML_Status enum gives the possible return values for several\r
+ API functions. The preprocessor #defines are included so this\r
+ stanza can be added to code that still needs to support older\r
+ versions of Expat 1.95.x:\r
+\r
+ #ifndef XML_STATUS_OK\r
+ #define XML_STATUS_OK 1\r
+ #define XML_STATUS_ERROR 0\r
+ #endif\r
+\r
+ Otherwise, the #define hackery is quite ugly and would have been\r
+ dropped.\r
+*/\r
+enum XML_Status {\r
+ XML_STATUS_ERROR = 0,\r
+#define XML_STATUS_ERROR XML_STATUS_ERROR\r
+ XML_STATUS_OK = 1,\r
+#define XML_STATUS_OK XML_STATUS_OK\r
+ XML_STATUS_SUSPENDED = 2\r
+#define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED\r
+};\r
+\r
+enum XML_Error {\r
+ XML_ERROR_NONE,\r
+ XML_ERROR_NO_MEMORY,\r
+ XML_ERROR_SYNTAX,\r
+ XML_ERROR_NO_ELEMENTS,\r
+ XML_ERROR_INVALID_TOKEN,\r
+ XML_ERROR_UNCLOSED_TOKEN,\r
+ XML_ERROR_PARTIAL_CHAR,\r
+ XML_ERROR_TAG_MISMATCH,\r
+ XML_ERROR_DUPLICATE_ATTRIBUTE,\r
+ XML_ERROR_JUNK_AFTER_DOC_ELEMENT,\r
+ XML_ERROR_PARAM_ENTITY_REF,\r
+ XML_ERROR_UNDEFINED_ENTITY,\r
+ XML_ERROR_RECURSIVE_ENTITY_REF,\r
+ XML_ERROR_ASYNC_ENTITY,\r
+ XML_ERROR_BAD_CHAR_REF,\r
+ XML_ERROR_BINARY_ENTITY_REF,\r
+ XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,\r
+ XML_ERROR_MISPLACED_XML_PI,\r
+ XML_ERROR_UNKNOWN_ENCODING,\r
+ XML_ERROR_INCORRECT_ENCODING,\r
+ XML_ERROR_UNCLOSED_CDATA_SECTION,\r
+ XML_ERROR_EXTERNAL_ENTITY_HANDLING,\r
+ XML_ERROR_NOT_STANDALONE,\r
+ XML_ERROR_UNEXPECTED_STATE,\r
+ XML_ERROR_ENTITY_DECLARED_IN_PE,\r
+ XML_ERROR_FEATURE_REQUIRES_XML_DTD,\r
+ XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,\r
+ /* Added in 1.95.7. */\r
+ XML_ERROR_UNBOUND_PREFIX,\r
+ /* Added in 1.95.8. */\r
+ XML_ERROR_UNDECLARING_PREFIX,\r
+ XML_ERROR_INCOMPLETE_PE,\r
+ XML_ERROR_XML_DECL,\r
+ XML_ERROR_TEXT_DECL,\r
+ XML_ERROR_PUBLICID,\r
+ XML_ERROR_SUSPENDED,\r
+ XML_ERROR_NOT_SUSPENDED,\r
+ XML_ERROR_ABORTED,\r
+ XML_ERROR_FINISHED,\r
+ XML_ERROR_SUSPEND_PE,\r
+ /* Added in 2.0. */\r
+ XML_ERROR_RESERVED_PREFIX_XML,\r
+ XML_ERROR_RESERVED_PREFIX_XMLNS,\r
+ XML_ERROR_RESERVED_NAMESPACE_URI\r
+};\r
+\r
+enum XML_Content_Type {\r
+ XML_CTYPE_EMPTY = 1,\r
+ XML_CTYPE_ANY,\r
+ XML_CTYPE_MIXED,\r
+ XML_CTYPE_NAME,\r
+ XML_CTYPE_CHOICE,\r
+ XML_CTYPE_SEQ\r
+};\r
+\r
+enum XML_Content_Quant {\r
+ XML_CQUANT_NONE,\r
+ XML_CQUANT_OPT,\r
+ XML_CQUANT_REP,\r
+ XML_CQUANT_PLUS\r
+};\r
+\r
+/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be\r
+ XML_CQUANT_NONE, and the other fields will be zero or NULL.\r
+ If type == XML_CTYPE_MIXED, then quant will be NONE or REP and\r
+ numchildren will contain number of elements that may be mixed in\r
+ and children point to an array of XML_Content cells that will be\r
+ all of XML_CTYPE_NAME type with no quantification.\r
+\r
+ If type == XML_CTYPE_NAME, then the name points to the name, and\r
+ the numchildren field will be zero and children will be NULL. The\r
+ quant fields indicates any quantifiers placed on the name.\r
+\r
+ CHOICE and SEQ will have name NULL, the number of children in\r
+ numchildren and children will point, recursively, to an array\r
+ of XML_Content cells.\r
+\r
+ The EMPTY, ANY, and MIXED types will only occur at top level.\r
+*/\r
+\r
+typedef struct XML_cp XML_Content;\r
+\r
+struct XML_cp {\r
+ enum XML_Content_Type type;\r
+ enum XML_Content_Quant quant;\r
+ XML_Char * name;\r
+ unsigned int numchildren;\r
+ XML_Content * children;\r
+};\r
+\r
+\r
+/* This is called for an element declaration. See above for\r
+ description of the model argument. It's the caller's responsibility\r
+ to free model when finished with it.\r
+*/\r
+typedef void (XMLCALL *XML_ElementDeclHandler) (void *userData,\r
+ const XML_Char *name,\r
+ XML_Content *model);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetElementDeclHandler(XML_Parser parser,\r
+ XML_ElementDeclHandler eldecl);\r
+\r
+/* The Attlist declaration handler is called for *each* attribute. So\r
+ a single Attlist declaration with multiple attributes declared will\r
+ generate multiple calls to this handler. The "default" parameter\r
+ may be NULL in the case of the "#IMPLIED" or "#REQUIRED"\r
+ keyword. The "isrequired" parameter will be true and the default\r
+ value will be NULL in the case of "#REQUIRED". If "isrequired" is\r
+ true and default is non-NULL, then this is a "#FIXED" default.\r
+*/\r
+typedef void (XMLCALL *XML_AttlistDeclHandler) (\r
+ void *userData,\r
+ const XML_Char *elname,\r
+ const XML_Char *attname,\r
+ const XML_Char *att_type,\r
+ const XML_Char *dflt,\r
+ int isrequired);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetAttlistDeclHandler(XML_Parser parser,\r
+ XML_AttlistDeclHandler attdecl);\r
+\r
+/* The XML declaration handler is called for *both* XML declarations\r
+ and text declarations. The way to distinguish is that the version\r
+ parameter will be NULL for text declarations. The encoding\r
+ parameter may be NULL for XML declarations. The standalone\r
+ parameter will be -1, 0, or 1 indicating respectively that there\r
+ was no standalone parameter in the declaration, that it was given\r
+ as no, or that it was given as yes.\r
+*/\r
+typedef void (XMLCALL *XML_XmlDeclHandler) (void *userData,\r
+ const XML_Char *version,\r
+ const XML_Char *encoding,\r
+ int standalone);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetXmlDeclHandler(XML_Parser parser,\r
+ XML_XmlDeclHandler xmldecl);\r
+\r
+\r
+typedef struct {\r
+ void *(*malloc_fcn)(size_t size);\r
+ void *(*realloc_fcn)(void *ptr, size_t size);\r
+ void (*free_fcn)(void *ptr);\r
+} XML_Memory_Handling_Suite;\r
+\r
+/* Constructs a new parser; encoding is the encoding specified by the\r
+ external protocol or NULL if there is none specified.\r
+*/\r
+XMLPARSEAPI(XML_Parser)\r
+XML_ParserCreate(const XML_Char *encoding);\r
+\r
+/* Constructs a new parser and namespace processor. Element type\r
+ names and attribute names that belong to a namespace will be\r
+ expanded; unprefixed attribute names are never expanded; unprefixed\r
+ element type names are expanded only if there is a default\r
+ namespace. The expanded name is the concatenation of the namespace\r
+ URI, the namespace separator character, and the local part of the\r
+ name. If the namespace separator is '\0' then the namespace URI\r
+ and the local part will be concatenated without any separator.\r
+ It is a programming error to use the separator '\0' with namespace\r
+ triplets (see XML_SetReturnNSTriplet).\r
+*/\r
+XMLPARSEAPI(XML_Parser)\r
+XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);\r
+\r
+\r
+/* Constructs a new parser using the memory management suite referred to\r
+ by memsuite. If memsuite is NULL, then use the standard library memory\r
+ suite. If namespaceSeparator is non-NULL it creates a parser with\r
+ namespace processing as described above. The character pointed at\r
+ will serve as the namespace separator.\r
+\r
+ All further memory operations used for the created parser will come from\r
+ the given suite.\r
+*/\r
+XMLPARSEAPI(XML_Parser)\r
+XML_ParserCreate_MM(const XML_Char *encoding,\r
+ const XML_Memory_Handling_Suite *memsuite,\r
+ const XML_Char *namespaceSeparator);\r
+\r
+/* Prepare a parser object to be re-used. This is particularly\r
+ valuable when memory allocation overhead is disproportionatly high,\r
+ such as when a large number of small documnents need to be parsed.\r
+ All handlers are cleared from the parser, except for the\r
+ unknownEncodingHandler. The parser's external state is re-initialized\r
+ except for the values of ns and ns_triplets.\r
+\r
+ Added in Expat 1.95.3.\r
+*/\r
+XMLPARSEAPI(XML_Bool)\r
+XML_ParserReset(XML_Parser parser, const XML_Char *encoding);\r
+\r
+/* atts is array of name/value pairs, terminated by 0;\r
+ names and values are 0 terminated.\r
+*/\r
+typedef void (XMLCALL *XML_StartElementHandler) (void *userData,\r
+ const XML_Char *name,\r
+ const XML_Char **atts);\r
+\r
+typedef void (XMLCALL *XML_EndElementHandler) (void *userData,\r
+ const XML_Char *name);\r
+\r
+\r
+/* s is not 0 terminated. */\r
+typedef void (XMLCALL *XML_CharacterDataHandler) (void *userData,\r
+ const XML_Char *s,\r
+ int len);\r
+\r
+/* target and data are 0 terminated */\r
+typedef void (XMLCALL *XML_ProcessingInstructionHandler) (\r
+ void *userData,\r
+ const XML_Char *target,\r
+ const XML_Char *data);\r
+\r
+/* data is 0 terminated */\r
+typedef void (XMLCALL *XML_CommentHandler) (void *userData,\r
+ const XML_Char *data);\r
+\r
+typedef void (XMLCALL *XML_StartCdataSectionHandler) (void *userData);\r
+typedef void (XMLCALL *XML_EndCdataSectionHandler) (void *userData);\r
+\r
+/* This is called for any characters in the XML document for which\r
+ there is no applicable handler. This includes both characters that\r
+ are part of markup which is of a kind that is not reported\r
+ (comments, markup declarations), or characters that are part of a\r
+ construct which could be reported but for which no handler has been\r
+ supplied. The characters are passed exactly as they were in the XML\r
+ document except that they will be encoded in UTF-8 or UTF-16.\r
+ Line boundaries are not normalized. Note that a byte order mark\r
+ character is not passed to the default handler. There are no\r
+ guarantees about how characters are divided between calls to the\r
+ default handler: for example, a comment might be split between\r
+ multiple calls.\r
+*/\r
+typedef void (XMLCALL *XML_DefaultHandler) (void *userData,\r
+ const XML_Char *s,\r
+ int len);\r
+\r
+/* This is called for the start of the DOCTYPE declaration, before\r
+ any DTD or internal subset is parsed.\r
+*/\r
+typedef void (XMLCALL *XML_StartDoctypeDeclHandler) (\r
+ void *userData,\r
+ const XML_Char *doctypeName,\r
+ const XML_Char *sysid,\r
+ const XML_Char *pubid,\r
+ int has_internal_subset);\r
+\r
+/* This is called for the start of the DOCTYPE declaration when the\r
+ closing > is encountered, but after processing any external\r
+ subset.\r
+*/\r
+typedef void (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);\r
+\r
+/* This is called for entity declarations. The is_parameter_entity\r
+ argument will be non-zero if the entity is a parameter entity, zero\r
+ otherwise.\r
+\r
+ For internal entities (<!ENTITY foo "bar">), value will\r
+ be non-NULL and systemId, publicID, and notationName will be NULL.\r
+ The value string is NOT nul-terminated; the length is provided in\r
+ the value_length argument. Since it is legal to have zero-length\r
+ values, do not use this argument to test for internal entities.\r
+\r
+ For external entities, value will be NULL and systemId will be\r
+ non-NULL. The publicId argument will be NULL unless a public\r
+ identifier was provided. The notationName argument will have a\r
+ non-NULL value only for unparsed entity declarations.\r
+\r
+ Note that is_parameter_entity can't be changed to XML_Bool, since\r
+ that would break binary compatibility.\r
+*/\r
+typedef void (XMLCALL *XML_EntityDeclHandler) (\r
+ void *userData,\r
+ const XML_Char *entityName,\r
+ int is_parameter_entity,\r
+ const XML_Char *value,\r
+ int value_length,\r
+ const XML_Char *base,\r
+ const XML_Char *systemId,\r
+ const XML_Char *publicId,\r
+ const XML_Char *notationName);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetEntityDeclHandler(XML_Parser parser,\r
+ XML_EntityDeclHandler handler);\r
+\r
+/* OBSOLETE -- OBSOLETE -- OBSOLETE\r
+ This handler has been superceded by the EntityDeclHandler above.\r
+ It is provided here for backward compatibility.\r
+\r
+ This is called for a declaration of an unparsed (NDATA) entity.\r
+ The base argument is whatever was set by XML_SetBase. The\r
+ entityName, systemId and notationName arguments will never be\r
+ NULL. The other arguments may be.\r
+*/\r
+typedef void (XMLCALL *XML_UnparsedEntityDeclHandler) (\r
+ void *userData,\r
+ const XML_Char *entityName,\r
+ const XML_Char *base,\r
+ const XML_Char *systemId,\r
+ const XML_Char *publicId,\r
+ const XML_Char *notationName);\r
+\r
+/* This is called for a declaration of notation. The base argument is\r
+ whatever was set by XML_SetBase. The notationName will never be\r
+ NULL. The other arguments can be.\r
+*/\r
+typedef void (XMLCALL *XML_NotationDeclHandler) (\r
+ void *userData,\r
+ const XML_Char *notationName,\r
+ const XML_Char *base,\r
+ const XML_Char *systemId,\r
+ const XML_Char *publicId);\r
+\r
+/* When namespace processing is enabled, these are called once for\r
+ each namespace declaration. The call to the start and end element\r
+ handlers occur between the calls to the start and end namespace\r
+ declaration handlers. For an xmlns attribute, prefix will be\r
+ NULL. For an xmlns="" attribute, uri will be NULL.\r
+*/\r
+typedef void (XMLCALL *XML_StartNamespaceDeclHandler) (\r
+ void *userData,\r
+ const XML_Char *prefix,\r
+ const XML_Char *uri);\r
+\r
+typedef void (XMLCALL *XML_EndNamespaceDeclHandler) (\r
+ void *userData,\r
+ const XML_Char *prefix);\r
+\r
+/* This is called if the document is not standalone, that is, it has an\r
+ external subset or a reference to a parameter entity, but does not\r
+ have standalone="yes". If this handler returns XML_STATUS_ERROR,\r
+ then processing will not continue, and the parser will return a\r
+ XML_ERROR_NOT_STANDALONE error.\r
+ If parameter entity parsing is enabled, then in addition to the\r
+ conditions above this handler will only be called if the referenced\r
+ entity was actually read.\r
+*/\r
+typedef int (XMLCALL *XML_NotStandaloneHandler) (void *userData);\r
+\r
+/* This is called for a reference to an external parsed general\r
+ entity. The referenced entity is not automatically parsed. The\r
+ application can parse it immediately or later using\r
+ XML_ExternalEntityParserCreate.\r
+\r
+ The parser argument is the parser parsing the entity containing the\r
+ reference; it can be passed as the parser argument to\r
+ XML_ExternalEntityParserCreate. The systemId argument is the\r
+ system identifier as specified in the entity declaration; it will\r
+ not be NULL.\r
+\r
+ The base argument is the system identifier that should be used as\r
+ the base for resolving systemId if systemId was relative; this is\r
+ set by XML_SetBase; it may be NULL.\r
+\r
+ The publicId argument is the public identifier as specified in the\r
+ entity declaration, or NULL if none was specified; the whitespace\r
+ in the public identifier will have been normalized as required by\r
+ the XML spec.\r
+\r
+ The context argument specifies the parsing context in the format\r
+ expected by the context argument to XML_ExternalEntityParserCreate;\r
+ context is valid only until the handler returns, so if the\r
+ referenced entity is to be parsed later, it must be copied.\r
+ context is NULL only when the entity is a parameter entity.\r
+\r
+ The handler should return XML_STATUS_ERROR if processing should not\r
+ continue because of a fatal error in the handling of the external\r
+ entity. In this case the calling parser will return an\r
+ XML_ERROR_EXTERNAL_ENTITY_HANDLING error.\r
+\r
+ Note that unlike other handlers the first argument is the parser,\r
+ not userData.\r
+*/\r
+typedef int (XMLCALL *XML_ExternalEntityRefHandler) (\r
+ XML_Parser parser,\r
+ const XML_Char *context,\r
+ const XML_Char *base,\r
+ const XML_Char *systemId,\r
+ const XML_Char *publicId);\r
+\r
+/* This is called in two situations:\r
+ 1) An entity reference is encountered for which no declaration\r
+ has been read *and* this is not an error.\r
+ 2) An internal entity reference is read, but not expanded, because\r
+ XML_SetDefaultHandler has been called.\r
+ Note: skipped parameter entities in declarations and skipped general\r
+ entities in attribute values cannot be reported, because\r
+ the event would be out of sync with the reporting of the\r
+ declarations or attribute values\r
+*/\r
+typedef void (XMLCALL *XML_SkippedEntityHandler) (\r
+ void *userData,\r
+ const XML_Char *entityName,\r
+ int is_parameter_entity);\r
+\r
+/* This structure is filled in by the XML_UnknownEncodingHandler to\r
+ provide information to the parser about encodings that are unknown\r
+ to the parser.\r
+\r
+ The map[b] member gives information about byte sequences whose\r
+ first byte is b.\r
+\r
+ If map[b] is c where c is >= 0, then b by itself encodes the\r
+ Unicode scalar value c.\r
+\r
+ If map[b] is -1, then the byte sequence is malformed.\r
+\r
+ If map[b] is -n, where n >= 2, then b is the first byte of an\r
+ n-byte sequence that encodes a single Unicode scalar value.\r
+\r
+ The data member will be passed as the first argument to the convert\r
+ function.\r
+\r
+ The convert function is used to convert multibyte sequences; s will\r
+ point to a n-byte sequence where map[(unsigned char)*s] == -n. The\r
+ convert function must return the Unicode scalar value represented\r
+ by this byte sequence or -1 if the byte sequence is malformed.\r
+\r
+ The convert function may be NULL if the encoding is a single-byte\r
+ encoding, that is if map[b] >= -1 for all bytes b.\r
+\r
+ When the parser is finished with the encoding, then if release is\r
+ not NULL, it will call release passing it the data member; once\r
+ release has been called, the convert function will not be called\r
+ again.\r
+\r
+ Expat places certain restrictions on the encodings that are supported\r
+ using this mechanism.\r
+\r
+ 1. Every ASCII character that can appear in a well-formed XML document,\r
+ other than the characters\r
+\r
+ $@\^`{}~\r
+\r
+ must be represented by a single byte, and that byte must be the\r
+ same byte that represents that character in ASCII.\r
+\r
+ 2. No character may require more than 4 bytes to encode.\r
+\r
+ 3. All characters encoded must have Unicode scalar values <=\r
+ 0xFFFF, (i.e., characters that would be encoded by surrogates in\r
+ UTF-16 are not allowed). Note that this restriction doesn't\r
+ apply to the built-in support for UTF-8 and UTF-16.\r
+\r
+ 4. No Unicode character may be encoded by more than one distinct\r
+ sequence of bytes.\r
+*/\r
+typedef struct {\r
+ int map[256];\r
+ void *data;\r
+ int (XMLCALL *convert)(void *data, const char *s);\r
+ void (XMLCALL *release)(void *data);\r
+} XML_Encoding;\r
+\r
+/* This is called for an encoding that is unknown to the parser.\r
+\r
+ The encodingHandlerData argument is that which was passed as the\r
+ second argument to XML_SetUnknownEncodingHandler.\r
+\r
+ The name argument gives the name of the encoding as specified in\r
+ the encoding declaration.\r
+\r
+ If the callback can provide information about the encoding, it must\r
+ fill in the XML_Encoding structure, and return XML_STATUS_OK.\r
+ Otherwise it must return XML_STATUS_ERROR.\r
+\r
+ If info does not describe a suitable encoding, then the parser will\r
+ return an XML_UNKNOWN_ENCODING error.\r
+*/\r
+typedef int (XMLCALL *XML_UnknownEncodingHandler) (\r
+ void *encodingHandlerData,\r
+ const XML_Char *name,\r
+ XML_Encoding *info);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetElementHandler(XML_Parser parser,\r
+ XML_StartElementHandler start,\r
+ XML_EndElementHandler end);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetStartElementHandler(XML_Parser parser,\r
+ XML_StartElementHandler handler);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetEndElementHandler(XML_Parser parser,\r
+ XML_EndElementHandler handler);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetCharacterDataHandler(XML_Parser parser,\r
+ XML_CharacterDataHandler handler);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetProcessingInstructionHandler(XML_Parser parser,\r
+ XML_ProcessingInstructionHandler handler);\r
+XMLPARSEAPI(void)\r
+XML_SetCommentHandler(XML_Parser parser,\r
+ XML_CommentHandler handler);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetCdataSectionHandler(XML_Parser parser,\r
+ XML_StartCdataSectionHandler start,\r
+ XML_EndCdataSectionHandler end);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetStartCdataSectionHandler(XML_Parser parser,\r
+ XML_StartCdataSectionHandler start);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetEndCdataSectionHandler(XML_Parser parser,\r
+ XML_EndCdataSectionHandler end);\r
+\r
+/* This sets the default handler and also inhibits expansion of\r
+ internal entities. These entity references will be passed to the\r
+ default handler, or to the skipped entity handler, if one is set.\r
+*/\r
+XMLPARSEAPI(void)\r
+XML_SetDefaultHandler(XML_Parser parser,\r
+ XML_DefaultHandler handler);\r
+\r
+/* This sets the default handler but does not inhibit expansion of\r
+ internal entities. The entity reference will not be passed to the\r
+ default handler.\r
+*/\r
+XMLPARSEAPI(void)\r
+XML_SetDefaultHandlerExpand(XML_Parser parser,\r
+ XML_DefaultHandler handler);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetDoctypeDeclHandler(XML_Parser parser,\r
+ XML_StartDoctypeDeclHandler start,\r
+ XML_EndDoctypeDeclHandler end);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetStartDoctypeDeclHandler(XML_Parser parser,\r
+ XML_StartDoctypeDeclHandler start);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetEndDoctypeDeclHandler(XML_Parser parser,\r
+ XML_EndDoctypeDeclHandler end);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetUnparsedEntityDeclHandler(XML_Parser parser,\r
+ XML_UnparsedEntityDeclHandler handler);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetNotationDeclHandler(XML_Parser parser,\r
+ XML_NotationDeclHandler handler);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetNamespaceDeclHandler(XML_Parser parser,\r
+ XML_StartNamespaceDeclHandler start,\r
+ XML_EndNamespaceDeclHandler end);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetStartNamespaceDeclHandler(XML_Parser parser,\r
+ XML_StartNamespaceDeclHandler start);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetEndNamespaceDeclHandler(XML_Parser parser,\r
+ XML_EndNamespaceDeclHandler end);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetNotStandaloneHandler(XML_Parser parser,\r
+ XML_NotStandaloneHandler handler);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetExternalEntityRefHandler(XML_Parser parser,\r
+ XML_ExternalEntityRefHandler handler);\r
+\r
+/* If a non-NULL value for arg is specified here, then it will be\r
+ passed as the first argument to the external entity ref handler\r
+ instead of the parser object.\r
+*/\r
+XMLPARSEAPI(void)\r
+XML_SetExternalEntityRefHandlerArg(XML_Parser parser,\r
+ void *arg);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetSkippedEntityHandler(XML_Parser parser,\r
+ XML_SkippedEntityHandler handler);\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetUnknownEncodingHandler(XML_Parser parser,\r
+ XML_UnknownEncodingHandler handler,\r
+ void *encodingHandlerData);\r
+\r
+/* This can be called within a handler for a start element, end\r
+ element, processing instruction or character data. It causes the\r
+ corresponding markup to be passed to the default handler.\r
+*/\r
+XMLPARSEAPI(void)\r
+XML_DefaultCurrent(XML_Parser parser);\r
+\r
+/* If do_nst is non-zero, and namespace processing is in effect, and\r
+ a name has a prefix (i.e. an explicit namespace qualifier) then\r
+ that name is returned as a triplet in a single string separated by\r
+ the separator character specified when the parser was created: URI\r
+ + sep + local_name + sep + prefix.\r
+\r
+ If do_nst is zero, then namespace information is returned in the\r
+ default manner (URI + sep + local_name) whether or not the name\r
+ has a prefix.\r
+\r
+ Note: Calling XML_SetReturnNSTriplet after XML_Parse or\r
+ XML_ParseBuffer has no effect.\r
+*/\r
+\r
+XMLPARSEAPI(void)\r
+XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);\r
+\r
+/* This value is passed as the userData argument to callbacks. */\r
+XMLPARSEAPI(void)\r
+XML_SetUserData(XML_Parser parser, void *userData);\r
+\r
+/* Returns the last value set by XML_SetUserData or NULL. */\r
+#define XML_GetUserData(parser) (*(void **)(parser))\r
+\r
+/* This is equivalent to supplying an encoding argument to\r
+ XML_ParserCreate. On success XML_SetEncoding returns non-zero,\r
+ zero otherwise.\r
+ Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer\r
+ has no effect and returns XML_STATUS_ERROR.\r
+*/\r
+XMLPARSEAPI(enum XML_Status)\r
+XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);\r
+\r
+/* If this function is called, then the parser will be passed as the\r
+ first argument to callbacks instead of userData. The userData will\r
+ still be accessible using XML_GetUserData.\r
+*/\r
+XMLPARSEAPI(void)\r
+XML_UseParserAsHandlerArg(XML_Parser parser);\r
+\r
+/* If useDTD == XML_TRUE is passed to this function, then the parser\r
+ will assume that there is an external subset, even if none is\r
+ specified in the document. In such a case the parser will call the\r
+ externalEntityRefHandler with a value of NULL for the systemId\r
+ argument (the publicId and context arguments will be NULL as well).\r
+ Note: For the purpose of checking WFC: Entity Declared, passing\r
+ useDTD == XML_TRUE will make the parser behave as if the document\r
+ had a DTD with an external subset.\r
+ Note: If this function is called, then this must be done before\r
+ the first call to XML_Parse or XML_ParseBuffer, since it will\r
+ have no effect after that. Returns\r
+ XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING.\r
+ Note: If the document does not have a DOCTYPE declaration at all,\r
+ then startDoctypeDeclHandler and endDoctypeDeclHandler will not\r
+ be called, despite an external subset being parsed.\r
+ Note: If XML_DTD is not defined when Expat is compiled, returns\r
+ XML_ERROR_FEATURE_REQUIRES_XML_DTD.\r
+*/\r
+XMLPARSEAPI(enum XML_Error)\r
+XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);\r
+\r
+\r
+/* Sets the base to be used for resolving relative URIs in system\r
+ identifiers in declarations. Resolving relative identifiers is\r
+ left to the application: this value will be passed through as the\r
+ base argument to the XML_ExternalEntityRefHandler,\r
+ XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base\r
+ argument will be copied. Returns XML_STATUS_ERROR if out of memory,\r
+ XML_STATUS_OK otherwise.\r
+*/\r
+XMLPARSEAPI(enum XML_Status)\r
+XML_SetBase(XML_Parser parser, const XML_Char *base);\r
+\r
+XMLPARSEAPI(const XML_Char *)\r
+XML_GetBase(XML_Parser parser);\r
+\r
+/* Returns the number of the attribute/value pairs passed in last call\r
+ to the XML_StartElementHandler that were specified in the start-tag\r
+ rather than defaulted. Each attribute/value pair counts as 2; thus\r
+ this correspondds to an index into the atts array passed to the\r
+ XML_StartElementHandler.\r
+*/\r
+XMLPARSEAPI(int)\r
+XML_GetSpecifiedAttributeCount(XML_Parser parser);\r
+\r
+/* Returns the index of the ID attribute passed in the last call to\r
+ XML_StartElementHandler, or -1 if there is no ID attribute. Each\r
+ attribute/value pair counts as 2; thus this correspondds to an\r
+ index into the atts array passed to the XML_StartElementHandler.\r
+*/\r
+XMLPARSEAPI(int)\r
+XML_GetIdAttributeIndex(XML_Parser parser);\r
+\r
+/* Parses some input. Returns XML_STATUS_ERROR if a fatal error is\r
+ detected. The last call to XML_Parse must have isFinal true; len\r
+ may be zero for this call (or any other).\r
+\r
+ Though the return values for these functions has always been\r
+ described as a Boolean value, the implementation, at least for the\r
+ 1.95.x series, has always returned exactly one of the XML_Status\r
+ values.\r
+*/\r
+XMLPARSEAPI(enum XML_Status)\r
+XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);\r
+\r
+XMLPARSEAPI(void *)\r
+XML_GetBuffer(XML_Parser parser, int len);\r
+\r
+XMLPARSEAPI(enum XML_Status)\r
+XML_ParseBuffer(XML_Parser parser, int len, int isFinal);\r
+\r
+/* Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return.\r
+ Must be called from within a call-back handler, except when aborting\r
+ (resumable = 0) an already suspended parser. Some call-backs may\r
+ still follow because they would otherwise get lost. Examples:\r
+ - endElementHandler() for empty elements when stopped in\r
+ startElementHandler(), \r
+ - endNameSpaceDeclHandler() when stopped in endElementHandler(), \r
+ and possibly others.\r
+\r
+ Can be called from most handlers, including DTD related call-backs,\r
+ except when parsing an external parameter entity and resumable != 0.\r
+ Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise.\r
+ Possible error codes: \r
+ - XML_ERROR_SUSPENDED: when suspending an already suspended parser.\r
+ - XML_ERROR_FINISHED: when the parser has already finished.\r
+ - XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE.\r
+\r
+ When resumable != 0 (true) then parsing is suspended, that is, \r
+ XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED. \r
+ Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer()\r
+ return XML_STATUS_ERROR with error code XML_ERROR_ABORTED.\r
+\r
+ *Note*:\r
+ This will be applied to the current parser instance only, that is, if\r
+ there is a parent parser then it will continue parsing when the\r
+ externalEntityRefHandler() returns. It is up to the implementation of\r
+ the externalEntityRefHandler() to call XML_StopParser() on the parent\r
+ parser (recursively), if one wants to stop parsing altogether.\r
+\r
+ When suspended, parsing can be resumed by calling XML_ResumeParser(). \r
+*/\r
+XMLPARSEAPI(enum XML_Status)\r
+XML_StopParser(XML_Parser parser, XML_Bool resumable);\r
+\r
+/* Resumes parsing after it has been suspended with XML_StopParser().\r
+ Must not be called from within a handler call-back. Returns same\r
+ status codes as XML_Parse() or XML_ParseBuffer().\r
+ Additional error code XML_ERROR_NOT_SUSPENDED possible. \r
+\r
+ *Note*:\r
+ This must be called on the most deeply nested child parser instance\r
+ first, and on its parent parser only after the child parser has finished,\r
+ to be applied recursively until the document entity's parser is restarted.\r
+ That is, the parent parser will not resume by itself and it is up to the\r
+ application to call XML_ResumeParser() on it at the appropriate moment.\r
+*/\r
+XMLPARSEAPI(enum XML_Status)\r
+XML_ResumeParser(XML_Parser parser);\r
+\r
+enum XML_Parsing {\r
+ XML_INITIALIZED,\r
+ XML_PARSING,\r
+ XML_FINISHED,\r
+ XML_SUSPENDED\r
+};\r
+\r
+typedef struct {\r
+ enum XML_Parsing parsing;\r
+ XML_Bool finalBuffer;\r
+} XML_ParsingStatus;\r
+\r
+/* Returns status of parser with respect to being initialized, parsing,\r
+ finished, or suspended and processing the final buffer.\r
+ XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus,\r
+ XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED\r
+*/\r
+XMLPARSEAPI(void)\r
+XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);\r
+\r
+/* Creates an XML_Parser object that can parse an external general\r
+ entity; context is a '\0'-terminated string specifying the parse\r
+ context; encoding is a '\0'-terminated string giving the name of\r
+ the externally specified encoding, or NULL if there is no\r
+ externally specified encoding. The context string consists of a\r
+ sequence of tokens separated by formfeeds (\f); a token consisting\r
+ of a name specifies that the general entity of the name is open; a\r
+ token of the form prefix=uri specifies the namespace for a\r
+ particular prefix; a token of the form =uri specifies the default\r
+ namespace. This can be called at any point after the first call to\r
+ an ExternalEntityRefHandler so longer as the parser has not yet\r
+ been freed. The new parser is completely independent and may\r
+ safely be used in a separate thread. The handlers and userData are\r
+ initialized from the parser argument. Returns NULL if out of memory.\r
+ Otherwise returns a new XML_Parser object.\r
+*/\r
+XMLPARSEAPI(XML_Parser)\r
+XML_ExternalEntityParserCreate(XML_Parser parser,\r
+ const XML_Char *context,\r
+ const XML_Char *encoding);\r
+\r
+enum XML_ParamEntityParsing {\r
+ XML_PARAM_ENTITY_PARSING_NEVER,\r
+ XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,\r
+ XML_PARAM_ENTITY_PARSING_ALWAYS\r
+};\r
+\r
+/* Controls parsing of parameter entities (including the external DTD\r
+ subset). If parsing of parameter entities is enabled, then\r
+ references to external parameter entities (including the external\r
+ DTD subset) will be passed to the handler set with\r
+ XML_SetExternalEntityRefHandler. The context passed will be 0.\r
+\r
+ Unlike external general entities, external parameter entities can\r
+ only be parsed synchronously. If the external parameter entity is\r
+ to be parsed, it must be parsed during the call to the external\r
+ entity ref handler: the complete sequence of\r
+ XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and\r
+ XML_ParserFree calls must be made during this call. After\r
+ XML_ExternalEntityParserCreate has been called to create the parser\r
+ for the external parameter entity (context must be 0 for this\r
+ call), it is illegal to make any calls on the old parser until\r
+ XML_ParserFree has been called on the newly created parser.\r
+ If the library has been compiled without support for parameter\r
+ entity parsing (ie without XML_DTD being defined), then\r
+ XML_SetParamEntityParsing will return 0 if parsing of parameter\r
+ entities is requested; otherwise it will return non-zero.\r
+ Note: If XML_SetParamEntityParsing is called after XML_Parse or\r
+ XML_ParseBuffer, then it has no effect and will always return 0.\r
+*/\r
+XMLPARSEAPI(int)\r
+XML_SetParamEntityParsing(XML_Parser parser,\r
+ enum XML_ParamEntityParsing parsing);\r
+\r
+/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then\r
+ XML_GetErrorCode returns information about the error.\r
+*/\r
+XMLPARSEAPI(enum XML_Error)\r
+XML_GetErrorCode(XML_Parser parser);\r
+\r
+/* These functions return information about the current parse\r
+ location. They may be called from any callback called to report\r
+ some parse event; in this case the location is the location of the\r
+ first of the sequence of characters that generated the event. When\r
+ called from callbacks generated by declarations in the document\r
+ prologue, the location identified isn't as neatly defined, but will\r
+ be within the relevant markup. When called outside of the callback\r
+ functions, the position indicated will be just past the last parse\r
+ event (regardless of whether there was an associated callback).\r
+ \r
+ They may also be called after returning from a call to XML_Parse\r
+ or XML_ParseBuffer. If the return value is XML_STATUS_ERROR then\r
+ the location is the location of the character at which the error\r
+ was detected; otherwise the location is the location of the last\r
+ parse event, as described above.\r
+*/\r
+XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser);\r
+XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser);\r
+XMLPARSEAPI(XML_Index) XML_GetCurrentByteIndex(XML_Parser parser);\r
+\r
+/* Return the number of bytes in the current event.\r
+ Returns 0 if the event is in an internal entity.\r
+*/\r
+XMLPARSEAPI(int)\r
+XML_GetCurrentByteCount(XML_Parser parser);\r
+\r
+/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets\r
+ the integer pointed to by offset to the offset within this buffer\r
+ of the current parse position, and sets the integer pointed to by size\r
+ to the size of this buffer (the number of input bytes). Otherwise\r
+ returns a NULL pointer. Also returns a NULL pointer if a parse isn't\r
+ active.\r
+\r
+ NOTE: The character pointer returned should not be used outside\r
+ the handler that makes the call.\r
+*/\r
+XMLPARSEAPI(const char *)\r
+XML_GetInputContext(XML_Parser parser,\r
+ int *offset,\r
+ int *size);\r
+\r
+/* For backwards compatibility with previous versions. */\r
+#define XML_GetErrorLineNumber XML_GetCurrentLineNumber\r
+#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber\r
+#define XML_GetErrorByteIndex XML_GetCurrentByteIndex\r
+\r
+/* Frees the content model passed to the element declaration handler */\r
+XMLPARSEAPI(void)\r
+XML_FreeContentModel(XML_Parser parser, XML_Content *model);\r
+\r
+/* Exposing the memory handling functions used in Expat */\r
+XMLPARSEAPI(void *)\r
+XML_MemMalloc(XML_Parser parser, size_t size);\r
+\r
+XMLPARSEAPI(void *)\r
+XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);\r
+\r
+XMLPARSEAPI(void)\r
+XML_MemFree(XML_Parser parser, void *ptr);\r
+\r
+/* Frees memory used by the parser. */\r
+XMLPARSEAPI(void)\r
+XML_ParserFree(XML_Parser parser);\r
+\r
+/* Returns a string describing the error. */\r
+XMLPARSEAPI(const XML_LChar *)\r
+XML_ErrorString(enum XML_Error code);\r
+\r
+/* Return a string containing the version number of this expat */\r
+XMLPARSEAPI(const XML_LChar *)\r
+XML_ExpatVersion(void);\r
+\r
+typedef struct {\r
+ int major;\r
+ int minor;\r
+ int micro;\r
+} XML_Expat_Version;\r
+\r
+/* Return an XML_Expat_Version structure containing numeric version\r
+ number information for this version of expat.\r
+*/\r
+XMLPARSEAPI(XML_Expat_Version)\r
+XML_ExpatVersionInfo(void);\r
+\r
+/* Added in Expat 1.95.5. */\r
+enum XML_FeatureEnum {\r
+ XML_FEATURE_END = 0,\r
+ XML_FEATURE_UNICODE,\r
+ XML_FEATURE_UNICODE_WCHAR_T,\r
+ XML_FEATURE_DTD,\r
+ XML_FEATURE_CONTEXT_BYTES,\r
+ XML_FEATURE_MIN_SIZE,\r
+ XML_FEATURE_SIZEOF_XML_CHAR,\r
+ XML_FEATURE_SIZEOF_XML_LCHAR,\r
+ XML_FEATURE_NS,\r
+ XML_FEATURE_LARGE_SIZE\r
+ /* Additional features must be added to the end of this enum. */\r
+};\r
+\r
+typedef struct {\r
+ enum XML_FeatureEnum feature;\r
+ const XML_LChar *name;\r
+ long int value;\r
+} XML_Feature;\r
+\r
+XMLPARSEAPI(const XML_Feature *)\r
+XML_GetFeatureList(void);\r
+\r
+\r
+/* Expat follows the GNU/Linux convention of odd number minor version for\r
+ beta/development releases and even number minor version for stable\r
+ releases. Micro is bumped with each release, and set to 0 with each\r
+ change to major or minor version.\r
+*/\r
+#define XML_MAJOR_VERSION 2\r
+#define XML_MINOR_VERSION 0\r
+#define XML_MICRO_VERSION 1\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+#endif /* not Expat_INCLUDED */\r
--- /dev/null
+/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd\r
+ See the file COPYING for copying permission.\r
+*/\r
+\r
+#ifndef Expat_External_INCLUDED\r
+#define Expat_External_INCLUDED 1\r
+\r
+/* External API definitions */\r
+\r
+#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)\r
+#define XML_USE_MSC_EXTENSIONS 1\r
+#endif\r
+\r
+/* Expat tries very hard to make the API boundary very specifically\r
+ defined. There are two macros defined to control this boundary;\r
+ each of these can be defined before including this header to\r
+ achieve some different behavior, but doing so it not recommended or\r
+ tested frequently.\r
+\r
+ XMLCALL - The calling convention to use for all calls across the\r
+ "library boundary." This will default to cdecl, and\r
+ try really hard to tell the compiler that's what we\r
+ want.\r
+\r
+ XMLIMPORT - Whatever magic is needed to note that a function is\r
+ to be imported from a dynamically loaded library\r
+ (.dll, .so, or .sl, depending on your platform).\r
+\r
+ The XMLCALL macro was added in Expat 1.95.7. The only one which is\r
+ expected to be directly useful in client code is XMLCALL.\r
+\r
+ Note that on at least some Unix versions, the Expat library must be\r
+ compiled with the cdecl calling convention as the default since\r
+ system headers may assume the cdecl convention.\r
+*/\r
+#ifndef XMLCALL\r
+#if defined(_MSC_VER)\r
+#define XMLCALL __cdecl\r
+#elif defined(__GNUC__) && defined(__i386) && !defined(__INTEL_COMPILER)\r
+#define XMLCALL __attribute__((cdecl))\r
+#else\r
+/* For any platform which uses this definition and supports more than\r
+ one calling convention, we need to extend this definition to\r
+ declare the convention used on that platform, if it's possible to\r
+ do so.\r
+\r
+ If this is the case for your platform, please file a bug report\r
+ with information on how to identify your platform via the C\r
+ pre-processor and how to specify the same calling convention as the\r
+ platform's malloc() implementation.\r
+*/\r
+#define XMLCALL\r
+#endif\r
+#endif /* not defined XMLCALL */\r
+\r
+\r
+#if !defined(XML_STATIC) && !defined(XMLIMPORT)\r
+#ifndef XML_BUILDING_EXPAT\r
+/* using Expat from an application */\r
+\r
+#ifdef XML_USE_MSC_EXTENSIONS\r
+#define XMLIMPORT __declspec(dllimport)\r
+#endif\r
+\r
+#endif\r
+#endif /* not defined XML_STATIC */\r
+\r
+\r
+/* If we didn't define it above, define it away: */\r
+#ifndef XMLIMPORT\r
+#define XMLIMPORT\r
+#endif\r
+\r
+\r
+#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+#ifdef XML_UNICODE_WCHAR_T\r
+#define XML_UNICODE\r
+#endif\r
+\r
+#ifdef XML_UNICODE /* Information is UTF-16 encoded. */\r
+#ifdef XML_UNICODE_WCHAR_T\r
+typedef wchar_t XML_Char;\r
+typedef wchar_t XML_LChar;\r
+#else\r
+typedef unsigned short XML_Char;\r
+typedef char XML_LChar;\r
+#endif /* XML_UNICODE_WCHAR_T */\r
+#else /* Information is UTF-8 encoded. */\r
+typedef char XML_Char;\r
+typedef char XML_LChar;\r
+#endif /* XML_UNICODE */\r
+\r
+#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */\r
+#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400\r
+typedef __int64 XML_Index; \r
+typedef unsigned __int64 XML_Size;\r
+#else\r
+typedef long long XML_Index;\r
+typedef unsigned long long XML_Size;\r
+#endif\r
+#else\r
+typedef long XML_Index;\r
+typedef unsigned long XML_Size;\r
+#endif /* XML_LARGE_SIZE */\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+#endif /* not Expat_External_INCLUDED */\r
--- /dev/null
+#ifndef __FMI1_CS_H__\r
+#define __FMI1_CS_H__\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+typedef struct {\r
+ char *name;\r
+ long vr;\r
+} FMIL_Variable;\r
+\r
+__declspec(dllexport) void* FMI1_CS_LOAD(const char *zipFilePath, const char *unzipFolder);\r
+__declspec(dllexport) int FMI1_CS_UNLOAD(void* fmu);\r
+__declspec(dllexport) FMIL_Variable *FMI1_CS_GET_VARIABLES(void* fmu, int *count);\r
+__declspec(dllexport) int FMI1_CS_INSTANTIATE(void* fmu);\r
+__declspec(dllexport) int FMI1_CS_INITIALIZE(void* fmu);\r
+__declspec(dllexport) int FMI1_CS_STEP(void* fmu, double masterTime, double stepSize);\r
+__declspec(dllexport) double FMI1_CS_SET_REAL(void* fmu, int vr, double value);\r
+__declspec(dllexport) int FMI1_CS_GET_REALS(void* fmu, int *vrs, double *values, int count);\r
+__declspec(dllexport) double FMI1_CS_GET_REAL(void* fmu, int vr);\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+#endif
\ No newline at end of file
--- /dev/null
+#ifndef fmiModelFunctions_h\r
+#define fmiModelFunctions_h\r
+\r
+/* This header file must be utilized when compiling a model.\r
+ It defines all functions of the Model Execution Interface.\r
+ In order to have unique function names even if several models\r
+ are compiled together (e.g. for embedded systems), every "real" function name\r
+ is constructed by prepending the function name by\r
+ "MODEL_IDENTIFIER" + "_" where "MODEL_IDENTIFIER" is the short name\r
+ of the model used as the name of the zip-file where the model is stored.\r
+ Therefore, the typical usage is:\r
+\r
+ #define MODEL_IDENTIFIER MyModel\r
+ #include "fmiModelFunctions.h"\r
+\r
+ As a result, a function that is defined as "fmiGetDerivatives" in this header file,\r
+ is actually getting the name "MyModel_fmiGetDerivatives".\r
+\r
+ Revisions:\r
+ - Jan. 20, 2010: stateValueReferencesChanged added to struct fmiEventInfo (ticket #27)\r
+ (by M. Otter, DLR)\r
+ Added WIN32 pragma to define the struct layout (ticket #34)\r
+ (by J. Mauss, QTronic)\r
+ - Jan. 4, 2010: Removed argument intermediateResults from fmiInitialize\r
+ Renamed macro fmiGetModelFunctionsVersion to fmiGetVersion\r
+ Renamed macro fmiModelFunctionsVersion to fmiVersion\r
+ Replaced fmiModel by fmiComponent in decl of fmiInstantiateModel\r
+ (by J. Mauss, QTronic)\r
+ - Dec. 17, 2009: Changed extension "me" to "fmi" (by Martin Otter, DLR).\r
+ - Dez. 14, 2009: Added eventInfo to meInitialize and added\r
+ meGetNominalContinuousStates (by Martin Otter, DLR)\r
+ - Sept. 9, 2009: Added DllExport (according to Peter Nilsson's suggestion)\r
+ (by A. Junghanns, QTronic)\r
+ - Sept. 9, 2009: Changes according to FMI-meeting on July 21:\r
+ meInquireModelTypesVersion -> meGetModelTypesPlatform\r
+ meInquireModelFunctionsVersion -> meGetModelFunctionsVersion\r
+ meSetStates -> meSetContinuousStates\r
+ meGetStates -> meGetContinuousStates\r
+ removal of meInitializeModelClass\r
+ removal of meGetTime\r
+ change of arguments of meInstantiateModel\r
+ change of arguments of meCompletedIntegratorStep\r
+ (by Martin Otter, DLR):\r
+ - July 19, 2009: Added "me" as prefix to file names (by Martin Otter, DLR).\r
+ - March 2, 2009: Changed function definitions according to the last design\r
+ meeting with additional improvements (by Martin Otter, DLR).\r
+ - Dec. 3 , 2008: First version by Martin Otter (DLR) and Hans Olsson (Dynasim).\r
+\r
+\r
+ Copyright © 2008-2009, MODELISAR consortium. All rights reserved.\r
+ This file is licensed by the copyright holders under the BSD License\r
+ (http://www.opensource.org/licenses/bsd-license.html):\r
+\r
+ ----------------------------------------------------------------------------\r
+ Redistribution and use in source and binary forms, with or without\r
+ modification, are permitted provided that the following conditions are met:\r
+\r
+ - Redistributions of source code must retain the above copyright notice,\r
+ this list of conditions and the following disclaimer.\r
+ - Redistributions in binary form must reproduce the above copyright notice,\r
+ this list of conditions and the following disclaimer in the documentation\r
+ and/or other materials provided with the distribution.\r
+ - Neither the name of the copyright holders nor the names of its\r
+ contributors may be used to endorse or promote products derived\r
+ from this software without specific prior written permission.\r
+\r
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\r
+ TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\r
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\r
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;\r
+ OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\r
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\r
+ OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\r
+ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ ----------------------------------------------------------------------------\r
+\r
+ with the extension:\r
+\r
+ You may distribute or publicly perform any modification only under the\r
+ terms of this license.\r
+*/\r
+\r
+#include "fmiModelTypes.h"\r
+#include <stdlib.h>\r
+\r
+/* Export fmi functions on Windows */\r
+#ifdef _MSC_VER\r
+#define DllExport __declspec( dllexport )\r
+#else\r
+#define DllExport\r
+#endif\r
+\r
+/* Macros to construct the real function name\r
+ (prepend function name by MODEL_IDENTIFIER + "_") */\r
+\r
+#define fmiPaste(a,b) a ## b\r
+#define fmiPasteB(a,b) fmiPaste(a,b)\r
+#define fmiFullName(name) fmiPasteB(MODEL_IDENTIFIER, name)\r
+\r
+#define fmiGetModelTypesPlatform fmiFullName(_fmiGetModelTypesPlatform)\r
+#define fmiGetVersion fmiFullName(_fmiGetVersion)\r
+#define fmiInstantiateModel fmiFullName(_fmiInstantiateModel)\r
+#define fmiFreeModelInstance fmiFullName(_fmiFreeModelInstance)\r
+#define fmiSetDebugLogging fmiFullName(_fmiSetDebugLogging)\r
+#define fmiSetTime fmiFullName(_fmiSetTime)\r
+#define fmiSetContinuousStates fmiFullName(_fmiSetContinuousStates)\r
+#define fmiCompletedIntegratorStep fmiFullName(_fmiCompletedIntegratorStep)\r
+#define fmiSetReal fmiFullName(_fmiSetReal)\r
+#define fmiSetInteger fmiFullName(_fmiSetInteger)\r
+#define fmiSetBoolean fmiFullName(_fmiSetBoolean)\r
+#define fmiSetString fmiFullName(_fmiSetString)\r
+#define fmiInitialize fmiFullName(_fmiInitialize)\r
+#define fmiGetDerivatives fmiFullName(_fmiGetDerivatives)\r
+#define fmiGetEventIndicators fmiFullName(_fmiGetEventIndicators)\r
+#define fmiGetReal fmiFullName(_fmiGetReal)\r
+#define fmiGetInteger fmiFullName(_fmiGetInteger)\r
+#define fmiGetBoolean fmiFullName(_fmiGetBoolean)\r
+#define fmiGetString fmiFullName(_fmiGetString)\r
+#define fmiEventUpdate fmiFullName(_fmiEventUpdate)\r
+#define fmiGetContinuousStates fmiFullName(_fmiGetContinuousStates)\r
+#define fmiGetNominalContinuousStates fmiFullName(_fmiGetNominalContinuousStates)\r
+#define fmiGetStateValueReferences fmiFullName(_fmiGetStateValueReferences)\r
+#define fmiTerminate fmiFullName(_fmiTerminate)\r
+\r
+\r
+/* Version number */\r
+#define fmiVersion "1.0"\r
+\r
+/* Inquire version numbers of header files */\r
+ DllExport const char* fmiGetModelTypesPlatform();\r
+ DllExport const char* fmiGetVersion();\r
+\r
+/* make sure all compiler use the same alignment policies for structures */\r
+#ifdef WIN32\r
+#pragma pack(push,8)\r
+#endif\r
+\r
+/* Type definitions */\r
+ typedef enum {fmiOK,\r
+ fmiWarning,\r
+ fmiDiscard,\r
+ fmiError,\r
+ fmiFatal} fmiStatus;\r
+\r
+ typedef void (*fmiCallbackLogger) (fmiComponent c, fmiString instanceName, fmiStatus status,\r
+ fmiString category, fmiString message, ...);\r
+ typedef void* (*fmiCallbackAllocateMemory)(size_t nobj, size_t size);\r
+ typedef void (*fmiCallbackFreeMemory) (void* obj);\r
+\r
+ typedef struct {\r
+ fmiCallbackLogger logger;\r
+ fmiCallbackAllocateMemory allocateMemory;\r
+ fmiCallbackFreeMemory freeMemory;\r
+ } fmiCallbackFunctions;\r
+\r
+ typedef struct {\r
+ fmiBoolean iterationConverged;\r
+ fmiBoolean stateValueReferencesChanged;\r
+ fmiBoolean stateValuesChanged;\r
+ fmiBoolean terminateSimulation;\r
+ fmiBoolean upcomingTimeEvent;\r
+ fmiReal nextEventTime;\r
+ } fmiEventInfo;\r
+\r
+/* reset alignment policy to the one set before reading this file */\r
+#ifdef WIN32\r
+#pragma pack(pop)\r
+#endif\r
+\r
+/* Creation and destruction of model instances and setting debug status */\r
+ DllExport fmiComponent fmiInstantiateModel (fmiString instanceName,\r
+ fmiString GUID,\r
+ fmiCallbackFunctions functions,\r
+ fmiBoolean loggingOn);\r
+ DllExport void fmiFreeModelInstance(fmiComponent c);\r
+ DllExport fmiStatus fmiSetDebugLogging (fmiComponent c, fmiBoolean loggingOn);\r
+\r
+\r
+/* Providing independent variables and re-initialization of caching */\r
+ DllExport fmiStatus fmiSetTime (fmiComponent c, fmiReal time);\r
+ DllExport fmiStatus fmiSetContinuousStates (fmiComponent c, const fmiReal x[], size_t nx);\r
+ DllExport fmiStatus fmiCompletedIntegratorStep(fmiComponent c, fmiBoolean* callEventUpdate);\r
+ DllExport fmiStatus fmiSetReal (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiReal value[]);\r
+ DllExport fmiStatus fmiSetInteger (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiInteger value[]);\r
+ DllExport fmiStatus fmiSetBoolean (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiBoolean value[]);\r
+ DllExport fmiStatus fmiSetString (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiString value[]);\r
+\r
+\r
+/* Evaluation of the model equations */\r
+ DllExport fmiStatus fmiInitialize(fmiComponent c, fmiBoolean toleranceControlled,\r
+ fmiReal relativeTolerance, fmiEventInfo* eventInfo);\r
+\r
+ DllExport fmiStatus fmiGetDerivatives (fmiComponent c, fmiReal derivatives[] , size_t nx);\r
+ DllExport fmiStatus fmiGetEventIndicators(fmiComponent c, fmiReal eventIndicators[], size_t ni);\r
+\r
+ DllExport fmiStatus fmiGetReal (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiReal value[]);\r
+ DllExport fmiStatus fmiGetInteger(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiInteger value[]);\r
+ DllExport fmiStatus fmiGetBoolean(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiBoolean value[]);\r
+ DllExport fmiStatus fmiGetString (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiString value[]);\r
+\r
+ DllExport fmiStatus fmiEventUpdate (fmiComponent c, fmiBoolean intermediateResults, fmiEventInfo* eventInfo);\r
+ DllExport fmiStatus fmiGetContinuousStates (fmiComponent c, fmiReal states[], size_t nx);\r
+ DllExport fmiStatus fmiGetNominalContinuousStates(fmiComponent c, fmiReal x_nominal[], size_t nx);\r
+ DllExport fmiStatus fmiGetStateValueReferences (fmiComponent c, fmiValueReference vrx[], size_t nx);\r
+ DllExport fmiStatus fmiTerminate (fmiComponent c);\r
+\r
+#endif // fmiModelFunctions_h\r
--- /dev/null
+#ifndef fmiModelTypes_h\r
+#define fmiModelTypes_h\r
+\r
+/* Standard header file to define the argument types of the\r
+ functions of the Model Execution Interface.\r
+ This header file must be utilized both by the model and\r
+ by the simulation engine.\r
+\r
+ Revisions:\r
+ - Jan. 4, 2010: Renamed meModelTypes_h to fmiModelTypes_h (by Mauss, QTronic)\r
+ - Dec. 21, 2009: Changed "me" to "fmi" and "meModel" to "fmiComponent"\r
+ according to meeting on Dec. 18 (by Martin Otter, DLR)\r
+ - Dec. 6, 2009: Added meUndefinedValueReference (by Martin Otter, DLR)\r
+ - Sept. 9, 2009: Changes according to FMI-meeting on July 21:\r
+ Changed "version" to "platform", "standard" to "standard32",\r
+ Added a precise definition of "standard32" as comment\r
+ (by Martin Otter, DLR)\r
+ - July 19, 2009: Added "me" as prefix to file names, added meTrue/meFalse,\r
+ and changed meValueReferenced from int to unsigned int\r
+ (by Martin Otter, DLR).\r
+ - March 2, 2009: Moved enums and function pointer definitions to\r
+ ModelFunctions.h (by Martin Otter, DLR).\r
+ - Dec. 3, 2008 : First version by Martin Otter (DLR) and\r
+ Hans Olsson (Dynasim).\r
+\r
+\r
+ Copyright © 2008-2010, MODELISAR consortium. All rights reserved.\r
+ This file is licensed by the copyright holders under the BSD License\r
+ (http://www.opensource.org/licenses/bsd-license.html)\r
+\r
+ ----------------------------------------------------------------------------\r
+ Redistribution and use in source and binary forms, with or without\r
+ modification, are permitted provided that the following conditions are met:\r
+\r
+ - Redistributions of source code must retain the above copyright notice,\r
+ this list of conditions and the following disclaimer.\r
+ - Redistributions in binary form must reproduce the above copyright notice,\r
+ this list of conditions and the following disclaimer in the documentation\r
+ and/or other materials provided with the distribution.\r
+ - Neither the name of the copyright holders nor the names of its\r
+ contributors may be used to endorse or promote products derived\r
+ from this software without specific prior written permission.\r
+\r
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\r
+ TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+ PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\r
+ CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r
+ EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\r
+ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;\r
+ OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\r
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\r
+ OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\r
+ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ ----------------------------------------------------------------------------\r
+\r
+ with the extension:\r
+\r
+ You may distribute or publicly perform any modification only under the\r
+ terms of this license.\r
+*/\r
+\r
+/* Platform (combination of machine, compiler, operating system) */\r
+#define fmiModelTypesPlatform "standard32"\r
+\r
+/* Type definitions of variables passed as arguments\r
+ Version "standard32" means:\r
+\r
+ fmiComponent : 32 bit pointer\r
+ fmiValueReference: 32 bit\r
+ fmiReal : 64 bit\r
+ fmiInteger : 32 bit\r
+ fmiBoolean : 8 bit\r
+ fmiString : 32 bit pointer\r
+\r
+*/\r
+ typedef void* fmiComponent;\r
+ typedef unsigned int fmiValueReference;\r
+ typedef double fmiReal ;\r
+ typedef int fmiInteger;\r
+ typedef char fmiBoolean;\r
+ typedef const char* fmiString ;\r
+\r
+/* Values for fmiBoolean */\r
+#define fmiTrue 1\r
+#define fmiFalse 0\r
+\r
+/* Undefined value for fmiValueReference (largest unsigned int value) */\r
+#define fmiUndefinedValueReference (fmiValueReference)(-1)\r
+\r
+#endif\r
--- /dev/null
+/* ------------------------------------------------------------------------- \r
+ * fmi_me.h\r
+ * Function types for all function of the "FMI for Model Exchange 1.0"\r
+ * and a struct with the corresponding function pointers. \r
+ * Copyright 2011 QTronic GmbH. All rights reserved. \r
+ * -------------------------------------------------------------------------\r
+ */\r
+\r
+#ifndef FMI_ME_H\r
+#define FMI_ME_H\r
+\r
+#include <windows.h>\r
+#include "fmiModelFunctions.h"\r
+#include "xml_parser.h"\r
+\r
+typedef const char* (*fGetModelTypesPlatform)();\r
+typedef const char* (*fGetVersion)();\r
+typedef fmiComponent (*fInstantiateModel)(fmiString instanceName, fmiString GUID,\r
+ fmiCallbackFunctions functions, fmiBoolean loggingOn);\r
+typedef void (*fFreeModelInstance) (fmiComponent c);\r
+typedef fmiStatus (*fSetDebugLogging) (fmiComponent c, fmiBoolean loggingOn);\r
+typedef fmiStatus (*fSetTime) (fmiComponent c, fmiReal time);\r
+typedef fmiStatus (*fSetContinuousStates)(fmiComponent c, const fmiReal x[], size_t nx);\r
+typedef fmiStatus (*fCompletedIntegratorStep)(fmiComponent c, fmiBoolean* callEventUpdate);\r
+typedef fmiStatus (*fSetReal) (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiReal value[]);\r
+typedef fmiStatus (*fSetInteger)(fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiInteger value[]);\r
+typedef fmiStatus (*fSetBoolean)(fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiBoolean value[]);\r
+typedef fmiStatus (*fSetString) (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiString value[]);\r
+typedef fmiStatus (*fInitialize)(fmiComponent c, fmiBoolean toleranceControlled, \r
+ fmiReal relativeTolerance, fmiEventInfo* eventInfo);\r
+typedef fmiStatus (*fGetDerivatives) (fmiComponent c, fmiReal derivatives[] , size_t nx);\r
+typedef fmiStatus (*fGetEventIndicators)(fmiComponent c, fmiReal eventIndicators[], size_t ni);\r
+typedef fmiStatus (*fGetReal) (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiReal value[]);\r
+typedef fmiStatus (*fGetInteger)(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiInteger value[]);\r
+typedef fmiStatus (*fGetBoolean)(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiBoolean value[]);\r
+typedef fmiStatus (*fGetString) (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiString value[]);\r
+typedef fmiStatus (*fEventUpdate) (fmiComponent c, fmiBoolean intermediateResults, fmiEventInfo* eventInfo);\r
+typedef fmiStatus (*fGetContinuousStates) (fmiComponent c, fmiReal states[], size_t nx);\r
+typedef fmiStatus (*fGetNominalContinuousStates)(fmiComponent c, fmiReal x_nominal[], size_t nx);\r
+typedef fmiStatus (*fGetStateValueReferences) (fmiComponent c, fmiValueReference vrx[], size_t nx);\r
+typedef fmiStatus (*fTerminate) (fmiComponent c); \r
+\r
+typedef struct {\r
+ ModelDescription* modelDescription;\r
+ HANDLE dllHandle;\r
+ fGetModelTypesPlatform getModelTypesPlatform;\r
+ fGetVersion getVersion;\r
+ fInstantiateModel instantiateModel;\r
+ fFreeModelInstance freeModelInstance;\r
+ fSetDebugLogging setDebugLogging;\r
+ fSetTime setTime;\r
+ fSetContinuousStates setContinuousStates;\r
+ fCompletedIntegratorStep completedIntegratorStep;\r
+ fSetReal setReal;\r
+ fSetInteger setInteger;\r
+ fSetBoolean setBoolean;\r
+ fSetString setString;\r
+ fInitialize initialize;\r
+ fGetDerivatives getDerivatives;\r
+ fGetEventIndicators getEventIndicators;\r
+ fGetReal getReal;\r
+ fGetInteger getInteger;\r
+ fGetBoolean getBoolean;\r
+ fGetString getString;\r
+ fEventUpdate eventUpdate;\r
+ fGetContinuousStates getContinuousStates;\r
+ fGetNominalContinuousStates getNominalContinuousStates;\r
+ fGetStateValueReferences getStateValueReferences;\r
+ fTerminate terminate; \r
+/* \r
+ fInstantiateSlave instantiateSlave;\r
+ fInitializeSlave initializeSlave;\r
+ fTerminateSlave terminateSlave;\r
+ fResetSlave resetSlave;\r
+ fFreeSlaveInstance freeSlaveInstance;\r
+ fGetRealOutputDerivatives getRealOutputDerivatives;\r
+ fSetRealInputDerivatives setRealInputDerivatives;\r
+ fDoStep doStep;\r
+ fCancelStep cancelStep;\r
+ fGetStatus getStatus;\r
+ fGetRealStatus getRealStatus;\r
+ fGetIntegerStatus getIntegerStatus;\r
+ fGetBooleanStatus getBooleanStatus;\r
+ fGetStringStatus getStringStatus;\r
+*/\r
+} FMU;\r
+\r
+#endif // FMI_ME_H\r
+\r
--- /dev/null
+ /* inffixed.h -- table for decoding fixed codes
+ * Generated automatically by makefixed().
+ */
+
+ /* WARNING: this file should *not* be used by applications.
+ It is part of the implementation of this library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+ static const code lenfix[512] = {
+ {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
+ {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
+ {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
+ {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
+ {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
+ {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
+ {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
+ {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
+ {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
+ {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
+ {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
+ {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
+ {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
+ {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
+ {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
+ {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
+ {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
+ {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
+ {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
+ {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
+ {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
+ {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
+ {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
+ {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
+ {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
+ {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
+ {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
+ {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
+ {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
+ {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
+ {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
+ {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
+ {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
+ {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
+ {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
+ {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
+ {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
+ {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
+ {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
+ {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
+ {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
+ {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
+ {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
+ {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
+ {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
+ {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
+ {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
+ {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
+ {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
+ {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
+ {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
+ {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
+ {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
+ {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
+ {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
+ {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
+ {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
+ {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
+ {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
+ {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
+ {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
+ {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
+ {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
+ {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
+ {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
+ {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
+ {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
+ {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
+ {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
+ {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
+ {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
+ {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
+ {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
+ {0,9,255}
+ };
+
+ static const code distfix[32] = {
+ {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
+ {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
+ {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
+ {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
+ {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
+ {22,5,193},{64,5,0}
+ };
--- /dev/null
+/* inflate.h -- internal inflate state definition
+ * Copyright (C) 1995-2009 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+ trailer decoding by inflate(). NO_GZIP would be used to avoid linking in
+ the crc code when it is not needed. For shared libraries, gzip decoding
+ should be left enabled. */
+#ifndef NO_GZIP
+# define GUNZIP
+#endif
+
+/* Possible inflate modes between inflate() calls */
+typedef enum {
+ HEAD, /* i: waiting for magic header */
+ FLAGS, /* i: waiting for method and flags (gzip) */
+ TIME, /* i: waiting for modification time (gzip) */
+ OS, /* i: waiting for extra flags and operating system (gzip) */
+ EXLEN, /* i: waiting for extra length (gzip) */
+ EXTRA, /* i: waiting for extra bytes (gzip) */
+ NAME, /* i: waiting for end of file name (gzip) */
+ COMMENT, /* i: waiting for end of comment (gzip) */
+ HCRC, /* i: waiting for header crc (gzip) */
+ DICTID, /* i: waiting for dictionary check value */
+ DICT, /* waiting for inflateSetDictionary() call */
+ TYPE, /* i: waiting for type bits, including last-flag bit */
+ TYPEDO, /* i: same, but skip check to exit inflate on new block */
+ STORED, /* i: waiting for stored size (length and complement) */
+ COPY_, /* i/o: same as COPY below, but only first time in */
+ COPY, /* i/o: waiting for input or output to copy stored block */
+ TABLE, /* i: waiting for dynamic block table lengths */
+ LENLENS, /* i: waiting for code length code lengths */
+ CODELENS, /* i: waiting for length/lit and distance code lengths */
+ LEN_, /* i: same as LEN below, but only first time in */
+ LEN, /* i: waiting for length/lit/eob code */
+ LENEXT, /* i: waiting for length extra bits */
+ DIST, /* i: waiting for distance code */
+ DISTEXT, /* i: waiting for distance extra bits */
+ MATCH, /* o: waiting for output space to copy string */
+ LIT, /* o: waiting for output space to write literal */
+ CHECK, /* i: waiting for 32-bit check value */
+ LENGTH, /* i: waiting for 32-bit length (gzip) */
+ DONE, /* finished check, done -- remain here until reset */
+ BAD, /* got a data error -- remain here until reset */
+ MEM, /* got an inflate() memory error -- remain here until reset */
+ SYNC /* looking for synchronization bytes to restart inflate() */
+} inflate_mode;
+
+/*
+ State transitions between above modes -
+
+ (most modes can go to BAD or MEM on error -- not shown for clarity)
+
+ Process header:
+ HEAD -> (gzip) or (zlib) or (raw)
+ (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT ->
+ HCRC -> TYPE
+ (zlib) -> DICTID or TYPE
+ DICTID -> DICT -> TYPE
+ (raw) -> TYPEDO
+ Read deflate blocks:
+ TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK
+ STORED -> COPY_ -> COPY -> TYPE
+ TABLE -> LENLENS -> CODELENS -> LEN_
+ LEN_ -> LEN
+ Read deflate codes in fixed or dynamic block:
+ LEN -> LENEXT or LIT or TYPE
+ LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
+ LIT -> LEN
+ Process trailer:
+ CHECK -> LENGTH -> DONE
+ */
+
+/* state maintained between inflate() calls. Approximately 10K bytes. */
+struct inflate_state {
+ inflate_mode mode; /* current inflate mode */
+ int last; /* true if processing last block */
+ int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
+ int havedict; /* true if dictionary provided */
+ int flags; /* gzip header method and flags (0 if zlib) */
+ unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */
+ unsigned long check; /* protected copy of check value */
+ unsigned long total; /* protected copy of output count */
+ gz_headerp head; /* where to save gzip header information */
+ /* sliding window */
+ unsigned wbits; /* log base 2 of requested window size */
+ unsigned wsize; /* window size or zero if not using window */
+ unsigned whave; /* valid bytes in the window */
+ unsigned wnext; /* window write index */
+ unsigned char FAR *window; /* allocated sliding window, if needed */
+ /* bit accumulator */
+ unsigned long hold; /* input bit accumulator */
+ unsigned bits; /* number of bits in "in" */
+ /* for string and stored block copying */
+ unsigned length; /* literal or length of data to copy */
+ unsigned offset; /* distance back to copy string from */
+ /* for table and code decoding */
+ unsigned extra; /* extra bits needed */
+ /* fixed and dynamic code tables */
+ code const FAR *lencode; /* starting table for length/literal codes */
+ code const FAR *distcode; /* starting table for distance codes */
+ unsigned lenbits; /* index bits for lencode */
+ unsigned distbits; /* index bits for distcode */
+ /* dynamic table building */
+ unsigned ncode; /* number of code length code lengths */
+ unsigned nlen; /* number of length code lengths */
+ unsigned ndist; /* number of distance code lengths */
+ unsigned have; /* number of code lengths in lens[] */
+ code FAR *next; /* next available space in codes[] */
+ unsigned short lens[320]; /* temporary storage for code lengths */
+ unsigned short work[288]; /* work area for code table building */
+ code codes[ENOUGH]; /* space for code tables */
+ int sane; /* if false, allow invalid distance too far */
+ int back; /* bits back of last unprocessed length/lit */
+ unsigned was; /* initial length of match */
+};
--- /dev/null
+/* inftrees.h -- header to use inftrees.c
+ * Copyright (C) 1995-2005, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+/* Structure for decoding tables. Each entry provides either the
+ information needed to do the operation requested by the code that
+ indexed that table entry, or it provides a pointer to another
+ table that indexes more bits of the code. op indicates whether
+ the entry is a pointer to another table, a literal, a length or
+ distance, an end-of-block, or an invalid code. For a table
+ pointer, the low four bits of op is the number of index bits of
+ that table. For a length or distance, the low four bits of op
+ is the number of extra bits to get after the code. bits is
+ the number of bits in this code or part of the code to drop off
+ of the bit buffer. val is the actual byte to output in the case
+ of a literal, the base length or distance, or the offset from
+ the current table to the next table. Each entry is four bytes. */
+typedef struct {
+ unsigned char op; /* operation, extra bits, table bits */
+ unsigned char bits; /* bits in this part of the code */
+ unsigned short val; /* offset in table or code value */
+} code;
+
+/* op values as set by inflate_table():
+ 00000000 - literal
+ 0000tttt - table link, tttt != 0 is the number of table index bits
+ 0001eeee - length or distance, eeee is the number of extra bits
+ 01100000 - end of block
+ 01000000 - invalid code
+ */
+
+/* Maximum size of the dynamic table. The maximum number of code structures is
+ 1444, which is the sum of 852 for literal/length codes and 592 for distance
+ codes. These values were found by exhaustive searches using the program
+ examples/enough.c found in the zlib distribtution. The arguments to that
+ program are the number of symbols, the initial root table size, and the
+ maximum bit length of a code. "enough 286 9 15" for literal/length codes
+ returns returns 852, and "enough 30 6 15" for distance codes returns 592.
+ The initial root table size (9 or 6) is found in the fifth argument of the
+ inflate_table() calls in inflate.c and infback.c. If the root table size is
+ changed, then these maximum sizes would be need to be recalculated and
+ updated. */
+#define ENOUGH_LENS 852
+#define ENOUGH_DISTS 592
+#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS)
+
+/* Type of code to build for inflate_table() */
+typedef enum {
+ CODES,
+ LENS,
+ DISTS
+} codetype;
+
+int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens,
+ unsigned codes, code FAR * FAR *table,
+ unsigned FAR *bits, unsigned short FAR *work));
--- /dev/null
+/*
+ * %W% %E%
+ *
+ * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+/*
+ * We used part of Netscape's Java Runtime Interface (JRI) as the starting
+ * point of our design and implementation.
+ */
+
+/******************************************************************************
+ * Java Runtime Interface
+ * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
+ *****************************************************************************/
+
+#ifndef _JAVASOFT_JNI_H_
+#define _JAVASOFT_JNI_H_
+
+#include <stdio.h>
+#include <stdarg.h>
+
+/* jni_md.h contains the machine-dependent typedefs for jbyte, jint
+ and jlong */
+
+#include "jni_md.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * JNI Types
+ */
+
+#ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H
+
+typedef unsigned char jboolean;
+typedef unsigned short jchar;
+typedef short jshort;
+typedef float jfloat;
+typedef double jdouble;
+
+typedef jint jsize;
+
+#ifdef __cplusplus
+
+class _jobject {};
+class _jclass : public _jobject {};
+class _jthrowable : public _jobject {};
+class _jstring : public _jobject {};
+class _jarray : public _jobject {};
+class _jbooleanArray : public _jarray {};
+class _jbyteArray : public _jarray {};
+class _jcharArray : public _jarray {};
+class _jshortArray : public _jarray {};
+class _jintArray : public _jarray {};
+class _jlongArray : public _jarray {};
+class _jfloatArray : public _jarray {};
+class _jdoubleArray : public _jarray {};
+class _jobjectArray : public _jarray {};
+
+typedef _jobject *jobject;
+typedef _jclass *jclass;
+typedef _jthrowable *jthrowable;
+typedef _jstring *jstring;
+typedef _jarray *jarray;
+typedef _jbooleanArray *jbooleanArray;
+typedef _jbyteArray *jbyteArray;
+typedef _jcharArray *jcharArray;
+typedef _jshortArray *jshortArray;
+typedef _jintArray *jintArray;
+typedef _jlongArray *jlongArray;
+typedef _jfloatArray *jfloatArray;
+typedef _jdoubleArray *jdoubleArray;
+typedef _jobjectArray *jobjectArray;
+
+#else
+
+struct _jobject;
+
+typedef struct _jobject *jobject;
+typedef jobject jclass;
+typedef jobject jthrowable;
+typedef jobject jstring;
+typedef jobject jarray;
+typedef jarray jbooleanArray;
+typedef jarray jbyteArray;
+typedef jarray jcharArray;
+typedef jarray jshortArray;
+typedef jarray jintArray;
+typedef jarray jlongArray;
+typedef jarray jfloatArray;
+typedef jarray jdoubleArray;
+typedef jarray jobjectArray;
+
+#endif
+
+typedef jobject jweak;
+
+typedef union jvalue {
+ jboolean z;
+ jbyte b;
+ jchar c;
+ jshort s;
+ jint i;
+ jlong j;
+ jfloat f;
+ jdouble d;
+ jobject l;
+} jvalue;
+
+struct _jfieldID;
+typedef struct _jfieldID *jfieldID;
+
+struct _jmethodID;
+typedef struct _jmethodID *jmethodID;
+
+/* Return values from jobjectRefType */
+typedef enum _jobjectType {
+ JNIInvalidRefType = 0,
+ JNILocalRefType = 1,
+ JNIGlobalRefType = 2,
+ JNIWeakGlobalRefType = 3
+} jobjectRefType;
+
+
+#endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */
+
+/*
+ * jboolean constants
+ */
+
+#define JNI_FALSE 0
+#define JNI_TRUE 1
+
+/*
+ * possible return values for JNI functions.
+ */
+
+#define JNI_OK 0 /* success */
+#define JNI_ERR (-1) /* unknown error */
+#define JNI_EDETACHED (-2) /* thread detached from the VM */
+#define JNI_EVERSION (-3) /* JNI version error */
+#define JNI_ENOMEM (-4) /* not enough memory */
+#define JNI_EEXIST (-5) /* VM already created */
+#define JNI_EINVAL (-6) /* invalid arguments */
+
+/*
+ * used in ReleaseScalarArrayElements
+ */
+
+#define JNI_COMMIT 1
+#define JNI_ABORT 2
+
+/*
+ * used in RegisterNatives to describe native method name, signature,
+ * and function pointer.
+ */
+
+typedef struct {
+ char *name;
+ char *signature;
+ void *fnPtr;
+} JNINativeMethod;
+
+/*
+ * JNI Native Method Interface.
+ */
+
+struct JNINativeInterface_;
+
+struct JNIEnv_;
+
+#ifdef __cplusplus
+typedef JNIEnv_ JNIEnv;
+#else
+typedef const struct JNINativeInterface_ *JNIEnv;
+#endif
+
+/*
+ * JNI Invocation Interface.
+ */
+
+struct JNIInvokeInterface_;
+
+struct JavaVM_;
+
+#ifdef __cplusplus
+typedef JavaVM_ JavaVM;
+#else
+typedef const struct JNIInvokeInterface_ *JavaVM;
+#endif
+
+struct JNINativeInterface_ {
+ void *reserved0;
+ void *reserved1;
+ void *reserved2;
+
+ void *reserved3;
+ jint (JNICALL *GetVersion)(JNIEnv *env);
+
+ jclass (JNICALL *DefineClass)
+ (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
+ jsize len);
+ jclass (JNICALL *FindClass)
+ (JNIEnv *env, const char *name);
+
+ jmethodID (JNICALL *FromReflectedMethod)
+ (JNIEnv *env, jobject method);
+ jfieldID (JNICALL *FromReflectedField)
+ (JNIEnv *env, jobject field);
+
+ jobject (JNICALL *ToReflectedMethod)
+ (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
+
+ jclass (JNICALL *GetSuperclass)
+ (JNIEnv *env, jclass sub);
+ jboolean (JNICALL *IsAssignableFrom)
+ (JNIEnv *env, jclass sub, jclass sup);
+
+ jobject (JNICALL *ToReflectedField)
+ (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
+
+ jint (JNICALL *Throw)
+ (JNIEnv *env, jthrowable obj);
+ jint (JNICALL *ThrowNew)
+ (JNIEnv *env, jclass clazz, const char *msg);
+ jthrowable (JNICALL *ExceptionOccurred)
+ (JNIEnv *env);
+ void (JNICALL *ExceptionDescribe)
+ (JNIEnv *env);
+ void (JNICALL *ExceptionClear)
+ (JNIEnv *env);
+ void (JNICALL *FatalError)
+ (JNIEnv *env, const char *msg);
+
+ jint (JNICALL *PushLocalFrame)
+ (JNIEnv *env, jint capacity);
+ jobject (JNICALL *PopLocalFrame)
+ (JNIEnv *env, jobject result);
+
+ jobject (JNICALL *NewGlobalRef)
+ (JNIEnv *env, jobject lobj);
+ void (JNICALL *DeleteGlobalRef)
+ (JNIEnv *env, jobject gref);
+ void (JNICALL *DeleteLocalRef)
+ (JNIEnv *env, jobject obj);
+ jboolean (JNICALL *IsSameObject)
+ (JNIEnv *env, jobject obj1, jobject obj2);
+ jobject (JNICALL *NewLocalRef)
+ (JNIEnv *env, jobject ref);
+ jint (JNICALL *EnsureLocalCapacity)
+ (JNIEnv *env, jint capacity);
+
+ jobject (JNICALL *AllocObject)
+ (JNIEnv *env, jclass clazz);
+ jobject (JNICALL *NewObject)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jobject (JNICALL *NewObjectV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jobject (JNICALL *NewObjectA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jclass (JNICALL *GetObjectClass)
+ (JNIEnv *env, jobject obj);
+ jboolean (JNICALL *IsInstanceOf)
+ (JNIEnv *env, jobject obj, jclass clazz);
+
+ jmethodID (JNICALL *GetMethodID)
+ (JNIEnv *env, jclass clazz, const char *name, const char *sig);
+
+ jobject (JNICALL *CallObjectMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jobject (JNICALL *CallObjectMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jobject (JNICALL *CallObjectMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
+
+ jboolean (JNICALL *CallBooleanMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jboolean (JNICALL *CallBooleanMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jboolean (JNICALL *CallBooleanMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
+
+ jbyte (JNICALL *CallByteMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jbyte (JNICALL *CallByteMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jbyte (JNICALL *CallByteMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ jchar (JNICALL *CallCharMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jchar (JNICALL *CallCharMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jchar (JNICALL *CallCharMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ jshort (JNICALL *CallShortMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jshort (JNICALL *CallShortMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jshort (JNICALL *CallShortMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ jint (JNICALL *CallIntMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jint (JNICALL *CallIntMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jint (JNICALL *CallIntMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ jlong (JNICALL *CallLongMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jlong (JNICALL *CallLongMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jlong (JNICALL *CallLongMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ jfloat (JNICALL *CallFloatMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jfloat (JNICALL *CallFloatMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jfloat (JNICALL *CallFloatMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ jdouble (JNICALL *CallDoubleMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ jdouble (JNICALL *CallDoubleMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ jdouble (JNICALL *CallDoubleMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args);
+
+ void (JNICALL *CallVoidMethod)
+ (JNIEnv *env, jobject obj, jmethodID methodID, ...);
+ void (JNICALL *CallVoidMethodV)
+ (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
+ void (JNICALL *CallVoidMethodA)
+ (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args);
+
+ jobject (JNICALL *CallNonvirtualObjectMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jobject (JNICALL *CallNonvirtualObjectMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jobject (JNICALL *CallNonvirtualObjectMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue * args);
+
+ jboolean (JNICALL *CallNonvirtualBooleanMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jboolean (JNICALL *CallNonvirtualBooleanMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jboolean (JNICALL *CallNonvirtualBooleanMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue * args);
+
+ jbyte (JNICALL *CallNonvirtualByteMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jbyte (JNICALL *CallNonvirtualByteMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jbyte (JNICALL *CallNonvirtualByteMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ jchar (JNICALL *CallNonvirtualCharMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jchar (JNICALL *CallNonvirtualCharMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jchar (JNICALL *CallNonvirtualCharMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ jshort (JNICALL *CallNonvirtualShortMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jshort (JNICALL *CallNonvirtualShortMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jshort (JNICALL *CallNonvirtualShortMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ jint (JNICALL *CallNonvirtualIntMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jint (JNICALL *CallNonvirtualIntMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jint (JNICALL *CallNonvirtualIntMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ jlong (JNICALL *CallNonvirtualLongMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jlong (JNICALL *CallNonvirtualLongMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jlong (JNICALL *CallNonvirtualLongMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ jfloat (JNICALL *CallNonvirtualFloatMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jfloat (JNICALL *CallNonvirtualFloatMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jfloat (JNICALL *CallNonvirtualFloatMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ jdouble (JNICALL *CallNonvirtualDoubleMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ jdouble (JNICALL *CallNonvirtualDoubleMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ jdouble (JNICALL *CallNonvirtualDoubleMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue *args);
+
+ void (JNICALL *CallNonvirtualVoidMethod)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
+ void (JNICALL *CallNonvirtualVoidMethodV)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ va_list args);
+ void (JNICALL *CallNonvirtualVoidMethodA)
+ (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
+ const jvalue * args);
+
+ jfieldID (JNICALL *GetFieldID)
+ (JNIEnv *env, jclass clazz, const char *name, const char *sig);
+
+ jobject (JNICALL *GetObjectField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jboolean (JNICALL *GetBooleanField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jbyte (JNICALL *GetByteField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jchar (JNICALL *GetCharField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jshort (JNICALL *GetShortField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jint (JNICALL *GetIntField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jlong (JNICALL *GetLongField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jfloat (JNICALL *GetFloatField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+ jdouble (JNICALL *GetDoubleField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID);
+
+ void (JNICALL *SetObjectField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
+ void (JNICALL *SetBooleanField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
+ void (JNICALL *SetByteField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
+ void (JNICALL *SetCharField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
+ void (JNICALL *SetShortField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
+ void (JNICALL *SetIntField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
+ void (JNICALL *SetLongField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
+ void (JNICALL *SetFloatField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
+ void (JNICALL *SetDoubleField)
+ (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
+
+ jmethodID (JNICALL *GetStaticMethodID)
+ (JNIEnv *env, jclass clazz, const char *name, const char *sig);
+
+ jobject (JNICALL *CallStaticObjectMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jobject (JNICALL *CallStaticObjectMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jobject (JNICALL *CallStaticObjectMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jboolean (JNICALL *CallStaticBooleanMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jboolean (JNICALL *CallStaticBooleanMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jboolean (JNICALL *CallStaticBooleanMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jbyte (JNICALL *CallStaticByteMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jbyte (JNICALL *CallStaticByteMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jbyte (JNICALL *CallStaticByteMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jchar (JNICALL *CallStaticCharMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jchar (JNICALL *CallStaticCharMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jchar (JNICALL *CallStaticCharMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jshort (JNICALL *CallStaticShortMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jshort (JNICALL *CallStaticShortMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jshort (JNICALL *CallStaticShortMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jint (JNICALL *CallStaticIntMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jint (JNICALL *CallStaticIntMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jint (JNICALL *CallStaticIntMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jlong (JNICALL *CallStaticLongMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jlong (JNICALL *CallStaticLongMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jlong (JNICALL *CallStaticLongMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jfloat (JNICALL *CallStaticFloatMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jfloat (JNICALL *CallStaticFloatMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jfloat (JNICALL *CallStaticFloatMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ jdouble (JNICALL *CallStaticDoubleMethod)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
+ jdouble (JNICALL *CallStaticDoubleMethodV)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
+ jdouble (JNICALL *CallStaticDoubleMethodA)
+ (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args);
+
+ void (JNICALL *CallStaticVoidMethod)
+ (JNIEnv *env, jclass cls, jmethodID methodID, ...);
+ void (JNICALL *CallStaticVoidMethodV)
+ (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
+ void (JNICALL *CallStaticVoidMethodA)
+ (JNIEnv *env, jclass cls, jmethodID methodID, const jvalue * args);
+
+ jfieldID (JNICALL *GetStaticFieldID)
+ (JNIEnv *env, jclass clazz, const char *name, const char *sig);
+ jobject (JNICALL *GetStaticObjectField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jboolean (JNICALL *GetStaticBooleanField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jbyte (JNICALL *GetStaticByteField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jchar (JNICALL *GetStaticCharField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jshort (JNICALL *GetStaticShortField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jint (JNICALL *GetStaticIntField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jlong (JNICALL *GetStaticLongField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jfloat (JNICALL *GetStaticFloatField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+ jdouble (JNICALL *GetStaticDoubleField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID);
+
+ void (JNICALL *SetStaticObjectField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
+ void (JNICALL *SetStaticBooleanField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
+ void (JNICALL *SetStaticByteField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
+ void (JNICALL *SetStaticCharField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
+ void (JNICALL *SetStaticShortField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
+ void (JNICALL *SetStaticIntField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
+ void (JNICALL *SetStaticLongField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
+ void (JNICALL *SetStaticFloatField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
+ void (JNICALL *SetStaticDoubleField)
+ (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
+
+ jstring (JNICALL *NewString)
+ (JNIEnv *env, const jchar *unicode, jsize len);
+ jsize (JNICALL *GetStringLength)
+ (JNIEnv *env, jstring str);
+ const jchar *(JNICALL *GetStringChars)
+ (JNIEnv *env, jstring str, jboolean *isCopy);
+ void (JNICALL *ReleaseStringChars)
+ (JNIEnv *env, jstring str, const jchar *chars);
+
+ jstring (JNICALL *NewStringUTF)
+ (JNIEnv *env, const char *utf);
+ jsize (JNICALL *GetStringUTFLength)
+ (JNIEnv *env, jstring str);
+ const char* (JNICALL *GetStringUTFChars)
+ (JNIEnv *env, jstring str, jboolean *isCopy);
+ void (JNICALL *ReleaseStringUTFChars)
+ (JNIEnv *env, jstring str, const char* chars);
+
+
+ jsize (JNICALL *GetArrayLength)
+ (JNIEnv *env, jarray array);
+
+ jobjectArray (JNICALL *NewObjectArray)
+ (JNIEnv *env, jsize len, jclass clazz, jobject init);
+ jobject (JNICALL *GetObjectArrayElement)
+ (JNIEnv *env, jobjectArray array, jsize index);
+ void (JNICALL *SetObjectArrayElement)
+ (JNIEnv *env, jobjectArray array, jsize index, jobject val);
+
+ jbooleanArray (JNICALL *NewBooleanArray)
+ (JNIEnv *env, jsize len);
+ jbyteArray (JNICALL *NewByteArray)
+ (JNIEnv *env, jsize len);
+ jcharArray (JNICALL *NewCharArray)
+ (JNIEnv *env, jsize len);
+ jshortArray (JNICALL *NewShortArray)
+ (JNIEnv *env, jsize len);
+ jintArray (JNICALL *NewIntArray)
+ (JNIEnv *env, jsize len);
+ jlongArray (JNICALL *NewLongArray)
+ (JNIEnv *env, jsize len);
+ jfloatArray (JNICALL *NewFloatArray)
+ (JNIEnv *env, jsize len);
+ jdoubleArray (JNICALL *NewDoubleArray)
+ (JNIEnv *env, jsize len);
+
+ jboolean * (JNICALL *GetBooleanArrayElements)
+ (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
+ jbyte * (JNICALL *GetByteArrayElements)
+ (JNIEnv *env, jbyteArray array, jboolean *isCopy);
+ jchar * (JNICALL *GetCharArrayElements)
+ (JNIEnv *env, jcharArray array, jboolean *isCopy);
+ jshort * (JNICALL *GetShortArrayElements)
+ (JNIEnv *env, jshortArray array, jboolean *isCopy);
+ jint * (JNICALL *GetIntArrayElements)
+ (JNIEnv *env, jintArray array, jboolean *isCopy);
+ jlong * (JNICALL *GetLongArrayElements)
+ (JNIEnv *env, jlongArray array, jboolean *isCopy);
+ jfloat * (JNICALL *GetFloatArrayElements)
+ (JNIEnv *env, jfloatArray array, jboolean *isCopy);
+ jdouble * (JNICALL *GetDoubleArrayElements)
+ (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
+
+ void (JNICALL *ReleaseBooleanArrayElements)
+ (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
+ void (JNICALL *ReleaseByteArrayElements)
+ (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
+ void (JNICALL *ReleaseCharArrayElements)
+ (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
+ void (JNICALL *ReleaseShortArrayElements)
+ (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
+ void (JNICALL *ReleaseIntArrayElements)
+ (JNIEnv *env, jintArray array, jint *elems, jint mode);
+ void (JNICALL *ReleaseLongArrayElements)
+ (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
+ void (JNICALL *ReleaseFloatArrayElements)
+ (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
+ void (JNICALL *ReleaseDoubleArrayElements)
+ (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
+
+ void (JNICALL *GetBooleanArrayRegion)
+ (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
+ void (JNICALL *GetByteArrayRegion)
+ (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
+ void (JNICALL *GetCharArrayRegion)
+ (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
+ void (JNICALL *GetShortArrayRegion)
+ (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
+ void (JNICALL *GetIntArrayRegion)
+ (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
+ void (JNICALL *GetLongArrayRegion)
+ (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
+ void (JNICALL *GetFloatArrayRegion)
+ (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
+ void (JNICALL *GetDoubleArrayRegion)
+ (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
+
+ void (JNICALL *SetBooleanArrayRegion)
+ (JNIEnv *env, jbooleanArray array, jsize start, jsize l, const jboolean *buf);
+ void (JNICALL *SetByteArrayRegion)
+ (JNIEnv *env, jbyteArray array, jsize start, jsize len, const jbyte *buf);
+ void (JNICALL *SetCharArrayRegion)
+ (JNIEnv *env, jcharArray array, jsize start, jsize len, const jchar *buf);
+ void (JNICALL *SetShortArrayRegion)
+ (JNIEnv *env, jshortArray array, jsize start, jsize len, const jshort *buf);
+ void (JNICALL *SetIntArrayRegion)
+ (JNIEnv *env, jintArray array, jsize start, jsize len, const jint *buf);
+ void (JNICALL *SetLongArrayRegion)
+ (JNIEnv *env, jlongArray array, jsize start, jsize len, const jlong *buf);
+ void (JNICALL *SetFloatArrayRegion)
+ (JNIEnv *env, jfloatArray array, jsize start, jsize len, const jfloat *buf);
+ void (JNICALL *SetDoubleArrayRegion)
+ (JNIEnv *env, jdoubleArray array, jsize start, jsize len, const jdouble *buf);
+
+ jint (JNICALL *RegisterNatives)
+ (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
+ jint nMethods);
+ jint (JNICALL *UnregisterNatives)
+ (JNIEnv *env, jclass clazz);
+
+ jint (JNICALL *MonitorEnter)
+ (JNIEnv *env, jobject obj);
+ jint (JNICALL *MonitorExit)
+ (JNIEnv *env, jobject obj);
+
+ jint (JNICALL *GetJavaVM)
+ (JNIEnv *env, JavaVM **vm);
+
+ void (JNICALL *GetStringRegion)
+ (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
+ void (JNICALL *GetStringUTFRegion)
+ (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
+
+ void * (JNICALL *GetPrimitiveArrayCritical)
+ (JNIEnv *env, jarray array, jboolean *isCopy);
+ void (JNICALL *ReleasePrimitiveArrayCritical)
+ (JNIEnv *env, jarray array, void *carray, jint mode);
+
+ const jchar * (JNICALL *GetStringCritical)
+ (JNIEnv *env, jstring string, jboolean *isCopy);
+ void (JNICALL *ReleaseStringCritical)
+ (JNIEnv *env, jstring string, const jchar *cstring);
+
+ jweak (JNICALL *NewWeakGlobalRef)
+ (JNIEnv *env, jobject obj);
+ void (JNICALL *DeleteWeakGlobalRef)
+ (JNIEnv *env, jweak ref);
+
+ jboolean (JNICALL *ExceptionCheck)
+ (JNIEnv *env);
+
+ jobject (JNICALL *NewDirectByteBuffer)
+ (JNIEnv* env, void* address, jlong capacity);
+ void* (JNICALL *GetDirectBufferAddress)
+ (JNIEnv* env, jobject buf);
+ jlong (JNICALL *GetDirectBufferCapacity)
+ (JNIEnv* env, jobject buf);
+
+ /* New JNI 1.6 Features */
+
+ jobjectRefType (JNICALL *GetObjectRefType)
+ (JNIEnv* env, jobject obj);
+};
+
+/*
+ * We use inlined functions for C++ so that programmers can write:
+ *
+ * env->FindClass("java/lang/String")
+ *
+ * in C++ rather than:
+ *
+ * (*env)->FindClass(env, "java/lang/String")
+ *
+ * in C.
+ */
+
+struct JNIEnv_ {
+ const struct JNINativeInterface_ *functions;
+#ifdef __cplusplus
+
+ jint GetVersion() {
+ return functions->GetVersion(this);
+ }
+ jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
+ jsize len) {
+ return functions->DefineClass(this, name, loader, buf, len);
+ }
+ jclass FindClass(const char *name) {
+ return functions->FindClass(this, name);
+ }
+ jmethodID FromReflectedMethod(jobject method) {
+ return functions->FromReflectedMethod(this,method);
+ }
+ jfieldID FromReflectedField(jobject field) {
+ return functions->FromReflectedField(this,field);
+ }
+
+ jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
+ return functions->ToReflectedMethod(this, cls, methodID, isStatic);
+ }
+
+ jclass GetSuperclass(jclass sub) {
+ return functions->GetSuperclass(this, sub);
+ }
+ jboolean IsAssignableFrom(jclass sub, jclass sup) {
+ return functions->IsAssignableFrom(this, sub, sup);
+ }
+
+ jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
+ return functions->ToReflectedField(this,cls,fieldID,isStatic);
+ }
+
+ jint Throw(jthrowable obj) {
+ return functions->Throw(this, obj);
+ }
+ jint ThrowNew(jclass clazz, const char *msg) {
+ return functions->ThrowNew(this, clazz, msg);
+ }
+ jthrowable ExceptionOccurred() {
+ return functions->ExceptionOccurred(this);
+ }
+ void ExceptionDescribe() {
+ functions->ExceptionDescribe(this);
+ }
+ void ExceptionClear() {
+ functions->ExceptionClear(this);
+ }
+ void FatalError(const char *msg) {
+ functions->FatalError(this, msg);
+ }
+
+ jint PushLocalFrame(jint capacity) {
+ return functions->PushLocalFrame(this,capacity);
+ }
+ jobject PopLocalFrame(jobject result) {
+ return functions->PopLocalFrame(this,result);
+ }
+
+ jobject NewGlobalRef(jobject lobj) {
+ return functions->NewGlobalRef(this,lobj);
+ }
+ void DeleteGlobalRef(jobject gref) {
+ functions->DeleteGlobalRef(this,gref);
+ }
+ void DeleteLocalRef(jobject obj) {
+ functions->DeleteLocalRef(this, obj);
+ }
+
+ jboolean IsSameObject(jobject obj1, jobject obj2) {
+ return functions->IsSameObject(this,obj1,obj2);
+ }
+
+ jobject NewLocalRef(jobject ref) {
+ return functions->NewLocalRef(this,ref);
+ }
+ jint EnsureLocalCapacity(jint capacity) {
+ return functions->EnsureLocalCapacity(this,capacity);
+ }
+
+ jobject AllocObject(jclass clazz) {
+ return functions->AllocObject(this,clazz);
+ }
+ jobject NewObject(jclass clazz, jmethodID methodID, ...) {
+ va_list args;
+ jobject result;
+ va_start(args, methodID);
+ result = functions->NewObjectV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jobject NewObjectV(jclass clazz, jmethodID methodID,
+ va_list args) {
+ return functions->NewObjectV(this,clazz,methodID,args);
+ }
+ jobject NewObjectA(jclass clazz, jmethodID methodID,
+ const jvalue *args) {
+ return functions->NewObjectA(this,clazz,methodID,args);
+ }
+
+ jclass GetObjectClass(jobject obj) {
+ return functions->GetObjectClass(this,obj);
+ }
+ jboolean IsInstanceOf(jobject obj, jclass clazz) {
+ return functions->IsInstanceOf(this,obj,clazz);
+ }
+
+ jmethodID GetMethodID(jclass clazz, const char *name,
+ const char *sig) {
+ return functions->GetMethodID(this,clazz,name,sig);
+ }
+
+ jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jobject result;
+ va_start(args,methodID);
+ result = functions->CallObjectMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jobject CallObjectMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallObjectMethodV(this,obj,methodID,args);
+ }
+ jobject CallObjectMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallObjectMethodA(this,obj,methodID,args);
+ }
+
+ jboolean CallBooleanMethod(jobject obj,
+ jmethodID methodID, ...) {
+ va_list args;
+ jboolean result;
+ va_start(args,methodID);
+ result = functions->CallBooleanMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallBooleanMethodV(this,obj,methodID,args);
+ }
+ jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallBooleanMethodA(this,obj,methodID, args);
+ }
+
+ jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jbyte result;
+ va_start(args,methodID);
+ result = functions->CallByteMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jbyte CallByteMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallByteMethodV(this,obj,methodID,args);
+ }
+ jbyte CallByteMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallByteMethodA(this,obj,methodID,args);
+ }
+
+ jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jchar result;
+ va_start(args,methodID);
+ result = functions->CallCharMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jchar CallCharMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallCharMethodV(this,obj,methodID,args);
+ }
+ jchar CallCharMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallCharMethodA(this,obj,methodID,args);
+ }
+
+ jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jshort result;
+ va_start(args,methodID);
+ result = functions->CallShortMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jshort CallShortMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallShortMethodV(this,obj,methodID,args);
+ }
+ jshort CallShortMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallShortMethodA(this,obj,methodID,args);
+ }
+
+ jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jint result;
+ va_start(args,methodID);
+ result = functions->CallIntMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jint CallIntMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallIntMethodV(this,obj,methodID,args);
+ }
+ jint CallIntMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallIntMethodA(this,obj,methodID,args);
+ }
+
+ jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jlong result;
+ va_start(args,methodID);
+ result = functions->CallLongMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jlong CallLongMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallLongMethodV(this,obj,methodID,args);
+ }
+ jlong CallLongMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallLongMethodA(this,obj,methodID,args);
+ }
+
+ jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jfloat result;
+ va_start(args,methodID);
+ result = functions->CallFloatMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallFloatMethodV(this,obj,methodID,args);
+ }
+ jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallFloatMethodA(this,obj,methodID,args);
+ }
+
+ jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ jdouble result;
+ va_start(args,methodID);
+ result = functions->CallDoubleMethodV(this,obj,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ return functions->CallDoubleMethodV(this,obj,methodID,args);
+ }
+ jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallDoubleMethodA(this,obj,methodID,args);
+ }
+
+ void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
+ va_list args;
+ va_start(args,methodID);
+ functions->CallVoidMethodV(this,obj,methodID,args);
+ va_end(args);
+ }
+ void CallVoidMethodV(jobject obj, jmethodID methodID,
+ va_list args) {
+ functions->CallVoidMethodV(this,obj,methodID,args);
+ }
+ void CallVoidMethodA(jobject obj, jmethodID methodID,
+ const jvalue * args) {
+ functions->CallVoidMethodA(this,obj,methodID,args);
+ }
+
+ jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jobject result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jboolean result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
+ methodID, args);
+ }
+
+ jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jbyte result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualByteMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualByteMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jchar result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualCharMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualCharMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jshort result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualShortMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualShortMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jint result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualIntMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualIntMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jlong result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallNonvirtualLongMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
+ jmethodID methodID, const jvalue * args) {
+ return functions->CallNonvirtualLongMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jfloat result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
+ jmethodID methodID,
+ va_list args) {
+ return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
+ jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jdouble result;
+ va_start(args,methodID);
+ result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
+ methodID,args);
+ va_end(args);
+ return result;
+ }
+ jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
+ jmethodID methodID,
+ va_list args) {
+ return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
+ methodID,args);
+ }
+ jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
+ jmethodID methodID,
+ const jvalue * args) {
+ return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
+ methodID,args);
+ }
+
+ void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ va_start(args,methodID);
+ functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
+ va_end(args);
+ }
+ void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
+ jmethodID methodID,
+ va_list args) {
+ functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
+ }
+ void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
+ jmethodID methodID,
+ const jvalue * args) {
+ functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
+ }
+
+ jfieldID GetFieldID(jclass clazz, const char *name,
+ const char *sig) {
+ return functions->GetFieldID(this,clazz,name,sig);
+ }
+
+ jobject GetObjectField(jobject obj, jfieldID fieldID) {
+ return functions->GetObjectField(this,obj,fieldID);
+ }
+ jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
+ return functions->GetBooleanField(this,obj,fieldID);
+ }
+ jbyte GetByteField(jobject obj, jfieldID fieldID) {
+ return functions->GetByteField(this,obj,fieldID);
+ }
+ jchar GetCharField(jobject obj, jfieldID fieldID) {
+ return functions->GetCharField(this,obj,fieldID);
+ }
+ jshort GetShortField(jobject obj, jfieldID fieldID) {
+ return functions->GetShortField(this,obj,fieldID);
+ }
+ jint GetIntField(jobject obj, jfieldID fieldID) {
+ return functions->GetIntField(this,obj,fieldID);
+ }
+ jlong GetLongField(jobject obj, jfieldID fieldID) {
+ return functions->GetLongField(this,obj,fieldID);
+ }
+ jfloat GetFloatField(jobject obj, jfieldID fieldID) {
+ return functions->GetFloatField(this,obj,fieldID);
+ }
+ jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
+ return functions->GetDoubleField(this,obj,fieldID);
+ }
+
+ void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
+ functions->SetObjectField(this,obj,fieldID,val);
+ }
+ void SetBooleanField(jobject obj, jfieldID fieldID,
+ jboolean val) {
+ functions->SetBooleanField(this,obj,fieldID,val);
+ }
+ void SetByteField(jobject obj, jfieldID fieldID,
+ jbyte val) {
+ functions->SetByteField(this,obj,fieldID,val);
+ }
+ void SetCharField(jobject obj, jfieldID fieldID,
+ jchar val) {
+ functions->SetCharField(this,obj,fieldID,val);
+ }
+ void SetShortField(jobject obj, jfieldID fieldID,
+ jshort val) {
+ functions->SetShortField(this,obj,fieldID,val);
+ }
+ void SetIntField(jobject obj, jfieldID fieldID,
+ jint val) {
+ functions->SetIntField(this,obj,fieldID,val);
+ }
+ void SetLongField(jobject obj, jfieldID fieldID,
+ jlong val) {
+ functions->SetLongField(this,obj,fieldID,val);
+ }
+ void SetFloatField(jobject obj, jfieldID fieldID,
+ jfloat val) {
+ functions->SetFloatField(this,obj,fieldID,val);
+ }
+ void SetDoubleField(jobject obj, jfieldID fieldID,
+ jdouble val) {
+ functions->SetDoubleField(this,obj,fieldID,val);
+ }
+
+ jmethodID GetStaticMethodID(jclass clazz, const char *name,
+ const char *sig) {
+ return functions->GetStaticMethodID(this,clazz,name,sig);
+ }
+
+ jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
+ ...) {
+ va_list args;
+ jobject result;
+ va_start(args,methodID);
+ result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
+ va_list args) {
+ return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
+ }
+ jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
+ const jvalue *args) {
+ return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
+ }
+
+ jboolean CallStaticBooleanMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jboolean result;
+ va_start(args,methodID);
+ result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jboolean CallStaticBooleanMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
+ }
+ jboolean CallStaticBooleanMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
+ }
+
+ jbyte CallStaticByteMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jbyte result;
+ va_start(args,methodID);
+ result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jbyte CallStaticByteMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticByteMethodV(this,clazz,methodID,args);
+ }
+ jbyte CallStaticByteMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticByteMethodA(this,clazz,methodID,args);
+ }
+
+ jchar CallStaticCharMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jchar result;
+ va_start(args,methodID);
+ result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jchar CallStaticCharMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticCharMethodV(this,clazz,methodID,args);
+ }
+ jchar CallStaticCharMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticCharMethodA(this,clazz,methodID,args);
+ }
+
+ jshort CallStaticShortMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jshort result;
+ va_start(args,methodID);
+ result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jshort CallStaticShortMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticShortMethodV(this,clazz,methodID,args);
+ }
+ jshort CallStaticShortMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticShortMethodA(this,clazz,methodID,args);
+ }
+
+ jint CallStaticIntMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jint result;
+ va_start(args,methodID);
+ result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jint CallStaticIntMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticIntMethodV(this,clazz,methodID,args);
+ }
+ jint CallStaticIntMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticIntMethodA(this,clazz,methodID,args);
+ }
+
+ jlong CallStaticLongMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jlong result;
+ va_start(args,methodID);
+ result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jlong CallStaticLongMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticLongMethodV(this,clazz,methodID,args);
+ }
+ jlong CallStaticLongMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticLongMethodA(this,clazz,methodID,args);
+ }
+
+ jfloat CallStaticFloatMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jfloat result;
+ va_start(args,methodID);
+ result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jfloat CallStaticFloatMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
+ }
+ jfloat CallStaticFloatMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
+ }
+
+ jdouble CallStaticDoubleMethod(jclass clazz,
+ jmethodID methodID, ...) {
+ va_list args;
+ jdouble result;
+ va_start(args,methodID);
+ result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
+ va_end(args);
+ return result;
+ }
+ jdouble CallStaticDoubleMethodV(jclass clazz,
+ jmethodID methodID, va_list args) {
+ return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
+ }
+ jdouble CallStaticDoubleMethodA(jclass clazz,
+ jmethodID methodID, const jvalue *args) {
+ return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
+ }
+
+ void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
+ va_list args;
+ va_start(args,methodID);
+ functions->CallStaticVoidMethodV(this,cls,methodID,args);
+ va_end(args);
+ }
+ void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
+ va_list args) {
+ functions->CallStaticVoidMethodV(this,cls,methodID,args);
+ }
+ void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
+ const jvalue * args) {
+ functions->CallStaticVoidMethodA(this,cls,methodID,args);
+ }
+
+ jfieldID GetStaticFieldID(jclass clazz, const char *name,
+ const char *sig) {
+ return functions->GetStaticFieldID(this,clazz,name,sig);
+ }
+ jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticObjectField(this,clazz,fieldID);
+ }
+ jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticBooleanField(this,clazz,fieldID);
+ }
+ jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticByteField(this,clazz,fieldID);
+ }
+ jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticCharField(this,clazz,fieldID);
+ }
+ jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticShortField(this,clazz,fieldID);
+ }
+ jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticIntField(this,clazz,fieldID);
+ }
+ jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticLongField(this,clazz,fieldID);
+ }
+ jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticFloatField(this,clazz,fieldID);
+ }
+ jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
+ return functions->GetStaticDoubleField(this,clazz,fieldID);
+ }
+
+ void SetStaticObjectField(jclass clazz, jfieldID fieldID,
+ jobject value) {
+ functions->SetStaticObjectField(this,clazz,fieldID,value);
+ }
+ void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
+ jboolean value) {
+ functions->SetStaticBooleanField(this,clazz,fieldID,value);
+ }
+ void SetStaticByteField(jclass clazz, jfieldID fieldID,
+ jbyte value) {
+ functions->SetStaticByteField(this,clazz,fieldID,value);
+ }
+ void SetStaticCharField(jclass clazz, jfieldID fieldID,
+ jchar value) {
+ functions->SetStaticCharField(this,clazz,fieldID,value);
+ }
+ void SetStaticShortField(jclass clazz, jfieldID fieldID,
+ jshort value) {
+ functions->SetStaticShortField(this,clazz,fieldID,value);
+ }
+ void SetStaticIntField(jclass clazz, jfieldID fieldID,
+ jint value) {
+ functions->SetStaticIntField(this,clazz,fieldID,value);
+ }
+ void SetStaticLongField(jclass clazz, jfieldID fieldID,
+ jlong value) {
+ functions->SetStaticLongField(this,clazz,fieldID,value);
+ }
+ void SetStaticFloatField(jclass clazz, jfieldID fieldID,
+ jfloat value) {
+ functions->SetStaticFloatField(this,clazz,fieldID,value);
+ }
+ void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
+ jdouble value) {
+ functions->SetStaticDoubleField(this,clazz,fieldID,value);
+ }
+
+ jstring NewString(const jchar *unicode, jsize len) {
+ return functions->NewString(this,unicode,len);
+ }
+ jsize GetStringLength(jstring str) {
+ return functions->GetStringLength(this,str);
+ }
+ const jchar *GetStringChars(jstring str, jboolean *isCopy) {
+ return functions->GetStringChars(this,str,isCopy);
+ }
+ void ReleaseStringChars(jstring str, const jchar *chars) {
+ functions->ReleaseStringChars(this,str,chars);
+ }
+
+ jstring NewStringUTF(const char *utf) {
+ return functions->NewStringUTF(this,utf);
+ }
+ jsize GetStringUTFLength(jstring str) {
+ return functions->GetStringUTFLength(this,str);
+ }
+ const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
+ return functions->GetStringUTFChars(this,str,isCopy);
+ }
+ void ReleaseStringUTFChars(jstring str, const char* chars) {
+ functions->ReleaseStringUTFChars(this,str,chars);
+ }
+
+ jsize GetArrayLength(jarray array) {
+ return functions->GetArrayLength(this,array);
+ }
+
+ jobjectArray NewObjectArray(jsize len, jclass clazz,
+ jobject init) {
+ return functions->NewObjectArray(this,len,clazz,init);
+ }
+ jobject GetObjectArrayElement(jobjectArray array, jsize index) {
+ return functions->GetObjectArrayElement(this,array,index);
+ }
+ void SetObjectArrayElement(jobjectArray array, jsize index,
+ jobject val) {
+ functions->SetObjectArrayElement(this,array,index,val);
+ }
+
+ jbooleanArray NewBooleanArray(jsize len) {
+ return functions->NewBooleanArray(this,len);
+ }
+ jbyteArray NewByteArray(jsize len) {
+ return functions->NewByteArray(this,len);
+ }
+ jcharArray NewCharArray(jsize len) {
+ return functions->NewCharArray(this,len);
+ }
+ jshortArray NewShortArray(jsize len) {
+ return functions->NewShortArray(this,len);
+ }
+ jintArray NewIntArray(jsize len) {
+ return functions->NewIntArray(this,len);
+ }
+ jlongArray NewLongArray(jsize len) {
+ return functions->NewLongArray(this,len);
+ }
+ jfloatArray NewFloatArray(jsize len) {
+ return functions->NewFloatArray(this,len);
+ }
+ jdoubleArray NewDoubleArray(jsize len) {
+ return functions->NewDoubleArray(this,len);
+ }
+
+ jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
+ return functions->GetBooleanArrayElements(this,array,isCopy);
+ }
+ jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
+ return functions->GetByteArrayElements(this,array,isCopy);
+ }
+ jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
+ return functions->GetCharArrayElements(this,array,isCopy);
+ }
+ jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
+ return functions->GetShortArrayElements(this,array,isCopy);
+ }
+ jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
+ return functions->GetIntArrayElements(this,array,isCopy);
+ }
+ jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
+ return functions->GetLongArrayElements(this,array,isCopy);
+ }
+ jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
+ return functions->GetFloatArrayElements(this,array,isCopy);
+ }
+ jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
+ return functions->GetDoubleArrayElements(this,array,isCopy);
+ }
+
+ void ReleaseBooleanArrayElements(jbooleanArray array,
+ jboolean *elems,
+ jint mode) {
+ functions->ReleaseBooleanArrayElements(this,array,elems,mode);
+ }
+ void ReleaseByteArrayElements(jbyteArray array,
+ jbyte *elems,
+ jint mode) {
+ functions->ReleaseByteArrayElements(this,array,elems,mode);
+ }
+ void ReleaseCharArrayElements(jcharArray array,
+ jchar *elems,
+ jint mode) {
+ functions->ReleaseCharArrayElements(this,array,elems,mode);
+ }
+ void ReleaseShortArrayElements(jshortArray array,
+ jshort *elems,
+ jint mode) {
+ functions->ReleaseShortArrayElements(this,array,elems,mode);
+ }
+ void ReleaseIntArrayElements(jintArray array,
+ jint *elems,
+ jint mode) {
+ functions->ReleaseIntArrayElements(this,array,elems,mode);
+ }
+ void ReleaseLongArrayElements(jlongArray array,
+ jlong *elems,
+ jint mode) {
+ functions->ReleaseLongArrayElements(this,array,elems,mode);
+ }
+ void ReleaseFloatArrayElements(jfloatArray array,
+ jfloat *elems,
+ jint mode) {
+ functions->ReleaseFloatArrayElements(this,array,elems,mode);
+ }
+ void ReleaseDoubleArrayElements(jdoubleArray array,
+ jdouble *elems,
+ jint mode) {
+ functions->ReleaseDoubleArrayElements(this,array,elems,mode);
+ }
+
+ void GetBooleanArrayRegion(jbooleanArray array,
+ jsize start, jsize len, jboolean *buf) {
+ functions->GetBooleanArrayRegion(this,array,start,len,buf);
+ }
+ void GetByteArrayRegion(jbyteArray array,
+ jsize start, jsize len, jbyte *buf) {
+ functions->GetByteArrayRegion(this,array,start,len,buf);
+ }
+ void GetCharArrayRegion(jcharArray array,
+ jsize start, jsize len, jchar *buf) {
+ functions->GetCharArrayRegion(this,array,start,len,buf);
+ }
+ void GetShortArrayRegion(jshortArray array,
+ jsize start, jsize len, jshort *buf) {
+ functions->GetShortArrayRegion(this,array,start,len,buf);
+ }
+ void GetIntArrayRegion(jintArray array,
+ jsize start, jsize len, jint *buf) {
+ functions->GetIntArrayRegion(this,array,start,len,buf);
+ }
+ void GetLongArrayRegion(jlongArray array,
+ jsize start, jsize len, jlong *buf) {
+ functions->GetLongArrayRegion(this,array,start,len,buf);
+ }
+ void GetFloatArrayRegion(jfloatArray array,
+ jsize start, jsize len, jfloat *buf) {
+ functions->GetFloatArrayRegion(this,array,start,len,buf);
+ }
+ void GetDoubleArrayRegion(jdoubleArray array,
+ jsize start, jsize len, jdouble *buf) {
+ functions->GetDoubleArrayRegion(this,array,start,len,buf);
+ }
+
+ void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
+ const jboolean *buf) {
+ functions->SetBooleanArrayRegion(this,array,start,len,buf);
+ }
+ void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
+ const jbyte *buf) {
+ functions->SetByteArrayRegion(this,array,start,len,buf);
+ }
+ void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
+ const jchar *buf) {
+ functions->SetCharArrayRegion(this,array,start,len,buf);
+ }
+ void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
+ const jshort *buf) {
+ functions->SetShortArrayRegion(this,array,start,len,buf);
+ }
+ void SetIntArrayRegion(jintArray array, jsize start, jsize len,
+ const jint *buf) {
+ functions->SetIntArrayRegion(this,array,start,len,buf);
+ }
+ void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
+ const jlong *buf) {
+ functions->SetLongArrayRegion(this,array,start,len,buf);
+ }
+ void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
+ const jfloat *buf) {
+ functions->SetFloatArrayRegion(this,array,start,len,buf);
+ }
+ void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
+ const jdouble *buf) {
+ functions->SetDoubleArrayRegion(this,array,start,len,buf);
+ }
+
+ jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
+ jint nMethods) {
+ return functions->RegisterNatives(this,clazz,methods,nMethods);
+ }
+ jint UnregisterNatives(jclass clazz) {
+ return functions->UnregisterNatives(this,clazz);
+ }
+
+ jint MonitorEnter(jobject obj) {
+ return functions->MonitorEnter(this,obj);
+ }
+ jint MonitorExit(jobject obj) {
+ return functions->MonitorExit(this,obj);
+ }
+
+ jint GetJavaVM(JavaVM **vm) {
+ return functions->GetJavaVM(this,vm);
+ }
+
+ void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
+ functions->GetStringRegion(this,str,start,len,buf);
+ }
+ void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
+ functions->GetStringUTFRegion(this,str,start,len,buf);
+ }
+
+ void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
+ return functions->GetPrimitiveArrayCritical(this,array,isCopy);
+ }
+ void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
+ functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);
+ }
+
+ const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
+ return functions->GetStringCritical(this,string,isCopy);
+ }
+ void ReleaseStringCritical(jstring string, const jchar *cstring) {
+ functions->ReleaseStringCritical(this,string,cstring);
+ }
+
+ jweak NewWeakGlobalRef(jobject obj) {
+ return functions->NewWeakGlobalRef(this,obj);
+ }
+ void DeleteWeakGlobalRef(jweak ref) {
+ functions->DeleteWeakGlobalRef(this,ref);
+ }
+
+ jboolean ExceptionCheck() {
+ return functions->ExceptionCheck(this);
+ }
+
+ jobject NewDirectByteBuffer(void* address, jlong capacity) {
+ return functions->NewDirectByteBuffer(this, address, capacity);
+ }
+ void* GetDirectBufferAddress(jobject buf) {
+ return functions->GetDirectBufferAddress(this, buf);
+ }
+ jlong GetDirectBufferCapacity(jobject buf) {
+ return functions->GetDirectBufferCapacity(this, buf);
+ }
+ jobjectRefType GetObjectRefType(jobject obj) {
+ return functions->GetObjectRefType(this, obj);
+ }
+
+#endif /* __cplusplus */
+};
+
+typedef struct JavaVMOption {
+ char *optionString;
+ void *extraInfo;
+} JavaVMOption;
+
+typedef struct JavaVMInitArgs {
+ jint version;
+
+ jint nOptions;
+ JavaVMOption *options;
+ jboolean ignoreUnrecognized;
+} JavaVMInitArgs;
+
+typedef struct JavaVMAttachArgs {
+ jint version;
+
+ char *name;
+ jobject group;
+} JavaVMAttachArgs;
+
+/* These will be VM-specific. */
+
+#define JDK1_2
+#define JDK1_4
+
+/* End VM-specific. */
+
+struct JNIInvokeInterface_ {
+ void *reserved0;
+ void *reserved1;
+ void *reserved2;
+
+ jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
+
+ jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
+
+ jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
+
+ jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
+
+ jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
+};
+
+struct JavaVM_ {
+ const struct JNIInvokeInterface_ *functions;
+#ifdef __cplusplus
+
+ jint DestroyJavaVM() {
+ return functions->DestroyJavaVM(this);
+ }
+ jint AttachCurrentThread(void **penv, void *args) {
+ return functions->AttachCurrentThread(this, penv, args);
+ }
+ jint DetachCurrentThread() {
+ return functions->DetachCurrentThread(this);
+ }
+
+ jint GetEnv(void **penv, jint version) {
+ return functions->GetEnv(this, penv, version);
+ }
+ jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
+ return functions->AttachCurrentThreadAsDaemon(this, penv, args);
+ }
+#endif
+};
+
+#ifdef _JNI_IMPLEMENTATION_
+#define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
+#else
+#define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
+#endif
+_JNI_IMPORT_OR_EXPORT_ jint JNICALL
+JNI_GetDefaultJavaVMInitArgs(void *args);
+
+_JNI_IMPORT_OR_EXPORT_ jint JNICALL
+JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
+
+_JNI_IMPORT_OR_EXPORT_ jint JNICALL
+JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
+
+/* Defined by native libraries. */
+JNIEXPORT jint JNICALL
+JNI_OnLoad(JavaVM *vm, void *reserved);
+
+JNIEXPORT void JNICALL
+JNI_OnUnload(JavaVM *vm, void *reserved);
+
+#define JNI_VERSION_1_1 0x00010001
+#define JNI_VERSION_1_2 0x00010002
+#define JNI_VERSION_1_4 0x00010004
+#define JNI_VERSION_1_6 0x00010006
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* !_JAVASOFT_JNI_H_ */
+
+
+
--- /dev/null
+/*
+ * %W% %E%
+ *
+ * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+
+#ifndef _JAVASOFT_JNI_MD_H_
+#define _JAVASOFT_JNI_MD_H_
+
+#define JNIEXPORT __declspec(dllexport)
+#define JNIIMPORT __declspec(dllimport)
+#define JNICALL __stdcall
+
+typedef long jint;
+typedef __int64 jlong;
+typedef signed char jbyte;
+
+#endif /* !_JAVASOFT_JNI_MD_H_ */
--- /dev/null
+/* DO NOT EDIT THIS FILE - it is machine generated */\r
+#include <jni.h>\r
+/* Header for class org_simantics_fmu_FMUControlJNI */\r
+\r
+#ifndef _Included_org_simantics_fmu_FMUControlJNI\r
+#define _Included_org_simantics_fmu_FMUControlJNI\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_loadFMUFile_1\r
+ (JNIEnv *, jobject, jstring, jstring);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: setStepLength_\r
+ * Signature: (Ljava/lang/String;D)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setStepLength_1\r
+ (JNIEnv *, jobject, jint, jdouble);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: instantiateSimulation_\r
+ * Signature: (Ljava/lang/String;)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_instantiateSimulation_1\r
+ (JNIEnv *, jobject, jint);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: initializeSimulation_\r
+ * Signature: (Ljava/lang/String;)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_initializeSimulation_1\r
+ (JNIEnv *, jobject, jint);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: subscribe_\r
+ * Signature: (Ljava/lang/String;[Ljava/lang/String;I)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_subscribe_1\r
+ (JNIEnv *, jobject, jint, jintArray);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: setRealValue_\r
+ * Signature: (Ljava/lang/String;Ljava/lang/String;D)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setRealValue_1\r
+ (JNIEnv *, jobject, jint, jint, jdouble);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: setIntegerValue_\r
+ * Signature: (Ljava/lang/String;Ljava/lang/String;I)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setIntegerValue_1\r
+ (JNIEnv *, jobject, jstring, jstring, jint);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: setBooleanValue_\r
+ * Signature: (Ljava/lang/String;Ljava/lang/String;Z)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setBooleanValue_1\r
+ (JNIEnv *, jobject, jstring, jstring, jboolean);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: setTime_\r
+ * Signature: (Ljava/lang/String;D)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setTime_1\r
+ (JNIEnv *, jobject, jstring, jdouble);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: simulateStep_\r
+ * Signature: (Ljava/lang/String;)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_simulateStep_1\r
+ (JNIEnv *, jobject, jint);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: getSubscribedResults_\r
+ * Signature: (Ljava/lang/String;[D)[D\r
+ */\r
+JNIEXPORT jdoubleArray JNICALL Java_org_simantics_fmil_FMIL_getSubscribedResults_1\r
+ (JNIEnv *, jobject, jint, jdoubleArray);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: unloadFMU_\r
+ * Signature: (Ljava/lang/String;)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_unloadFMU_1\r
+ (JNIEnv *, jobject, jint);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: isInitialized_\r
+ * Signature: (Ljava/lang/String;)Z\r
+ */\r
+JNIEXPORT jboolean JNICALL Java_org_simantics_fmil_FMIL_isInitialized_1\r
+ (JNIEnv *, jobject, jstring);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: getTime_\r
+ * Signature: (Ljava/lang/String;)D\r
+ */\r
+JNIEXPORT jdouble JNICALL Java_org_simantics_fmil_FMIL_getTime_1\r
+ (JNIEnv *, jobject, jint);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: getAllVariables_\r
+ * Signature: (Ljava/lang/String;)[Ljava/lang/String;\r
+ */\r
+JNIEXPORT jobjectArray JNICALL Java_org_simantics_fmil_FMIL_getAllVariables_1\r
+ (JNIEnv *, jobject, jint);\r
+\r
+JNIEXPORT jintArray JNICALL Java_org_simantics_fmil_FMIL_getAllVariableReferences_1\r
+ (JNIEnv *, jobject, jint, jintArray);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: filterVariables_\r
+ * Signature: (Ljava/lang/String;Ljava/lang/String;)[Ljava/lang/String;\r
+ */\r
+JNIEXPORT jobjectArray JNICALL Java_org_simantics_fmil_FMIL_filterVariables_1\r
+ (JNIEnv *, jobject, jstring, jstring);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: getLastErrorMessage_\r
+ * Signature: (Ljava/lang/String;)Ljava/lang/String;\r
+ */\r
+JNIEXPORT jstring JNICALL Java_org_simantics_fmil_FMIL_getLastErrorMessage_1\r
+ (JNIEnv *, jobject, jstring);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: getRealValue_\r
+ * Signature: (Ljava/lang/String;Ljava/lang/String;)D\r
+ */\r
+JNIEXPORT jdouble JNICALL Java_org_simantics_fmil_FMIL_getRealValue_1\r
+ (JNIEnv *, jobject, jint, jint);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: getStringValue_\r
+ * Signature: (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;\r
+ */\r
+JNIEXPORT jstring JNICALL Java_org_simantics_fmil_FMIL_getStringValue_1\r
+ (JNIEnv *, jobject, jstring, jstring);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: getIntegerValue_\r
+ * Signature: (Ljava/lang/String;Ljava/lang/String;)I\r
+ */\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_getIntegerValue_1\r
+ (JNIEnv *, jobject, jstring, jstring);\r
+\r
+/*\r
+ * Class: org_simantics_fmu_FMUControlJNI\r
+ * Method: getBooleanValue_\r
+ * Signature: (Ljava/lang/String;Ljava/lang/String;)Z\r
+ */\r
+JNIEXPORT jboolean JNICALL Java_org_simantics_fmil_FMIL_getBooleanValue_1\r
+ (JNIEnv *, jobject, jstring, jstring);\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+#endif\r
--- /dev/null
+/* ------------------------------------------------------------------------- \r
+ * sim_support.h\r
+ * Functions used by the FMU simulatios fmusim_me and fmusim_cs.\r
+ * Copyright 2011 QTronic GmbH. All rights reserved. \r
+ * -------------------------------------------------------------------------*/ \r
+\r
+// Used 7z options, version 4.57:\r
+// -x Extracts files from an archive with their full paths in the current dir, or in an output dir if specified\r
+// -aoa Overwrite All existing files without prompt\r
+// -o Specifies a destination directory where files are to be extracted\r
+#define UNZIP_CMD "7z x -aoa -o"\r
+#define XML_FILE "modelDescription.xml"\r
+#define DLL_DIR "binaries\\win32\\"\r
+#define RESULT_FILE "result.csv"\r
+#define BUFSIZE 4096\r
+\r
+// return codes of the 7z command line tool\r
+#define SEVEN_ZIP_NO_ERROR 0 // success\r
+#define SEVEN_ZIP_WARNING 1 // e.g., one or more files were locked during zip\r
+#define SEVEN_ZIP_ERROR 2\r
+#define SEVEN_ZIP_COMMAND_LINE_ERROR 7\r
+#define SEVEN_ZIP_OUT_OF_MEMORY 8\r
+#define SEVEN_ZIP_STOPPED_BY_USER 255\r
+\r
+void fmuLogger(fmiComponent c, fmiString instanceName, fmiStatus status, fmiString category, fmiString message, ...);\r
+int unzip(const char *zipPath, const char *outPath);\r
+void parseArguments(int argc, char *argv[], char** fmuFileName, double* tEnd, double* h, int* loggingOn, char* csv_separator);\r
+int loadFMU(FMU *fmu, const char* fmuFileName, const char* tmpPath);\r
+void outputRow(FMU *fmu, fmiComponent c, double time, FILE* file, char separator, boolean header);\r
+int error(const char* message);\r
+void printHelp(const char* fmusim);\r
--- /dev/null
+/* ------------------------------------------------------------------------- \r
+ * stack.c\r
+ * A stack of pointers. \r
+ * Copyright 2010 QTronic GmbH. All rights reserved. \r
+ * -------------------------------------------------------------------------*/ \r
+\r
+#ifndef STACK_H\r
+#define STACK_H\r
+\r
+typedef struct {\r
+ void** stack;\r
+ int stackSize; // allocated size of stack\r
+ int stackPos; // array index of top element, -1 if stack is empty.\r
+ int initialSize; // how many element to allocate initially\r
+ int inc; // how many elements to allocate when stack gets full\r
+} Stack;\r
+\r
+Stack* stackNew(int initialSize, int inc);\r
+int stackIsEmpty(Stack* s);\r
+int stackPush(Stack* s, void* e);\r
+void* stackPeek(Stack* s);\r
+void* stackPop(Stack* s);\r
+void** stackPopAllAsArray(Stack* s, int *size);\r
+void** stackLastPopedAsArray0(Stack* s, int n);\r
+void stackFree(Stack* s);\r
+\r
+#endif // STACK_H\r
+\r
--- /dev/null
+/* header created automatically with -DGEN_TREES_H */
+
+local const ct_data static_ltree[L_CODES+2] = {
+{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}},
+{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}},
+{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}},
+{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}},
+{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}},
+{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}},
+{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}},
+{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}},
+{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}},
+{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}},
+{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}},
+{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}},
+{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}},
+{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}},
+{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}},
+{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}},
+{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}},
+{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}},
+{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}},
+{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}},
+{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}},
+{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}},
+{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}},
+{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}},
+{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}},
+{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}},
+{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}},
+{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}},
+{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}},
+{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}},
+{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}},
+{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}},
+{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}},
+{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}},
+{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}},
+{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}},
+{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}},
+{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}},
+{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}},
+{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}},
+{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}},
+{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}},
+{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}},
+{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}},
+{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}},
+{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}},
+{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}},
+{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}},
+{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}},
+{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}},
+{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}},
+{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}},
+{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}},
+{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}},
+{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}},
+{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}},
+{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}},
+{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}}
+};
+
+local const ct_data static_dtree[D_CODES] = {
+{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
+{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
+{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
+{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
+{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
+{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
+};
+
+const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {
+ 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8,
+ 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10,
+10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17,
+18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+};
+
+const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12,
+13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+};
+
+local const int base_length[LENGTH_CODES] = {
+0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+64, 80, 96, 112, 128, 160, 192, 224, 0
+};
+
+local const int base_dist[D_CODES] = {
+ 0, 1, 2, 3, 4, 6, 8, 12, 16, 24,
+ 32, 48, 64, 96, 128, 192, 256, 384, 512, 768,
+ 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576
+};
+
--- /dev/null
+/* ------------------------------------------------------------------------- \r
+ * xml_parser.h\r
+ * A parser for file modelVariables.xml of an FMU.\r
+ * Supports "FMI for Model Exchange 1.0" and "FMI for Co-Simulation 1.0".\r
+ * Copyright 2011 QTronic GmbH. All rights reserved. \r
+ * -------------------------------------------------------------------------*/\r
+\r
+#ifndef xml_parser_h\r
+#define xml_parser_h\r
+\r
+// define XML_STATIC before including expat.h\r
+// to prevent error when linking with libexpatMT.lib\r
+#define XML_STATIC \r
+#include "expat.h"\r
+#include "stack.h"\r
+\r
+typedef unsigned int fmiValueReference;\r
+#define fmiUndefinedValueReference (fmiValueReference)(-1)\r
+\r
+#define SIZEOF_ELM 31\r
+extern const char *elmNames[SIZEOF_ELM];\r
+\r
+#define SIZEOF_ATT 47\r
+extern const char *attNames[SIZEOF_ATT];\r
+\r
+#define SIZEOF_ENU 13\r
+extern const char *enuNames[SIZEOF_ENU];\r
+\r
+// Elements\r
+typedef enum {\r
+ elm_fmiModelDescription,elm_UnitDefinitions,elm_BaseUnit,elm_DisplayUnitDefinition,elm_TypeDefinitions,\r
+ elm_Type,elm_RealType,elm_IntegerType,elm_BooleanType,elm_StringType,elm_EnumerationType,elm_Item,\r
+ elm_DefaultExperiment,elm_VendorAnnotations,elm_Tool,elm_Annotation,elm_ModelVariables,elm_ScalarVariable,\r
+ elm_DirectDependency,elm_Name,elm_Real,elm_Integer,elm_Boolean,elm_String,elm_Enumeration,\r
+ elm_Implementation,elm_CoSimulation_StandAlone,elm_CoSimulation_Tool,elm_Model,elm_File,elm_Capabilities\r
+} Elm;\r
+\r
+// Attributes\r
+typedef enum { \r
+ att_fmiVersion,att_displayUnit,att_gain,att_offset,att_unit,att_name,att_description,att_quantity,att_relativeQuantity,\r
+ att_min,att_max,att_nominal,att_declaredType,att_start,att_fixed,att_startTime,att_stopTime,att_tolerance,att_value,\r
+ att_valueReference,att_variability,att_causality,att_alias,att_modelName,att_modelIdentifier,att_guid,att_author,\r
+ att_version,att_generationTool,att_generationDateAndTime,att_variableNamingConvention,att_numberOfContinuousStates,\r
+ att_numberOfEventIndicators,att_input,\r
+ att_canHandleVariableCommunicationStepSize,att_canHandleEvents,att_canRejectSteps,att_canInterpolateInputs,\r
+ att_maxOutputDerivativeOrder,att_canRunAsynchronuously,att_canSignalEvents,att_canBeInstantiatedOnlyOncePerProcess,\r
+ att_canNotUseMemoryManagementFunctions,att_entryPoint,att_manualStart,att_type\r
+} Att;\r
+\r
+// Enumeration values\r
+typedef enum {\r
+ enu_flat,enu_structured,enu_constant,enu_parameter,enu_discrete,enu_continuous,\r
+ enu_input,enu_output,enu_internal,enu_none,enu_noAlias,enu_alias,enu_negatedAlias \r
+} Enu;\r
+\r
+// AST node for element \r
+// DisplayUnitDefinition, RealType, IntegerType, BooleanType, StringType, DefaultExperiment, \r
+// Item, Annotation, Name, Real, Integer, Boolean, String, Enumeration, Capabilities, File\r
+typedef struct {\r
+ Elm type; // element type \r
+ const char** attributes; // null or n attribute value strings\r
+ int n; // size of attributes, even number\r
+} Element;\r
+\r
+// AST node for element that has a list of elements \r
+// BaseUnit, EnumerationType, Tool, DirectDependency, Model\r
+typedef struct {\r
+ Elm type; // element type \r
+ const char** attributes; // null or n attribute value strings\r
+ int n; // size of attributes, even number\r
+ Element** list; // null-terminated array of pointers to elements, not null\r
+} ListElement;\r
+\r
+// AST node for element Type\r
+typedef struct {\r
+ Elm type; // element type \r
+ const char** attributes; // null or n attribute value strings\r
+ int n; // size of attributes, an even number\r
+ Element* typeSpec; // one of RealType, IntegerType etc. \r
+} Type;\r
+\r
+// AST node for element ScalarVariable\r
+typedef struct {\r
+ Elm type; // element type \r
+ const char** attributes; // null or n attribute value strings\r
+ int n; // size of attributes, even number\r
+ Element* typeSpec; // one of Real, Integer, etc\r
+ Element** directDependencies; // null or null-terminated list of Name\r
+} ScalarVariable;\r
+\r
+// AST node for element CoSimulation_StandAlone and CoSimulation_Tool\r
+typedef struct {\r
+ Elm type; // one of elm_CoSimulation_StandAlone and elm_CoSimulation_Tool\r
+ const char** attributes; // null or n attribute value strings\r
+ int n; // size of attributes, even number\r
+ Element* capabilities; // a set of capability attributes\r
+ ListElement* model; // non-NULL to support tool coupling, NULL for standalone \r
+} CoSimulation;\r
+\r
+// AST node for element ModelDescription\r
+typedef struct {\r
+ Elm type; // element type\r
+ const char** attributes; // null or n attribute value strings\r
+ int n; // size of attributes, even number\r
+ ListElement** unitDefinitions; // NULL or null-terminated list of BaseUnits\r
+ Type** typeDefinitions; // NULL or null-terminated list of Types \r
+ Element* defaultExperiment; // NULL or DefaultExperiment\r
+ ListElement** vendorAnnotations; // NULL or null-terminated list of Tools\r
+ ScalarVariable** modelVariables; // NULL or null-terminated list of ScalarVariable\r
+ CoSimulation* cosimulation; // NULL if this ModelDescription is for model exchange only\r
+} ModelDescription;\r
+\r
+// types of AST nodes used to represent an element\r
+typedef enum { \r
+ astElement, \r
+ astListElement,\r
+ astType,\r
+ astScalarVariable,\r
+ astCoSimulation,\r
+ astModelDescription\r
+} AstNodeType;\r
+\r
+// Possible results when retrieving an attribute value from an element\r
+typedef enum { \r
+ valueMissing,\r
+ valueDefined,\r
+ valueIllegal\r
+} ValueStatus;\r
+\r
+// Public methods: Parsing and low-level AST access\r
+ModelDescription* parse(const char* xmlPath);\r
+const char* getString(void* element, Att a);\r
+double getDouble (void* element, Att a, ValueStatus* vs);\r
+int getInt (void* element, Att a, ValueStatus* vs);\r
+unsigned int getUInt (void* element, Att a, ValueStatus* vs);\r
+char getBoolean (void* element, Att a, ValueStatus* vs);\r
+Enu getEnumValue (void* element, Att a, ValueStatus* vs);\r
+void freeElement (void* element);\r
+\r
+// Convenience methods for AST access. To be used afer successful validation only.\r
+const char* getModelIdentifier(ModelDescription* md);\r
+int getNumberOfStates(ModelDescription* md);\r
+int getNumberOfEventIndicators(ModelDescription* md);\r
+const char* getName(void* element);\r
+Enu getCausality(void* scalarVariable);\r
+Enu getVariability(void* scalarVariable);\r
+Enu getAlias(void* scalarVariable);\r
+fmiValueReference getValueReference(void* scalarVariable);\r
+ScalarVariable* getVariableByName(ModelDescription* md, const char* name);\r
+ScalarVariable* getVariable(ModelDescription* md, fmiValueReference vr, Elm type);\r
+Type* getDeclaredType(ModelDescription* md, const char* declaredType);\r
+const char* getString2(ModelDescription* md, void* sv, Att a);\r
+const char * getDescription(ModelDescription* md, ScalarVariable* sv);\r
+const char * getVariableAttributeString(ModelDescription* md, fmiValueReference vr, Elm type, Att a);\r
+double getVariableAttributeDouble(ModelDescription* md, fmiValueReference vr, Elm type, Att a, ValueStatus* vs);\r
+double getNominal(ModelDescription* md, fmiValueReference vr);\r
+\r
+#endif // xml_parser_h\r
+\r
--- /dev/null
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2011 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+ part of the implementation of the compression library and is
+ subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZUTIL_H
+#define ZUTIL_H
+
+#if ((__GNUC__-0) * 10 + __GNUC_MINOR__-0 >= 33) && !defined(NO_VIZ)
+# define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
+#else
+# define ZLIB_INTERNAL
+#endif
+
+#include "zlib.h"
+
+#if defined(STDC) && !defined(Z_SOLO)
+# if !(defined(_WIN32_WCE) && defined(_MSC_VER))
+# include <stddef.h>
+# endif
+# include <string.h>
+# include <stdlib.h>
+#endif
+
+#ifdef Z_SOLO
+ typedef long ptrdiff_t; /* guess -- will be caught if guess is wrong */
+#endif
+
+#ifndef local
+# define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+typedef unsigned char uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long ulg;
+
+extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
+
+#define ERR_RETURN(strm,err) \
+ return (strm->msg = (char*)ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+ /* common constants */
+
+#ifndef DEF_WBITS
+# define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+# define DEF_MEM_LEVEL 8
+#else
+# define DEF_MEM_LEVEL MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES 2
+/* The three kinds of block type */
+
+#define MIN_MATCH 3
+#define MAX_MATCH 258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+ /* target dependencies */
+
+#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
+# define OS_CODE 0x00
+# ifndef Z_SOLO
+# if defined(__TURBOC__) || defined(__BORLANDC__)
+# if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+ /* Allow compilation with ANSI keywords only enabled */
+ void _Cdecl farfree( void *block );
+ void *_Cdecl farmalloc( unsigned long nbytes );
+# else
+# include <alloc.h>
+# endif
+# else /* MSC or DJGPP */
+# include <malloc.h>
+# endif
+# endif
+#endif
+
+#ifdef AMIGA
+# define OS_CODE 0x01
+#endif
+
+#if defined(VAXC) || defined(VMS)
+# define OS_CODE 0x02
+# define F_OPEN(name, mode) \
+ fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#if defined(ATARI) || defined(atarist)
+# define OS_CODE 0x05
+#endif
+
+#ifdef OS2
+# define OS_CODE 0x06
+# if defined(M_I86) && !defined(Z_SOLO)
+# include <malloc.h>
+# endif
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+# define OS_CODE 0x07
+# ifndef Z_SOLO
+# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+# include <unix.h> /* for fdopen */
+# else
+# ifndef fdopen
+# define fdopen(fd,mode) NULL /* No fdopen() */
+# endif
+# endif
+# endif
+#endif
+
+#ifdef TOPS20
+# define OS_CODE 0x0a
+#endif
+
+#ifdef WIN32
+# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */
+# define OS_CODE 0x0b
+# endif
+#endif
+
+#ifdef __50SERIES /* Prime/PRIMOS */
+# define OS_CODE 0x0f
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+# define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
+# if defined(_WIN32_WCE)
+# define fdopen(fd,mode) NULL /* No fdopen() */
+# ifndef _PTRDIFF_T_DEFINED
+ typedef int ptrdiff_t;
+# define _PTRDIFF_T_DEFINED
+# endif
+# else
+# define fdopen(fd,type) _fdopen(fd,type)
+# endif
+#endif
+
+#if defined(__BORLANDC__) && !defined(MSDOS)
+ #pragma warn -8004
+ #pragma warn -8008
+ #pragma warn -8066
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_WIN32) && (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
+ ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+ ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+#endif
+
+ /* common defaults */
+
+#ifndef OS_CODE
+# define OS_CODE 0x03 /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+# define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+ /* functions */
+
+#if defined(pyr) || defined(Z_SOLO)
+# define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+ * You may have to use the same strategy for Borland C (untested).
+ * The __SC__ check is for Symantec.
+ */
+# define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+# define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+# ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+# define zmemcpy _fmemcpy
+# define zmemcmp _fmemcmp
+# define zmemzero(dest, len) _fmemset(dest, 0, len)
+# else
+# define zmemcpy memcpy
+# define zmemcmp memcmp
+# define zmemzero(dest, len) memset(dest, 0, len)
+# endif
+#else
+ void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
+ int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
+ void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef DEBUG
+# include <stdio.h>
+ extern int ZLIB_INTERNAL z_verbose;
+ extern void ZLIB_INTERNAL z_error OF((char *m));
+# define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+# define Trace(x) {if (z_verbose>=0) fprintf x ;}
+# define Tracev(x) {if (z_verbose>0) fprintf x ;}
+# define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+# define Assert(cond,msg)
+# define Trace(x)
+# define Tracev(x)
+# define Tracevv(x)
+# define Tracec(c,x)
+# define Tracecv(c,x)
+#endif
+
+#ifndef Z_SOLO
+ voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
+ unsigned size));
+ void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr));
+#endif
+
+#define ZALLOC(strm, items, size) \
+ (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+#endif /* ZUTIL_H */
--- /dev/null
+/* ------------------------------------------------------------------------- \r
+ * fmu_control.c\r
+ * Simulation controls for fmus\r
+ *\r
+ * Free libraries and tools used to implement this simulator:\r
+ * - header files from the FMU specification\r
+ * - eXpat 2.0.1 XML parser, see http://expat.sourceforge.net\r
+ * - 7z.exe 4.57 zip and unzip tool, see http://www.7-zip.org <---------- Replace with zlib\r
+ * Author: Teemu Lempinen\r
+ * Copyright 2012 Semantum Oy\r
+ * -------------------------------------------------------------------------\r
+ */\r
+\r
+#include <stdlib.h>\r
+#include <stdio.h>\r
+#include <string.h>\r
+#include <map>\r
+#include <string>\r
+#include <vector>\r
+#include <iostream>\r
+#include <regex>\r
+\r
+#include <org_simantics_fmil_FMILJNI.h>\r
+\r
+extern "C" {\r
+ #include "fmi_me.h"\r
+ #include "sim_support.h"\r
+}\r
+\r
+#include "fmi1_cs.h"\r
+\r
+#define PRINT(fmt,args) { FILE *fp = fopen("R:\\Simantics\\Sysdyn\\log.txt", "ab"); fprintf(fp, fmt, args); fclose(fp); }\r
+\r
+#include <direct.h>\r
+#define GetCurrentDir _getcwd\r
+\r
+using namespace std;\r
+\r
+struct FMI1 {\r
+\r
+ void *fmu;\r
+ vector<string> variables; // all variables in an initialized model\r
+ vector<int> valueReferences; // all value references\r
+ vector<int> subscription; // subscribed value references\r
+ double currentTime;\r
+ double timeStep;\r
+\r
+};\r
+\r
+struct FMUControlStruct {\r
+ double step; // simulation step length\r
+ fmiReal currentTime; // current simulation time\r
+\r
+ fmiComponent c; // instance of the fmu \r
+ ScalarVariable** vars; // model variables\r
+\r
+ fmiEventInfo eventInfo; // updated by calls to initialize and eventUpdate\r
+ const char* guid; // global unique id of the fmu\r
+ fmiCallbackFunctions callbacks; // called by the model during simulation\r
+ fmiStatus fmiFlag; // return code of the fmu functions\r
+\r
+ map<string,int> indexes; // indexes for variable names in vars-table\r
+ map<string,int>::iterator it;\r
+\r
+ int nx; // number of state variables\r
+ double *x; // continuous states\r
+ double *xdot; // the crresponding derivatives in same order\r
+ int nz; // number of state event indicators\r
+ double *z; // state event indicators\r
+ double *prez; // previous values of state event indicators\r
+ \r
+ bool initialized; // has the fmu been initialized\r
+\r
+ vector<fmiValueReference> subscription; // result subscriptions\r
+ vector<string> allVariables; // all variables in an initialized model\r
+ vector<fmiValueReference> fmiValueReferences; // all value references\r
+\r
+ string lastErrorMessage;\r
+\r
+ FMU fmu;\r
+};\r
+\r
+vector<FMI1> fmus;\r
+\r
+//map<string,FMUControlStruct> fmus; // indexes for variable names in vars-table\r
+\r
+int throwException(JNIEnv *env, string message) {\r
+ jclass newExcCls;\r
+ newExcCls = env->FindClass("java/lang/Exception");\r
+ if (newExcCls == NULL) {\r
+ /* Unable to find the exception class, give up. */\r
+ return 0;\r
+ }\r
+ env->ThrowNew(newExcCls, message.c_str());\r
+ return 0;\r
+}\r
+\r
+/*\r
+bool exists(string id) {\r
+ map<string,FMUControlStruct>::iterator it = fmus.find(id);\r
+ if(it != fmus.end()) {\r
+ return true;\r
+ } else {\r
+ return false;\r
+ }\r
+}\r
+*/\r
+\r
+\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_loadFMUFile_1 \r
+ (JNIEnv *env, jobject obj, jstring path, jstring tempDir) {\r
+\r
+ HMODULE module = NULL;\r
+ FMI1 fmi1;\r
+ FMIL_Variable *vars;\r
+ int variableCount = 0;\r
+\r
+ const char *fmuPath = env->GetStringUTFChars(path, 0);\r
+ const char *fmuTempDir = env->GetStringUTFChars(tempDir, 0);\r
+\r
+ fmi1.currentTime = 0;\r
+ fmi1.timeStep = 0.1;\r
+ fmi1.fmu = FMI1_CS_LOAD(fmuPath, fmuTempDir);\r
+ if(!fmi1.fmu)\r
+ return throwException(env, "No FMU loaded");\r
+\r
+ vars = FMI1_CS_GET_VARIABLES(fmi1.fmu, &variableCount);\r
+ for(int i=0;i<variableCount;i++) {\r
+ fmi1.variables.push_back(string(vars[i].name));\r
+ fmi1.valueReferences.push_back(vars[i].vr);\r
+ }\r
+\r
+ fmus.push_back(fmi1);\r
+\r
+ env->ReleaseStringUTFChars(path, fmuPath);\r
+ env->ReleaseStringUTFChars(tempDir, fmuTempDir);\r
+\r
+ return fmus.size() - 1;\r
+\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setStepLength_1 \r
+ (JNIEnv *env, jobject obj, jint id, jdouble stepLength) {\r
+ fmus[id].timeStep = stepLength;\r
+ return 1;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_subscribe_1\r
+ (JNIEnv *env, jobject obj, jint id, jintArray vrs) {\r
+\r
+ jboolean isCopy;\r
+ jint* elements = env -> GetIntArrayElements(vrs, &isCopy);\r
+ jsize n = env -> GetArrayLength(vrs);\r
+\r
+ int i;\r
+ for (i = 0; i < n; i++) {\r
+ fmus[id].subscription.push_back(elements[i]);\r
+ } \r
+ \r
+ if (isCopy == JNI_TRUE) {\r
+ env -> ReleaseIntArrayElements(vrs, elements, 0);\r
+ }\r
+\r
+ return 1;\r
+\r
+}\r
+\r
+bool referenceExists(FMUControlStruct fmuStruct, string variable) {\r
+ map<string,int>::iterator it = fmuStruct.indexes.find(variable);\r
+ if(it != fmuStruct.indexes.end()) {\r
+ return true;\r
+ } else {\r
+ return false;\r
+ }\r
+}\r
+\r
+// Remember to check if reference exists\r
+fmiValueReference getReference(FMUControlStruct fmuStruct, string variable) {\r
+ return fmuStruct.fmiValueReferences[fmuStruct.indexes[variable]];\r
+}\r
+\r
+// Get string representation of a scalar variable type\r
+string getTypeString(ScalarVariable* sv) {\r
+ switch (sv->typeSpec->type){\r
+ case elm_Integer:\r
+ return "Integer";\r
+ case elm_Enumeration:\r
+ return "Enumeration";\r
+ case elm_Real:\r
+ return "Real";\r
+ case elm_Boolean:\r
+ return "Boolean";\r
+ default:\r
+ return "No type";\r
+ }\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setRealValue_1\r
+ (JNIEnv *env, jobject obj, jint id, jint vr, jdouble value) {\r
+\r
+ FMI1_CS_SET_REAL(fmus[id].fmu, vr, value);\r
+ return 1;\r
+\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setIntegerValue_1\r
+ (JNIEnv *env, jobject obj, jstring id, jstring parameter, jint value) {\r
+ /*\r
+ const char *fmuId = env->GetStringUTFChars(id, 0);\r
+ if(exists(fmuId)) {\r
+ FMUControlStruct& fmuStruct = fmus[fmuId];\r
+ const char *name = env->GetStringUTFChars(parameter, 0);\r
+ string nameString = name;\r
+ string modelId = fmuId;\r
+ if(!referenceExists(fmuStruct, name)) {\r
+ string errorMessage = "setIntegerValue: Model (id " + modelId + ") does not contain variable: " + nameString;\r
+ env->ReleaseStringUTFChars(parameter, name);\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return throwException(env, errorMessage);\r
+ } else {\r
+ // Check variable type\r
+ ScalarVariable* sv = fmuStruct.vars[fmuStruct.indexes[name]];\r
+ switch (sv->typeSpec->type){\r
+ case elm_Integer:\r
+ break; // ok\r
+ default: {\r
+ string errorMessage = "setIntegerValue: " + nameString + " is not of type Integer. (type: + " + getTypeString(sv) + ")";\r
+ env->ReleaseStringUTFChars(parameter, name);\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return throwException(env, errorMessage);\r
+ }\r
+ }\r
+\r
+ // Change value\r
+ fmiValueReference vr = getReference(fmuStruct, name);\r
+ const int intValue = (int) value;\r
+ fmuStruct.fmu.setInteger(fmuStruct.c, &vr, 1, &intValue);\r
+ env->ReleaseStringUTFChars(parameter, name);\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return 1;\r
+ }\r
+ } else {\r
+ string message = fmuId;\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return throwException(env, "setIntegerValue: Model id " + message + " not found");\r
+ }\r
+ */\r
+ return 1;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setBooleanValue_1\r
+ (JNIEnv *env, jobject obj, jstring id, jstring parameter, jboolean value) {\r
+ /*\r
+ const char *fmuId = env->GetStringUTFChars(id, 0);\r
+ if(exists(fmuId)) {\r
+ FMUControlStruct& fmuStruct = fmus[fmuId];\r
+ const char *name = env->GetStringUTFChars(parameter, 0);\r
+ string nameString = name;\r
+ string modelId = fmuId;\r
+ if(!referenceExists(fmuStruct, name)) {\r
+ string errorMessage = "setBooleanValue: Model (id " + modelId + ") does not contain variable: " + nameString;\r
+ env->ReleaseStringUTFChars(parameter, name);\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return throwException(env, errorMessage);\r
+ } else {\r
+ // Check variable type\r
+ ScalarVariable* sv = fmuStruct.vars[fmuStruct.indexes[name]];\r
+ switch (sv->typeSpec->type){\r
+ case elm_Boolean:\r
+ break; // ok\r
+ default: {\r
+ string errorMessage = "setBooleanValue: " + nameString + " is not of type Boolean. (type: + " + getTypeString(sv) + ")";\r
+ env->ReleaseStringUTFChars(parameter, name);\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return throwException(env, errorMessage);\r
+ }\r
+ }\r
+\r
+ // Change value\r
+ fmiValueReference vr = getReference(fmuStruct, name);\r
+ fmiBoolean result = 1;\r
+ if(value == 0)\r
+ result = 0;\r
+ fmuStruct.fmu.setBoolean(fmuStruct.c, &vr, 1, &result);\r
+ env->ReleaseStringUTFChars(parameter, name);\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return 1;\r
+ }\r
+ } else {\r
+ string message = fmuId;\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return throwException(env, "setBooleanValue: Model id " + message + " not found");\r
+ }*/\r
+ return 1;\r
+}\r
+\r
+JNIEXPORT jboolean JNICALL Java_org_simantics_fmil_FMIL_isInitialized_1\r
+ (JNIEnv *env, jobject obj, jstring id) {\r
+ /*\r
+ const char *fmuId = env->GetStringUTFChars(id, 0);\r
+ if(exists(fmuId)) {\r
+ FMUControlStruct& fmuStruct = fmus[fmuId];\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return fmuStruct.initialized;\r
+ } else {\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return false;\r
+ }\r
+ */\r
+ return 1;\r
+}\r
+\r
+\r
+JNIEXPORT jdouble JNICALL Java_org_simantics_fmil_FMIL_getTime_1\r
+ (JNIEnv *env, jobject obj, jint id) {\r
+ return fmus[id].currentTime;\r
+}\r
+\r
+double getRealValue(FMUControlStruct fmuStruct, int index) {\r
+ ScalarVariable *sv = fmuStruct.vars[index];\r
+ fmiValueReference vr = fmuStruct.fmiValueReferences[index];\r
+ double real;\r
+ fmiInteger integer;\r
+ fmiBoolean fmibool;\r
+\r
+ switch (sv->typeSpec->type){\r
+ case elm_Real:\r
+ fmuStruct.fmu.getReal(fmuStruct.c, &vr, 1, &real);\r
+ break;\r
+ case elm_Integer:\r
+ case elm_Enumeration:\r
+ fmuStruct.fmu.getInteger(fmuStruct.c, &vr, 1, &integer);\r
+ real = (double)integer;\r
+ break;\r
+ case elm_Boolean:\r
+ fmuStruct.fmu.getBoolean(fmuStruct.c, &vr, 1, &fmibool);\r
+ if(fmibool == fmiTrue)\r
+ real = 1.0;\r
+ else\r
+ real = 0.0;\r
+ break;\r
+ }\r
+ return real;\r
+}\r
+\r
+JNIEXPORT jdoubleArray JNICALL Java_org_simantics_fmil_FMIL_getSubscribedResults_1\r
+ (JNIEnv *env, jobject obj, jint id, jdoubleArray result) {\r
+\r
+ jboolean isCopy;\r
+ jdouble* resultElements = env -> GetDoubleArrayElements(result, &isCopy);\r
+ jsize n = env -> GetArrayLength(result);\r
+ int *vrs;\r
+ if(n > 0) {\r
+ vrs = &(fmus[id].subscription[0]);\r
+ FMI1_CS_GET_REALS(fmus[id].fmu, vrs, resultElements, n);\r
+ }\r
+ if (isCopy == JNI_TRUE) {\r
+ env -> ReleaseDoubleArrayElements(result, resultElements, 0);\r
+ }\r
+\r
+ return result;\r
+ \r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_instantiateSimulation_1\r
+ (JNIEnv *env, jobject obj, jint id) {\r
+\r
+ int asd = FMI1_CS_INSTANTIATE(fmus[id].fmu);\r
+ if(asd != 0)\r
+ return throwException(env, "No FMU loaded");\r
+\r
+ return 1;\r
+\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_initializeSimulation_1\r
+ (JNIEnv *env, jobject obj, jint id) {\r
+\r
+ int asd = FMI1_CS_INITIALIZE(fmus[id].fmu);\r
+ if(asd != 0)\r
+ return throwException(env, "No FMU loaded");\r
+\r
+ return 1;\r
+\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_setTime_1\r
+ (JNIEnv *env, jobject obj, jstring id, jdouble time) {\r
+ return 1;\r
+}\r
+\r
+JNIEXPORT jobjectArray JNICALL Java_org_simantics_fmil_FMIL_getAllVariables_1\r
+ (JNIEnv *env, jobject obj, jint id) {\r
+\r
+ jobjectArray ret= (jobjectArray)env->NewObjectArray(fmus[id].variables.size(), \r
+ env->FindClass("java/lang/String"), \r
+ env->NewStringUTF("")); \r
+ \r
+ for(int i=0;i<fmus[id].variables.size();i++) { \r
+ env->SetObjectArrayElement(ret,i,env->NewStringUTF(fmus[id].variables[i].c_str())); \r
+ } \r
+\r
+ return ret; \r
+\r
+}\r
+\r
+JNIEXPORT jintArray JNICALL Java_org_simantics_fmil_FMIL_getAllVariableReferences_1\r
+ (JNIEnv *env, jobject obj, jint id, jintArray result) {\r
+\r
+ jboolean isCopy;\r
+ jint* resultElements = env -> GetIntArrayElements(result, &isCopy);\r
+ jsize n = env -> GetArrayLength(result);\r
+\r
+ int i;\r
+ for (i = 0; i < n; i++) {\r
+ resultElements[i] = fmus[id].valueReferences[i];\r
+ } \r
+ \r
+ if (isCopy == JNI_TRUE) {\r
+ env -> ReleaseIntArrayElements(result, resultElements, 0);\r
+ }\r
+\r
+ return result;\r
+\r
+}\r
+\r
+/*\r
+JNIEXPORT jobjectArray JNICALL Java_org_simantics_fmil_FMIL_filterVariables_1\r
+ (JNIEnv *env, jobject obj, jstring id, jstring regexp) {\r
+ const char *rx = env->GetStringUTFChars(regexp, 0);\r
+ jobjectArray result = filterVariables(env, obj, id, rx);\r
+ env->ReleaseStringUTFChars(regexp, rx);\r
+ return result;\r
+}\r
+*/\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_simulateStep_1\r
+ (JNIEnv *env, jobject obj, jint id) {\r
+\r
+ int asd = FMI1_CS_STEP(fmus[id].fmu, fmus[id].currentTime, fmus[id].timeStep);\r
+ if(asd != 0)\r
+ return throwException(env, "No FMU loaded");\r
+\r
+ fmus[id].currentTime += fmus[id].timeStep;\r
+\r
+ return 1;\r
+\r
+ /*\r
+ const char *fmuId = env->GetStringUTFChars(id, 0);\r
+ if(exists(fmuId)) {\r
+ FMUControlStruct& fmuStruct = fmus[fmuId];\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+\r
+ if(&fmuStruct.fmu == NULL || fmuStruct.fmu.modelDescription == NULL || &fmuStruct.vars == NULL) {\r
+ return throwException(env, "Simulate step failed - fmu not loaded");\r
+ }\r
+\r
+ if(fmuStruct.x == NULL) {\r
+ return throwException(env, "Simulate step failed - fmu not instantiated");\r
+ }\r
+\r
+ if(fmuStruct.initialized == false) {\r
+ fmiBoolean toleranceControlled = fmiFalse;\r
+ fmuStruct.fmiFlag = fmuStruct.fmu.initialize(fmuStruct.c, toleranceControlled, fmuStruct.currentTime, &(fmuStruct.eventInfo));\r
+ if (fmuStruct.fmiFlag > fmiWarning) return throwException(env, "could not initialize model");\r
+ fmuStruct.initialized = true;\r
+ }\r
+\r
+ FMU& fmu = fmuStruct.fmu;\r
+ int debug = 0; // DEBUG ON = 1, OFF = 0\r
+\r
+ int i;\r
+ double dt, tPre, tEnd = fmuStruct.currentTime + fmuStruct.step;\r
+\r
+ fmiBoolean timeEvent, stateEvent, stepEvent;\r
+ fmiStatus fmiFlag; // return code of the fmu functions\r
+ fmiValueReference vr;\r
+\r
+\r
+ */\r
+ /* Simulate the duration of one step. The simulation may be done in \r
+ * multiple parts if events occur\r
+ */ /*\r
+ while (fmuStruct.currentTime < tEnd) {\r
+ // get current state and derivatives\r
+ fmiFlag = fmu.getContinuousStates(fmuStruct.c, fmuStruct.x, fmuStruct.nx);\r
+ if (fmiFlag > fmiWarning) \r
+ return throwException(env, "could not retrieve states");\r
+\r
+ fmiFlag = fmu.getDerivatives(fmuStruct.c, fmuStruct.xdot, fmuStruct.nx);\r
+ if (fmiFlag > fmiWarning) \r
+ return throwException(env, "could not retrieve derivatives");\r
+\r
+ // advance time\r
+ tPre = fmuStruct.currentTime;\r
+ fmuStruct.currentTime = min(fmuStruct.currentTime+fmuStruct.step, tEnd);\r
+ timeEvent = fmuStruct.eventInfo.upcomingTimeEvent && fmuStruct.eventInfo.nextEventTime < fmuStruct.currentTime; \r
+ \r
+ if (timeEvent) fmuStruct.currentTime = fmuStruct.eventInfo.nextEventTime;\r
+ dt = fmuStruct.currentTime - tPre; \r
+ fmiFlag = fmu.setTime(fmuStruct.c, fmuStruct.currentTime);\r
+ if (fmiFlag > fmiWarning) throwException(env, "could not set time");\r
+\r
+ if(referenceExists(fmuStruct, "time")) {\r
+ vr = getReference(fmuStruct, "time");\r
+ if(vr != NULL) {\r
+ fmu.setReal(fmuStruct.c, &vr, 1, &(fmuStruct.currentTime));\r
+ }\r
+ }\r
+\r
+ if(debug)\r
+ printf("Actual time: %lf\n", fmuStruct.currentTime);\r
+\r
+ if (fmiFlag > fmiWarning) \r
+ return throwException(env, "could not set time");\r
+\r
+ // perform one step\r
+ for (i=0; i<fmuStruct.nx; i++) \r
+ fmuStruct.x[i] += dt*fmuStruct.xdot[i]; // forward Euler method\r
+\r
+ fmiFlag = fmu.setContinuousStates(fmuStruct.c, fmuStruct.x, fmuStruct.nx);\r
+ if (fmiFlag > fmiWarning) \r
+ return throwException(env, "could not set states");\r
+\r
+ // Check for step event, e.g. dynamic state selection\r
+ fmiFlag = fmu.completedIntegratorStep(fmuStruct.c, &stepEvent);\r
+ if (fmiFlag > fmiWarning) return throwException(env, "could not complete intgrator step");\r
+ */\r
+/* for (i=0; i<fmuStruct.nz; i++) fmuStruct.prez[i] = fmuStruct.z[i]; \r
+ fmiFlag = fmu.getEventIndicators(fmuStruct.c, fmuStruct.z, fmuStruct.nz);\r
+ if (fmiFlag > fmiWarning) return throwException(env, "could not retrieve event indicators");\r
+ stateEvent = FALSE;\r
+ for (i=0; i<fmuStruct.nz; i++) \r
+ stateEvent = stateEvent || (fmuStruct.prez[i] * fmuStruct.z[i] < 0); \r
+ \r
+\r
+ stepEvent = fmiTrue;\r
+ // handle events\r
+ if (timeEvent || stateEvent || stepEvent) {\r
+ \r
+ // event iteration in one step, ignoring intermediate results\r
+ fmiFlag = fmu.eventUpdate(fmuStruct.c, fmiFalse, &(fmuStruct.eventInfo));\r
+ if (fmiFlag > fmiWarning) return throwException(env, "could not perform event update");\r
+ \r
+ } // if event\r
+ */\r
+ \r
+/* }\r
+\r
+ fflush(stdout);\r
+ return 1;\r
+\r
+ } else {\r
+ string message = fmuId;\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return throwException(env, "simulateStep: Model id " + message + " not found");\r
+ }*/\r
+ return 1;\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_unloadFMU_1\r
+ (JNIEnv *env, jobject obj, jint id) {\r
+\r
+ int asd = FMI1_CS_UNLOAD(fmus[id].fmu);\r
+ return asd;\r
+\r
+}\r
+\r
+JNIEXPORT jstring JNICALL Java_org_simantics_fmil_FMIL_getLastErrorMessage_1\r
+ (JNIEnv *env, jobject obj, jstring id) {\r
+ return env->NewStringUTF("No errors");\r
+}\r
+\r
+JNIEXPORT jdouble JNICALL Java_org_simantics_fmil_FMIL_getRealValue_1\r
+ (JNIEnv *env, jobject obj, jint id, jint vr) {\r
+ return FMI1_CS_GET_REAL(fmus[id].fmu, vr);\r
+}\r
+\r
+JNIEXPORT jint JNICALL Java_org_simantics_fmil_FMIL_getIntegerValue_1\r
+ (JNIEnv *env, jobject obj, jstring id, jstring variable) {\r
+ /*\r
+ const char *fmuId = env->GetStringUTFChars(id, 0);\r
+ if(exists(fmuId)) {\r
+ FMUControlStruct fmuStruct = fmus[fmuId];\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ const char *name = env->GetStringUTFChars(variable, 0);\r
+\r
+ if(referenceExists(fmuStruct, name)) {\r
+ fmiValueReference vr = getReference(fmuStruct, name);\r
+ int result;\r
+ fmuStruct.fmu.getInteger(fmuStruct.c, &vr, 1, &result);\r
+ env->ReleaseStringUTFChars(variable, name);\r
+ return result;\r
+\r
+ } else {\r
+ string nameString = name;\r
+ string message = "Variable " + nameString + " not found";\r
+ env->ReleaseStringUTFChars(variable, name);\r
+ return throwException(env, message);\r
+ }\r
+\r
+ } else {\r
+ string message = fmuId;\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return throwException(env, "unloadFMU: Model id " + message + " not found");\r
+ }\r
+ */\r
+ return 1;\r
+\r
+}\r
+\r
+JNIEXPORT jboolean JNICALL Java_org_simantics_fmil_FMIL_getBooleanValue_1\r
+ (JNIEnv *env, jobject obj, jstring id, jstring variable) {\r
+ /*\r
+ const char *fmuId = env->GetStringUTFChars(id, 0);\r
+ if(exists(fmuId)) {\r
+ FMUControlStruct fmuStruct = fmus[fmuId];\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ const char *name = env->GetStringUTFChars(variable, 0);\r
+\r
+ if(referenceExists(fmuStruct, name)) {\r
+ fmiValueReference vr = getReference(fmuStruct, name);\r
+ fmiBoolean result;\r
+ fmuStruct.fmu.getBoolean(fmuStruct.c, &vr, 1, &result);\r
+ env->ReleaseStringUTFChars(variable, name);\r
+ return result;\r
+\r
+ } else {\r
+ string nameString = name;\r
+ string message = "Variable " + nameString + " not found";\r
+ env->ReleaseStringUTFChars(variable, name);\r
+ return throwException(env, message);\r
+ }\r
+\r
+ } else {\r
+ string message = fmuId;\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return throwException(env, "unloadFMU: Model id " + message + " not found");\r
+ }*/\r
+ return 1;\r
+\r
+}\r
+\r
+JNIEXPORT jstring JNICALL Java_org_simantics_fmil_FMIL_getStringValue_1\r
+ (JNIEnv *env, jobject obj, jstring id, jstring variable) {\r
+ /*\r
+ const char *fmuId = env->GetStringUTFChars(id, 0);\r
+ if(exists(fmuId)) {\r
+ FMUControlStruct fmuStruct = fmus[fmuId];\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ const char *name = env->GetStringUTFChars(variable, 0);\r
+\r
+ if(referenceExists(fmuStruct, name)) {\r
+ fmiValueReference vr = getReference(fmuStruct, name);\r
+ fmiString result;\r
+ fmuStruct.fmu.getString(fmuStruct.c, &vr, 1, &result);\r
+ env->ReleaseStringUTFChars(variable, name);\r
+ return env->NewStringUTF(result);\r
+\r
+ } else {\r
+ string nameString = name;\r
+ string message = "Variable " + nameString + " not found";\r
+ env->ReleaseStringUTFChars(variable, name);\r
+ return 0; //throwException(env, message);\r
+ }\r
+\r
+ } else {\r
+ string message = fmuId;\r
+ env->ReleaseStringUTFChars(id, fmuId);\r
+ return 0; //throwException(env, "unloadFMU: Model id " + message + " not found");\r
+ }\r
+ */\r
+ return 0;\r
+\r
+}
\ No newline at end of file
--- /dev/null
+/* ------------------------------------------------------------------------- \r
+ * sim_support.c\r
+ * Functions used by both FMU simulators fmusim_me and fmusim_cs\r
+ * to parse command-line arguments, to unzip and load an fmu, \r
+ * to write CSV file, and more.\r
+ * Copyright 2011 QTronic GmbH. All rights reserved. \r
+ * -------------------------------------------------------------------------*/ \r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <string.h>\r
+#include <assert.h>\r
+#include <time.h>\r
+\r
+#ifdef FMI_COSIMULATION\r
+#include "fmi_cs.h"\r
+#else\r
+#include "fmi_me.h"\r
+#endif\r
+\r
+#include "sim_support.h"\r
+#include "fmuExtract.h"\r
+\r
+// fileName is an absolute path, e.g. C:\test\a.fmu\r
+// or relative to the current dir, e.g. ..\test\a.fmu\r
+// Does not check for existence of the file\r
+static char* getFmuPath(const char* fileName){\r
+ char pathName[MAX_PATH];\r
+ int n = GetFullPathName(fileName, MAX_PATH, pathName, NULL);\r
+ return n ? strdup(pathName) : NULL;\r
+}\r
+\r
+int tmpPathRequests = 0;\r
+static char* getTmpPath() {\r
+ char tmpPath[BUFSIZE];\r
+ if(! GetTempPath(BUFSIZE, tmpPath)) {\r
+ printf ("error: Could not find temporary disk space\n");\r
+ return NULL;\r
+ }\r
+ if(tmpPathRequests % 2 == 0) {\r
+ strcat(tmpPath, "fmu\\");\r
+ tmpPathRequests++;\r
+ } else {\r
+ strcat(tmpPath, "fmu2\\");\r
+ tmpPathRequests = 0;\r
+ }\r
+\r
+ makedir(tmpPath);\r
+\r
+ return strdup(tmpPath);\r
+}\r
+\r
+static void* getAdr(int* s, FMU *fmu, const char* functionName){\r
+ char name[BUFSIZE];\r
+ void* fp;\r
+ sprintf(name, "%s_%s", getModelIdentifier(fmu->modelDescription), functionName);\r
+ fp = GetProcAddress(fmu->dllHandle, name);\r
+ if (!fp) {\r
+ printf ("warning: Function %s not found in dll\n", name);\r
+ *s = 0; // mark dll load as 'failed' \r
+ }\r
+ return fp;\r
+}\r
+\r
+// Load the given dll and set function pointers in fmu\r
+// Return 0 to indicate failure\r
+static int loadDll(const char* dllPath, FMU *fmu) {\r
+ int x = 1, s = 1;\r
+ HANDLE h = LoadLibraryEx(dllPath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);\r
+ if (!h) {\r
+ int error = GetLastError();\r
+ printf("error %d: Could not load %s\n", error, dllPath);\r
+ return 0; // failure\r
+ }\r
+ fmu->dllHandle = h;\r
+\r
+#ifdef FMI_COSIMULATION \r
+ fmu->getTypesPlatform = (fGetTypesPlatform) getAdr(&s, fmu, "fmiGetTypesPlatform");\r
+ if (s==0) { \r
+ s = 1; // work around bug for FMUs exported using Dymola 2012 and SimulationX 3.x\r
+ fmu->getTypesPlatform = (fGetTypesPlatform) getAdr(&s, fmu, "fmiGetModelTypesPlatform");\r
+ if (s==1) printf(" using fmiGetModelTypesPlatform instead\n", dllPath);\r
+ }\r
+ fmu->instantiateSlave = (fInstantiateSlave) getAdr(&s, fmu, "fmiInstantiateSlave");\r
+ fmu->initializeSlave = (fInitializeSlave) getAdr(&s, fmu, "fmiInitializeSlave"); \r
+ fmu->terminateSlave = (fTerminateSlave) getAdr(&s, fmu, "fmiTerminateSlave");\r
+ fmu->resetSlave = (fResetSlave) getAdr(&s, fmu, "fmiResetSlave");\r
+ fmu->freeSlaveInstance = (fFreeSlaveInstance) getAdr(&s, fmu, "fmiFreeSlaveInstance");\r
+ fmu->setRealInputDerivatives = (fSetRealInputDerivatives) getAdr(&s, fmu, "fmiSetRealInputDerivatives");\r
+ fmu->getRealOutputDerivatives = (fGetRealOutputDerivatives) getAdr(&s, fmu, "fmiGetRealOutputDerivatives");\r
+ fmu->cancelStep = (fCancelStep) getAdr(&s, fmu, "fmiCancelStep");\r
+ fmu->doStep = (fDoStep) getAdr(&s, fmu, "fmiDoStep");\r
+ // SimulationX 3.4 and 3.5 do not yet export getStatus and getXStatus: do not count this as failure here\r
+ fmu->getStatus = (fGetStatus) getAdr(&x, fmu, "fmiGetStatus");\r
+ fmu->getRealStatus = (fGetRealStatus) getAdr(&x, fmu, "fmiGetRealStatus");\r
+ fmu->getIntegerStatus = (fGetIntegerStatus) getAdr(&x, fmu, "fmiGetIntegerStatus");\r
+ fmu->getBooleanStatus = (fGetBooleanStatus) getAdr(&x, fmu, "fmiGetBooleanStatus");\r
+ fmu->getStringStatus = (fGetStringStatus) getAdr(&x, fmu, "fmiGetStringStatus"); \r
+\r
+#else // FMI for Model Exchange 1.0\r
+ fmu->getModelTypesPlatform = (fGetModelTypesPlatform) getAdr(&s, fmu, "fmiGetModelTypesPlatform");\r
+ fmu->instantiateModel = (fInstantiateModel) getAdr(&s, fmu, "fmiInstantiateModel");\r
+ fmu->freeModelInstance = (fFreeModelInstance) getAdr(&s, fmu, "fmiFreeModelInstance");\r
+ fmu->setTime = (fSetTime) getAdr(&s, fmu, "fmiSetTime");\r
+ fmu->setContinuousStates = (fSetContinuousStates)getAdr(&s, fmu, "fmiSetContinuousStates");\r
+ fmu->completedIntegratorStep = (fCompletedIntegratorStep)getAdr(&s, fmu, "fmiCompletedIntegratorStep");\r
+ fmu->initialize = (fInitialize) getAdr(&s, fmu, "fmiInitialize");\r
+ fmu->getDerivatives = (fGetDerivatives) getAdr(&s, fmu, "fmiGetDerivatives");\r
+ fmu->getEventIndicators = (fGetEventIndicators) getAdr(&s, fmu, "fmiGetEventIndicators");\r
+ fmu->eventUpdate = (fEventUpdate) getAdr(&s, fmu, "fmiEventUpdate");\r
+ fmu->getContinuousStates = (fGetContinuousStates)getAdr(&s, fmu, "fmiGetContinuousStates");\r
+ fmu->getNominalContinuousStates = (fGetNominalContinuousStates)getAdr(&s, fmu, "fmiGetNominalContinuousStates");\r
+ fmu->getStateValueReferences = (fGetStateValueReferences)getAdr(&s, fmu, "fmiGetStateValueReferences");\r
+ fmu->terminate = (fTerminate) getAdr(&s, fmu, "fmiTerminate");\r
+#endif \r
+ fmu->getVersion = (fGetVersion) getAdr(&s, fmu, "fmiGetVersion");\r
+ fmu->setDebugLogging = (fSetDebugLogging) getAdr(&s, fmu, "fmiSetDebugLogging");\r
+ fmu->setReal = (fSetReal) getAdr(&s, fmu, "fmiSetReal");\r
+ fmu->setInteger = (fSetInteger) getAdr(&s, fmu, "fmiSetInteger");\r
+ fmu->setBoolean = (fSetBoolean) getAdr(&s, fmu, "fmiSetBoolean");\r
+ fmu->setString = (fSetString) getAdr(&s, fmu, "fmiSetString");\r
+ fmu->getReal = (fGetReal) getAdr(&s, fmu, "fmiGetReal");\r
+ fmu->getInteger = (fGetInteger) getAdr(&s, fmu, "fmiGetInteger");\r
+ fmu->getBoolean = (fGetBoolean) getAdr(&s, fmu, "fmiGetBoolean");\r
+ fmu->getString = (fGetString) getAdr(&s, fmu, "fmiGetString");\r
+ return s; \r
+}\r
+\r
+static void printModelDescription(ModelDescription* md){\r
+ Element* e = (Element*)md; \r
+ int i;\r
+ printf("%s\n", elmNames[e->type]);\r
+ for (i=0; i<e->n; i+=2) \r
+ printf(" %s=%s\n", e->attributes[i], e->attributes[i+1]);\r
+#ifdef FMI_COSIMULATION \r
+ if (!md->cosimulation) {\r
+ printf("error: No Implementation element found in model description. This FMU is not for Co-Simulation.\n");\r
+ exit(EXIT_FAILURE);\r
+ }\r
+ e = md->cosimulation->capabilities;\r
+ printf("%s\n", elmNames[e->type]);\r
+ for (i=0; i<e->n; i+=2) \r
+ printf(" %s=%s\n", e->attributes[i], e->attributes[i+1]);\r
+#endif // FMI_COSIMULATION \r
+}\r
+\r
+/*\r
+ * return: 1 for successful laod or number for error.\r
+ * -1. FMU path not found\r
+ * -2. Unzip failed\r
+ * -3. Loading model description failed\r
+ * -4. FMU dll load failed\r
+ */\r
+/*\r
+int loadFMU(FMU *fmu, const char* fmuFileName, const char* tmpPath) {\r
+ char* fmuPath;\r
+ char* xmlPath;\r
+ char* dllPath;\r
+ unsigned old_clock = clock();\r
+ unsigned current_clock = 0;//will be assigned later\r
+ \r
+ // get absolute path to FMU, NULL if not found\r
+ fmuPath = getFmuPath(fmuFileName);\r
+ if (!fmuPath) return -1; // path not found\r
+\r
+ // unzip the FMU to the tmpPath directory\r
+ if (unzip(fmuPath, tmpPath)) return -2; // unzip failed\r
+\r
+ // parse tmpPath\modelDescription.xml\r
+ xmlPath = calloc(sizeof(char), strlen(tmpPath) + strlen(XML_FILE) + 1);\r
+ sprintf(xmlPath, "%s%s", tmpPath, XML_FILE);\r
+ fmu->modelDescription = parse(xmlPath);\r
+ free(xmlPath);\r
+ if (!fmu->modelDescription) return -3; // loading model description failed\r
+\r
+ // printModelDescription(fmu.modelDescription);\r
+ // fflush(stdout);\r
+\r
+ // load the FMU dll\r
+ dllPath = calloc(sizeof(char), strlen(tmpPath) + strlen(DLL_DIR) \r
+ + strlen( getModelIdentifier(fmu->modelDescription)) + strlen(".dll") + 1);\r
+ sprintf(dllPath,"%s%s%s.dll", tmpPath, DLL_DIR, getModelIdentifier(fmu->modelDescription));\r
+ if (!loadDll(dllPath, fmu)) return -4; // loading dll failed\r
+\r
+ free(dllPath);\r
+ free(fmuPath);\r
+\r
+ return 1;\r
+}\r
+*/\r
+\r
+static void doubleToCommaString(char* buffer, double r){\r
+ char* comma;\r
+ sprintf(buffer, "%.16g", r);\r
+ comma = strchr(buffer, '.');\r
+ if (comma) *comma = ',';\r
+}\r
+\r
+// output time and all non-alias variables in CSV format\r
+// if separator is ',', columns are separated by ',' and '.' is used for floating-point numbers.\r
+// otherwise, the given separator (e.g. ';' or '\t') is to separate columns, and ',' is used \r
+// as decimal dot in floating-point numbers.\r
+/*\r
+void outputRow(FMU *fmu, fmiComponent c, double time, FILE* file, char separator, boolean header) {\r
+ int k;\r
+ fmiReal r;\r
+ fmiInteger i;\r
+ fmiBoolean b;\r
+ fmiString s;\r
+ fmiValueReference vr;\r
+ ScalarVariable** vars = fmu->modelDescription->modelVariables;\r
+ char buffer[32];\r
+ \r
+ // print first column\r
+ if (header) \r
+ fprintf(file, "time"); \r
+ else {\r
+ if (separator==',') \r
+ fprintf(file, "%.16g", time);\r
+ else {\r
+ // separator is e.g. ';' or '\t'\r
+ doubleToCommaString(buffer, time);\r
+ fprintf(file, "%s", buffer); \r
+ }\r
+ }\r
+ \r
+ // print all other columns\r
+ for (k=0; vars[k]; k++) {\r
+ ScalarVariable* sv = vars[k];\r
+ if (getAlias(sv)!=enu_noAlias) continue;\r
+ if (header) {\r
+ // output names only\r
+ if (separator==',') {\r
+ // treat array element, e.g. print a[1, 2] as a[1.2]\r
+ char* s = getName(sv);\r
+ fprintf(file, "%c", separator);\r
+ while (*s) {\r
+ if (*s!=' ') fprintf(file, "%c", *s==',' ? '.' : *s);\r
+ s++;\r
+ }\r
+ }\r
+ else\r
+ fprintf(file, "%c%s", separator, getName(sv));\r
+ }\r
+ else {\r
+ // output values\r
+ vr = getValueReference(sv);\r
+ switch (sv->typeSpec->type){\r
+ case elm_Real:\r
+ fmu->getReal(c, &vr, 1, &r);\r
+ if (separator==',') \r
+ fprintf(file, ",%.16g", r);\r
+ else {\r
+ // separator is e.g. ';' or '\t'\r
+ doubleToCommaString(buffer, r);\r
+ fprintf(file, "%c%s", separator, buffer); \r
+ }\r
+ break;\r
+ case elm_Integer:\r
+ case elm_Enumeration:\r
+ fmu->getInteger(c, &vr, 1, &i);\r
+ fprintf(file, "%c%d", separator, i);\r
+ break;\r
+ case elm_Boolean:\r
+ fmu->getBoolean(c, &vr, 1, &b);\r
+ fprintf(file, "%c%d", separator, b);\r
+ break;\r
+ case elm_String:\r
+ fmu->getString(c, &vr, 1, &s);\r
+ fprintf(file, "%c%s", separator, s);\r
+ break;\r
+ default: \r
+ fprintf(file, "%cNoValueForType=%d", separator,sv->typeSpec->type);\r
+ }\r
+ }\r
+ } // for\r
+ \r
+ // terminate this row\r
+ fprintf(file, "\n"); \r
+}\r
+*/\r
+\r
+static const char* fmiStatusToString(fmiStatus status){\r
+ switch (status){\r
+ case fmiOK: return "ok";\r
+ case fmiWarning: return "warning";\r
+ case fmiDiscard: return "discard";\r
+ case fmiError: return "error";\r
+ case fmiFatal: return "fatal";\r
+#ifdef FMI_COSIMULATION\r
+ case fmiPending: return "fmiPending";\r
+#endif\r
+ default: return "?";\r
+ }\r
+}\r
+\r
+// search a fmu for the given variable\r
+// return NULL if not found or vr = fmiUndefinedValueReference\r
+static ScalarVariable* getSV(FMU* fmu, char type, fmiValueReference vr) {\r
+ int i;\r
+ Elm tp;\r
+ ScalarVariable** vars = fmu->modelDescription->modelVariables;\r
+ if (vr==fmiUndefinedValueReference) return NULL;\r
+ switch (type) {\r
+ case 'r': tp = elm_Real; break;\r
+ case 'i': tp = elm_Integer; break;\r
+ case 'b': tp = elm_Boolean; break;\r
+ case 's': tp = elm_String; break; \r
+ }\r
+ for (i=0; vars[i]; i++) {\r
+ ScalarVariable* sv = vars[i];\r
+ if (vr==getValueReference(sv) && tp==sv->typeSpec->type) \r
+ return sv;\r
+ }\r
+ return NULL;\r
+}\r
+\r
+// replace e.g. #r1365# by variable name and ## by # in message\r
+// copies the result to buffer\r
+static void replaceRefsInMessage(const char* msg, char* buffer, int nBuffer, FMU* fmu){\r
+ int i=0; // position in msg\r
+ int k=0; // position in buffer\r
+ int n;\r
+ char c = msg[i];\r
+ while (c!='\0' && k < nBuffer) {\r
+ if (c!='#') {\r
+ buffer[k++]=c;\r
+ i++;\r
+ c = msg[i];\r
+ }\r
+ else {\r
+ char* end = strchr(msg+i+1, '#');\r
+ if (!end) {\r
+ printf("unmatched '#' in '%s'\n", msg);\r
+ buffer[k++]='#';\r
+ break;\r
+ }\r
+ n = end - (msg+i);\r
+ if (n==1) {\r
+ // ## detected, output #\r
+ buffer[k++]='#';\r
+ i += 2;\r
+ c = msg[i];\r
+ }\r
+ else {\r
+ char type = msg[i+1]; // one of ribs\r
+ fmiValueReference vr;\r
+ int nvr = sscanf(msg+i+2, "%u", &vr);\r
+ if (nvr==1) {\r
+ // vr of type detected, e.g. #r12#\r
+ ScalarVariable* sv = getSV(fmu, type, vr);\r
+ const char* name = sv ? getName(sv) : "?";\r
+ sprintf(buffer+k, "%s", name);\r
+ k += strlen(name);\r
+ i += (n+1);\r
+ c = msg[i]; \r
+ }\r
+ else {\r
+ // could not parse the number\r
+ printf("illegal value reference at position %d in '%s'\n", i+2, msg);\r
+ buffer[k++]='#';\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ } // while\r
+ buffer[k] = '\0';\r
+}\r
+\r
+#define MAX_MSG_SIZE 1000\r
+void fmuLogger(FMU *fmu, fmiComponent c, fmiString instanceName, fmiStatus status,\r
+ fmiString category, fmiString message, ...) {\r
+ char msg[MAX_MSG_SIZE];\r
+ char* copy;\r
+ va_list argp;\r
+\r
+ // replace C format strings\r
+ va_start(argp, message);\r
+ vsprintf(msg, message, argp);\r
+\r
+ // replace e.g. ## and #r12# \r
+// copy = strdup(msg);\r
+// replaceRefsInMessage(copy, msg, MAX_MSG_SIZE, fmu);\r
+// free(copy);\r
+ \r
+ // print the final message\r
+ if (!instanceName) instanceName = "?";\r
+ if (!category) category = "?";\r
+ //printf("%s %s (%s): %s\n", fmiStatusToString(status), instanceName, category, msg);\r
+ printf("%s\n", message);\r
+}\r
+\r
+int error(const char* message){\r
+ printf("%s\n", message);\r
+ return 0;\r
+}\r
+\r
+void parseArguments(int argc, char *argv[], char** fmuFileName, double* tEnd, double* h, int* loggingOn, char* csv_separator) {\r
+ // parse command line arguments\r
+ if (argc>1) {\r
+ *fmuFileName = argv[1];\r
+ }\r
+ else {\r
+ printf("error: no fmu file\n");\r
+ printHelp(argv[0]);\r
+ exit(EXIT_FAILURE);\r
+ }\r
+ if (argc>2) {\r
+ if (sscanf(argv[2],"%lf", tEnd) != 1) {\r
+ printf("error: The given end time (%s) is not a number\n", argv[2]);\r
+ exit(EXIT_FAILURE);\r
+ }\r
+ }\r
+ if (argc>3) {\r
+ if (sscanf(argv[3],"%lf", h) != 1) {\r
+ printf("error: The given stepsize (%s) is not a number\n", argv[3]);\r
+ exit(EXIT_FAILURE);\r
+ }\r
+ }\r
+ if (argc>4) {\r
+ if (sscanf(argv[4],"%d", loggingOn) != 1 || *loggingOn<0 || *loggingOn>1) {\r
+ printf("error: The given logging flag (%s) is not boolean\n", argv[4]);\r
+ exit(EXIT_FAILURE);\r
+ }\r
+ }\r
+ if (argc>5) {\r
+ if (strlen(argv[5]) != 1) {\r
+ printf("error: The given CSV separator char (%s) is not valid\n", argv[5]);\r
+ exit(EXIT_FAILURE);\r
+ }\r
+ switch (argv[5][0]) {\r
+ case 'c': *csv_separator = ','; break; // comma\r
+ case 's': *csv_separator = ';'; break; // semicolon\r
+ default: *csv_separator = argv[5][0]; break; // any other char\r
+ }\r
+ }\r
+ if (argc>6) {\r
+ printf("warning: Ignoring %d additional arguments: %s ...\n", argc-6, argv[6]);\r
+ printHelp(argv[0]);\r
+ }\r
+}\r
+\r
+void printHelp(const char* fmusim) {\r
+ printf("command syntax: %s <model.fmu> <tEnd> <h> <loggingOn> <csv separator>\n", fmusim);\r
+ printf(" <model.fmu> .... path to FMU, relative to current dir or absolute, required\n");\r
+ printf(" <tEnd> ......... end time of simulation, optional, defaults to 1.0 sec\n");\r
+ printf(" <h> ............ step size of simulation, optional, defaults to 0.1 sec\n");\r
+ printf(" <loggingOn> .... 1 to activate logging, optional, defaults to 0\n");\r
+ printf(" <csv separator>. separator in csv file, optional, c for ';', s for';', defaults to c\n");\r
+}\r
+\r
--- /dev/null
+/* ------------------------------------------------------------------------- \r
+ * stack.c\r
+ * A stack of pointers. \r
+ * Copyright 2010 QTronic GmbH. All rights reserved. \r
+ * -------------------------------------------------------------------------*/ \r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <assert.h>\r
+#include "stack.h"\r
+\r
+Stack* stackNew(int initialSize, int inc){\r
+ Stack* s = (Stack*)malloc(sizeof(Stack));\r
+ s->stack = NULL;\r
+ s->stackSize = 0;\r
+ s->stackPos = -1;\r
+ s->initialSize = initialSize;\r
+ s->inc = inc;\r
+ return s;\r
+}\r
+\r
+int stackIsEmpty(Stack* s) {\r
+ return s->stackPos == -1;\r
+}\r
+\r
+// add an element to stack and grow stack if required\r
+// returns 1 to indicate success and 0 for error\r
+int stackPush(Stack* s, void* e) {\r
+ s->stackPos++;\r
+ if (s->stackPos==s->stackSize){\r
+ s->stackSize += (s->stack ? s->inc: s->initialSize);\r
+ s->stack = (void**) realloc(s->stack, s->stackSize * sizeof(void*));\r
+ if (!s->stack) return 0; // error;\r
+ }\r
+ s->stack[s->stackPos] = e;\r
+ return 1; // success\r
+}\r
+\r
+// return top element (possibly NULL), if stack not empty\r
+// runtime error if stack is empty\r
+void* stackPeek(Stack* s){\r
+ assert(!stackIsEmpty(s));\r
+ return s->stack[s->stackPos];\r
+}\r
+\r
+// remove top element (possibly NULL) from stack and return it\r
+// runtime error if stack is empty\r
+void* stackPop(Stack* s){\r
+ assert(!stackIsEmpty(s));\r
+ return s->stack[s->stackPos--];\r
+}\r
+\r
+// return the last n elements as null terminated array, \r
+// or NULL if memory allocation fails\r
+void** stackLastPopedAsArray0(Stack* s, int n){\r
+ int i;\r
+ void** array = (void**)malloc((n + 1)*sizeof(void*));\r
+ if (! array) return NULL; // failure\r
+ for (i=0; i<n; i++) {\r
+ array[i] = s->stack[i+ s->stackPos + 1];\r
+ }\r
+ array[n]=NULL; // terminating NULL\r
+ return array;\r
+}\r
+\r
+// return stack as possibly empty array, or NULL if memory allocation fails\r
+// On sucessful return, the stack is empty.\r
+void** stackPopAllAsArray(Stack* s, int *size) {\r
+ int i;\r
+ void** array = (void**)malloc((s->stackPos + 1)*sizeof(void*));\r
+ if (! array) return NULL; // failure\r
+ *size = s->stackPos + 1;\r
+ for (i=0; i<*size; i++) \r
+ array[i] = s->stack[i];\r
+ s->stackPos = -1;\r
+ return array; \r
+}\r
+\r
+// release the given stack\r
+void stackFree(Stack* s){\r
+ if (s->stack) free(s->stack);\r
+ free(s);\r
+}\r
+\r
+\r
--- /dev/null
+\r
+Microsoft Visual Studio Solution File, Format Version 12.00\r
+# Visual Studio 2012\r
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "FMUSimulator", "FMUSimulator\FMUSimulator.vcxproj", "{9838038D-09A3-43A5-AB97-B5B5C763DF43}"\r
+EndProject\r
+Global\r
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution\r
+ Debug|Mixed Platforms = Debug|Mixed Platforms\r
+ Debug|Win32 = Debug|Win32\r
+ Debug|x64 = Debug|x64\r
+ MinSizeRel|Mixed Platforms = MinSizeRel|Mixed Platforms\r
+ MinSizeRel|Win32 = MinSizeRel|Win32\r
+ MinSizeRel|x64 = MinSizeRel|x64\r
+ Release|Mixed Platforms = Release|Mixed Platforms\r
+ Release|Win32 = Release|Win32\r
+ Release|x64 = Release|x64\r
+ ReleaseWithoutAsm|Mixed Platforms = ReleaseWithoutAsm|Mixed Platforms\r
+ ReleaseWithoutAsm|Win32 = ReleaseWithoutAsm|Win32\r
+ ReleaseWithoutAsm|x64 = ReleaseWithoutAsm|x64\r
+ RelWithDebInfo|Mixed Platforms = RelWithDebInfo|Mixed Platforms\r
+ RelWithDebInfo|Win32 = RelWithDebInfo|Win32\r
+ RelWithDebInfo|x64 = RelWithDebInfo|x64\r
+ EndGlobalSection\r
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.Debug|Mixed Platforms.Build.0 = Debug|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.Debug|Win32.ActiveCfg = Debug|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.Debug|Win32.Build.0 = Debug|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.Debug|x64.ActiveCfg = Debug|x64\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.Debug|x64.Build.0 = Debug|x64\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.MinSizeRel|Mixed Platforms.ActiveCfg = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.MinSizeRel|Mixed Platforms.Build.0 = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.MinSizeRel|Win32.ActiveCfg = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.MinSizeRel|Win32.Build.0 = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.MinSizeRel|x64.ActiveCfg = Release|x64\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.MinSizeRel|x64.Build.0 = Release|x64\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.Release|Mixed Platforms.ActiveCfg = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.Release|Mixed Platforms.Build.0 = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.Release|Win32.ActiveCfg = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.Release|Win32.Build.0 = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.Release|x64.ActiveCfg = Release|x64\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.Release|x64.Build.0 = Release|x64\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.ReleaseWithoutAsm|Mixed Platforms.ActiveCfg = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.ReleaseWithoutAsm|Mixed Platforms.Build.0 = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.ReleaseWithoutAsm|Win32.ActiveCfg = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.ReleaseWithoutAsm|Win32.Build.0 = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.ReleaseWithoutAsm|x64.ActiveCfg = Release|x64\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.ReleaseWithoutAsm|x64.Build.0 = Release|x64\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.RelWithDebInfo|Mixed Platforms.ActiveCfg = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.RelWithDebInfo|Mixed Platforms.Build.0 = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.RelWithDebInfo|Win32.ActiveCfg = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.RelWithDebInfo|Win32.Build.0 = Release|Win32\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.RelWithDebInfo|x64.ActiveCfg = Release|x64\r
+ {9838038D-09A3-43A5-AB97-B5B5C763DF43}.RelWithDebInfo|x64.Build.0 = Release|x64\r
+ EndGlobalSection\r
+ GlobalSection(SolutionProperties) = preSolution\r
+ HideSolutionNode = FALSE\r
+ EndGlobalSection\r
+EndGlobal\r
--- /dev/null
+package org.simantics.fmil;\r
+\r
+public class ExecEnvironment {\r
+\r
+ public enum OSType {\r
+ APPLE, LINUX, SUN, WINDOWS, UNKNOWN\r
+ }\r
+ \r
+ public enum ARCHType {\r
+ PPC, PPC_64, SPARC, X86, X86_64, UNKNOWN;\r
+ }\r
+ \r
+ public final OSType os;\r
+ public final ARCHType arch;\r
+\r
+ private ExecEnvironment(OSType os, ARCHType arch) {\r
+ this.os = os;\r
+ this.arch = arch;\r
+ }\r
+\r
+ public static ExecEnvironment calculate() {\r
+ return new ExecEnvironment(calculateOS(), calculateArch());\r
+ }\r
+\r
+ public static ARCHType calculateArch() {\r
+ String osArch = System.getProperty("os.arch", "");\r
+ osArch = osArch.toLowerCase();\r
+ if (osArch.equals("i386") || osArch.equals("i586") || osArch.equals("i686") || osArch.equals("x86"))\r
+ return ARCHType.X86;\r
+ if (osArch.startsWith("amd64") || osArch.startsWith("x86_64"))\r
+ return ARCHType.X86_64;\r
+ if (osArch.equals("ppc"))\r
+ return ARCHType.PPC;\r
+ if (osArch.startsWith("ppc"))\r
+ return ARCHType.PPC_64;\r
+ if (osArch.startsWith("sparc"))\r
+ return ARCHType.SPARC;\r
+ return ARCHType.UNKNOWN;\r
+ }\r
+\r
+ public static OSType calculateOS() {\r
+ String osName = System.getProperty("os.name", "");\r
+ osName = osName.toLowerCase();\r
+ if (osName.startsWith("mac os x"))\r
+ return OSType.APPLE;\r
+ if (osName.startsWith("windows"))\r
+ return OSType.WINDOWS;\r
+ if (osName.startsWith("linux"))\r
+ return OSType.LINUX;\r
+ if (osName.startsWith("sun"))\r
+ return OSType.SUN;\r
+ return OSType.UNKNOWN;\r
+ }\r
+}\r
--- /dev/null
+package org.simantics.fmil;\r
+\r
+import java.io.File;\r
+import java.io.IOException;\r
+import java.io.RandomAccessFile;\r
+import java.nio.channels.FileChannel;\r
+import java.nio.channels.FileLock;\r
+import java.util.ArrayList;\r
+import java.util.HashSet;\r
+import java.util.List;\r
+import java.util.Set;\r
+import java.util.UUID;\r
+\r
+import org.eclipse.core.runtime.FileLocator;\r
+import org.eclipse.core.runtime.Platform;\r
+import org.osgi.framework.Bundle;\r
+import org.simantics.Simantics;\r
+import org.simantics.fmil.ExecEnvironment.ARCHType;\r
+import org.simantics.fmil.ExecEnvironment.OSType;\r
+import org.simantics.utils.FileUtils;\r
+\r
+import gnu.trove.list.array.TIntArrayList;\r
+import gnu.trove.map.hash.TObjectIntHashMap;\r
+\r
+\r
+public class FMIL {\r
+\r
+ /**\r
+ * Static variables\r
+ */\r
+ private static int ERROR = 0;\r
+ private static int OK = 1;\r
+ private static String UNSATISFIED_LINK = "Method not found. DLL might not be loaded properly."; \r
+ private static String TEMP_FMU_DIRECTORY_NAME = "fmil"; \r
+ public static String TEMP_FMU_COMMON_DIRECTORY; \r
+ public static String LOCK_FILE_NAME = "fmil.lock";\r
+\r
+ public static Object syncObject = new Object();\r
+\r
+ /**\r
+ * Static: load native libraries required for the FMU simulation to work.\r
+ */\r
+ static {\r
+ \r
+ File[] libraries = new File[2];\r
+\r
+ Bundle bundle = null;\r
+ \r
+ ExecEnvironment env = ExecEnvironment.calculate();\r
+ if (env.os == OSType.WINDOWS) {\r
+ if (env.arch == ARCHType.X86) {\r
+ bundle = Platform.getBundle("org.simantics.fmil.win32");\r
+ } else if (env.arch == ARCHType.X86_64) {\r
+ bundle = Platform.getBundle("org.simantics.fmil.win64");\r
+ }\r
+ }\r
+ \r
+ if (bundle != null) {\r
+ try{\r
+ String root = FileLocator.getBundleFile(bundle).getAbsolutePath();\r
+// if (env.arch == ARCHType.X86_64) {\r
+// File newFIle = new File(root, "libraries/libexpat.dll");\r
+// System.load(newFIle.getAbsolutePath());\r
+// }\r
+// libraries[0] = new File(root, "libraries/zlibwapi.dll");\r
+// libraries[1] = new File(root, "libraries/miniunz.dll");\r
+ libraries[0] = new File(root, "libraries/fmilib_shared.dll");\r
+ libraries[1] = new File(root, "libraries/FMUSimulator.dll");\r
+ }\r
+ catch (Exception e) {\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+\r
+ for(File library : libraries) {\r
+ if(library == null) {\r
+ System.err.println("FMU library not loaded. FMU simulation not working.");\r
+ continue;\r
+ } else if(!library.isFile()) {\r
+ System.err.println(library.getAbsolutePath() + " not found");\r
+ } else {\r
+ try {\r
+ System.load(library.getAbsolutePath());\r
+ } catch (Throwable t) {\r
+ System.err.println(t.getMessage());\r
+ }\r
+ } \r
+ }\r
+ }\r
+\r
+ /**\r
+ * Static: initialize fmu temp folder\r
+ */\r
+ static {\r
+ File dir = Simantics.getTemporaryDirectory(TEMP_FMU_DIRECTORY_NAME);\r
+ TEMP_FMU_COMMON_DIRECTORY = dir.getAbsolutePath(); \r
+ }\r
+\r
+\r
+ private String fmuDir;\r
+ private int id;\r
+\r
+ public String TEMP_FOLDER_1;\r
+ public String TEMP_FOLDER_2;\r
+ public String TEMP_FMU_DIRECTORY;\r
+ private String dirName;\r
+\r
+ private String[] variableNames;\r
+ private int[] variableReferences;\r
+ private TObjectIntHashMap<String> variableMap = new TObjectIntHashMap<String>();\r
+ \r
+ private Set<String> subscriptionSet = new HashSet<String>();\r
+ private TIntArrayList subscription = new TIntArrayList();\r
+ private ArrayList<String> subscribedNames = new ArrayList<String>();\r
+ \r
+ public List<String> getSubscribedNames() {\r
+ return subscribedNames;\r
+ }\r
+ \r
+ public boolean subscribe(String name) throws FMILException {\r
+ // Safety check\r
+ int vr = variableMap.get(name);\r
+ if(vr == 0) return false;\r
+ if(!subscriptionSet.add(name)) return false;\r
+ subscribedNames.add(name);\r
+ System.err.println("subscribed : " + name + " => " + subscribedNames.size());\r
+ subscription.add(vr);\r
+ subscribe(new int[] { vr });\r
+ return true;\r
+ }\r
+\r
+ public FMIL() {\r
+ // Create a directory for this control\r
+ File tempDir = new File(TEMP_FMU_COMMON_DIRECTORY, UUID.randomUUID().toString());\r
+ tempDir.mkdir();\r
+ TEMP_FMU_DIRECTORY = tempDir.getAbsolutePath();\r
+\r
+ // Create two directories inside the temp directory for this control\r
+ dirName = UUID.randomUUID().toString();\r
+ File fmuDir = new File(TEMP_FMU_DIRECTORY, dirName);\r
+ fmuDir.mkdir();\r
+\r
+ TEMP_FOLDER_1 = fmuDir.toString();\r
+ TEMP_FOLDER_2 = fmuDir.toString() + "_2";\r
+\r
+ // Lock fmu directory in temp directory\r
+ lockFMUDirectory();\r
+ }\r
+\r
+ public int getModelIDNew() {\r
+ return id;\r
+ }\r
+\r
+ public String getModelID() {\r
+ return dirName;\r
+ }\r
+\r
+ public String getFmuDir() {\r
+ return fmuDir;\r
+ }\r
+\r
+ /**\r
+ * Load fmu from a given file path. Releases the (possible) previously\r
+ * loaded fmu.\r
+ * \r
+ * @param path absolute file path for fmu file\r
+ * @throws FMILException\r
+ */\r
+ private int fmuN = 0;\r
+ private boolean fmuLoaded = false;\r
+ public void loadFMUFile(String path) throws FMILException {\r
+\r
+ synchronized(syncObject) {\r
+\r
+ if(fmuN % 2 == 0) {\r
+ fmuDir = TEMP_FOLDER_1;\r
+ fmuN++;\r
+ } else {\r
+ fmuDir = TEMP_FOLDER_2;\r
+ fmuN = 0;\r
+ }\r
+\r
+ File tempDir = new File(fmuDir);\r
+ if(tempDir.isDirectory()) {\r
+ try {\r
+ FileUtils.deleteAll(tempDir);\r
+ } catch (IOException e) {\r
+ throw new FMILException("Could not create temp folder for fmu");\r
+ }\r
+ tempDir.mkdir();\r
+ } else {\r
+ tempDir.mkdir();\r
+ }\r
+\r
+\r
+ try {\r
+ String tmpPath = tempDir.getAbsolutePath();\r
+ if(!tmpPath.endsWith("\\"))\r
+ tmpPath = tmpPath + "\\";\r
+ id = loadFMUFile_(path, tmpPath);\r
+ \r
+ getAllVariables();\r
+ getAllVariableReferences();\r
+ \r
+ for(int i=0;i<variableNames.length;i++) {\r
+ variableMap.put(variableNames[i], variableReferences[i]);\r
+ }\r
+\r
+ fmuLoaded = true;\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+\r
+ private native int loadFMUFile_(String path, String toDir);\r
+\r
+ /**\r
+ * Set a step length for simulation\r
+ * \r
+ * @param step Step length for simulation\r
+ * @throws FMILException\r
+ */\r
+ public void setStepLength(double step) throws FMILException {\r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ int ret = setStepLength_(getModelIDNew(), step);\r
+ if(ret == ERROR)\r
+ throw new FMILException(getLastErrorMessage());\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+\r
+ private native int setStepLength_(int id, double step);\r
+\r
+ /**\r
+ * Instantiates a simulation. \r
+ * <p>\r
+ * Make sure that an FMU is loaded first.\r
+ * @throws FMILException\r
+ */\r
+ public void instantiateSimulation() throws FMILException {\r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ int ret = instantiateSimulation_(getModelIDNew()); \r
+ if(ret == ERROR)\r
+ throw new FMILException(getLastErrorMessage());\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+\r
+ private native int instantiateSimulation_(int id);\r
+\r
+ \r
+ /**\r
+ * Initializes a simulation. \r
+ * <p>\r
+ * Make sure that simulation is instantiated first!\r
+ * @throws FMILException\r
+ */\r
+ public void initializeSimulation() throws FMILException {\r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ int ret = initializeSimulation_(getModelIDNew()); \r
+ if(ret == ERROR)\r
+ throw new FMILException(getLastErrorMessage());\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+\r
+ private native int initializeSimulation_(int id);\r
+\r
+ /**\r
+ * Subscribe a set of variables from a loaded simulation.\r
+ * <p>\r
+ * Make sure that an FMU is loaded first.\r
+ * @param variables Array of variables\r
+ * @throws FMILException\r
+ */\r
+ public void subscribe(int[] variables) throws FMILException {\r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ int ret = subscribe_(getModelIDNew(), variables); \r
+ if(ret == ERROR)\r
+ throw new FMILException(getLastErrorMessage());\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+\r
+ private native int subscribe_(int id, int[] variables);\r
+\r
+ /**\r
+ * Set a new (Real, double) value for a variable. If the variable is a \r
+ * parameter, the change is effective immediately.\r
+ * \r
+ * @param name Variable\r
+ * @param value New (Real, double) value\r
+ * @throws FMILException\r
+ */\r
+ public void setRealValue(String name, double value) throws FMILException {\r
+ \r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ int ret = setRealValue_(getModelIDNew(), variableMap.get(name), value); \r
+ if(ret == ERROR)\r
+ throw new FMILException(getLastErrorMessage());\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ \r
+ }\r
+ \r
+ }\r
+\r
+ public void setRealValue(int variableReference, double value) throws FMILException {\r
+ \r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ int ret = setRealValue_(getModelIDNew(), variableReference, value); \r
+ if(ret == ERROR)\r
+ throw new FMILException(getLastErrorMessage());\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ \r
+ }\r
+ \r
+ }\r
+\r
+ private native int setRealValue_(int id, int variableReference, double value);\r
+\r
+// /**\r
+// * Set a new (integer) value for a variable. If the variable is a \r
+// * parameter, the change is effective immediately.\r
+// * \r
+// * @param name Variable\r
+// * @param value New (integer) value\r
+// * @throws FMILException\r
+// */\r
+// public void setIntegerValue(String name, int value) throws FMILException {\r
+// synchronized(syncObject) {\r
+//\r
+// try {\r
+//\r
+// int ret = setIntegerValue_(getModelID(), name, value); \r
+// if(ret == ERROR)\r
+// throw new FMILException(getLastErrorMessage());\r
+//\r
+// } catch (UnsatisfiedLinkError err) {\r
+// throw new FMILException(UNSATISFIED_LINK);\r
+// } catch (Exception e) {\r
+// throw new FMILException(e.getMessage());\r
+// }\r
+// }\r
+// }\r
+// private native int setIntegerValue_(String id, String name, int value);\r
+//\r
+// /**\r
+// * Set a new (boolean) value for a variable. If the variable is a \r
+// * parameter, the change is effective immediately.\r
+// * \r
+// * @param name Variable\r
+// * @param value New (boolean) value\r
+// * @throws FMILException\r
+// */\r
+// public void setBooleanValue(String name, boolean value) throws FMILException {\r
+// synchronized(syncObject) {\r
+//\r
+// try {\r
+//\r
+// int ret = setBooleanValue_(getModelID(), name, value); \r
+// if(ret == ERROR)\r
+// throw new FMILException(getLastErrorMessage());\r
+//\r
+// } catch (UnsatisfiedLinkError err) {\r
+// throw new FMILException(UNSATISFIED_LINK);\r
+// } catch (Exception e) {\r
+// throw new FMILException(e.getMessage());\r
+// }\r
+// }\r
+// }\r
+// private native int setBooleanValue_(String id, String name, boolean value);\r
+//\r
+// public void setTime(double time) throws FMILException {\r
+// synchronized(syncObject) {\r
+//\r
+// try {\r
+//\r
+// int ret = setTime_(getModelID(), time); \r
+// if(ret == ERROR)\r
+// throw new FMILException(getLastErrorMessage());\r
+//\r
+// } catch (UnsatisfiedLinkError err) {\r
+// throw new FMILException(UNSATISFIED_LINK);\r
+// } catch (Exception e) {\r
+// throw new FMILException(e.getMessage());\r
+// }\r
+// }\r
+// }\r
+// private native int setTime_(String id, double time);\r
+\r
+ /**\r
+ * Simulate one step forward. The step length can be set with\r
+ * setStepLength()\r
+ * \r
+ * @throws FMILException\r
+ */\r
+ public void simulateStep() throws FMILException {\r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ int ret = simulateStep_(getModelIDNew()); \r
+ if(ret == ERROR)\r
+ throw new FMILException(getLastErrorMessage());\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+ private native int simulateStep_(int id);\r
+\r
+ /**\r
+ * Get an array containing the current values for subscribed variables. The\r
+ * values are in the same order as in the subscription.\r
+ * \r
+ * @param results An array the size of subscribed results\r
+ * @return\r
+ */\r
+ public double[] getSubscribedResults() throws FMILException {\r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ double[] results = new double[subscription.size()];\r
+ return getSubscribedResults_(getModelIDNew(), results);\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+\r
+ private native double[] getSubscribedResults_(int id, double[] results);\r
+ \r
+\r
+ /**\r
+ * Unload FMU and the dll:s that it requires.\r
+ * <p>\r
+ * To be called after all FMU simulations are ended. \r
+ * If the fmu is loaded again / changed, call to loadFMUFile is sufficient. loadFMUFile \r
+ * releases the previous fmu.dll \r
+ * \r
+ * @throws FMILException\r
+ */\r
+ public void unloadFMU() throws FMILException {\r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ unlockFMUDirectory();\r
+ if(fmuLoaded) {\r
+ int ret = unloadFMU_(getModelIDNew()); \r
+ if(ret == ERROR)\r
+ throw new FMILException(getLastErrorMessage());\r
+ }\r
+ removeFMUDirectoryContents();\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+ private native int unloadFMU_(int id);\r
+ \r
+// /**\r
+// * Checks if fmu has been initialized\r
+// * @return current simulation time\r
+// */\r
+// public boolean isInitialized() throws FMILException {\r
+// synchronized(syncObject) {\r
+// try {\r
+// return isInitialized_(getModelID());\r
+// } catch (UnsatisfiedLinkError err) {\r
+// throw new FMILException(UNSATISFIED_LINK);\r
+// } catch (Exception e) {\r
+// throw new FMILException(e.getMessage());\r
+// }\r
+// }\r
+// }\r
+//\r
+// private native boolean isInitialized_(String id);\r
+//\r
+ /**\r
+ * Get the current simulation time\r
+ * @return current simulation time\r
+ */\r
+ public double getTime() throws FMILException {\r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ return getTime_(getModelIDNew());\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+\r
+ private native double getTime_(int id);\r
+\r
+ /**\r
+ * Get all variables in a loaded model\r
+ * @return all variables in a loaded model\r
+ */\r
+ public String[] getAllVariables() throws FMILException {\r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ if(variableNames == null) {\r
+ variableNames = getAllVariables_(getModelIDNew());\r
+ }\r
+ return variableNames;\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+\r
+ private native String[] getAllVariables_(int id);\r
+\r
+ /**\r
+ * Get all variables in a loaded model\r
+ * @return all variables in a loaded model\r
+ */\r
+ public int[] getAllVariableReferences() throws FMILException {\r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ if(variableReferences == null) {\r
+ variableReferences = getAllVariableReferences_(getModelIDNew(), new int[variableNames.length]); \r
+ }\r
+ return variableReferences;\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+\r
+ private native int[] getAllVariableReferences_(int id, int[] array);\r
+ \r
+//\r
+// /**\r
+// * Get all variables from model that match the filter (and time variable)\r
+// * \r
+// * @param regexp Regular expression filter\r
+// * @return An array of variable names that match regexp filter (and time-variable)\r
+// * @throws FMILException\r
+// */\r
+// public String[] filterVariables(String regexp) throws FMILException { \r
+// synchronized(syncObject) {\r
+// try {\r
+//\r
+// return filterVariables_(getModelID(), regexp + "|time");\r
+//\r
+// } catch (UnsatisfiedLinkError err) {\r
+// throw new FMILException(UNSATISFIED_LINK);\r
+// } catch (Exception e) {\r
+// throw new FMILException(e.getMessage());\r
+// }\r
+// }\r
+// }\r
+//\r
+// private native String[] filterVariables_(String id, String regexp);\r
+//\r
+ /**\r
+ * Get the last error message\r
+ * @return Last error message\r
+ */\r
+ public String getLastErrorMessage() throws FMILException {\r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+\r
+ return "err";\r
+ //return getLastErrorMessage_(getModelID());\r
+\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+//\r
+// private native String getLastErrorMessage_(String id);\r
+\r
+ /**\r
+ * Get a real (double) value for variable\r
+ * @param name Name of the variable\r
+ * @return value\r
+ * @throws FMILException\r
+ */\r
+ public double getRealValue(String name) throws FMILException {\r
+ synchronized(syncObject) {\r
+\r
+ try {\r
+ // TODO: printtaa id ja name, jotta saadaan virheessä kiinni\r
+ double result = getRealValue_(getModelIDNew(), variableMap.get(name));\r
+ System.err.println("getRealValue " + name + " = " + result);\r
+ return result;\r
+ } catch (UnsatisfiedLinkError err) {\r
+ throw new FMILException(UNSATISFIED_LINK);\r
+ } catch (Exception e) {\r
+ throw new FMILException(e.getMessage());\r
+ }\r
+ }\r
+ }\r
+\r
+ private native double getRealValue_(int id, int variableReference);\r
+\r
+// /**\r
+// * Get a string value for variable\r
+// * @param name Name of the variable\r
+// * @return value\r
+// * @throws FMILException\r
+// */\r
+// public String getStringValue(String name) throws FMILException {\r
+// synchronized(syncObject) {\r
+//\r
+// try {\r
+// return getStringValue_(getModelID(), name); \r
+// } catch (UnsatisfiedLinkError err) {\r
+// throw new FMILException(UNSATISFIED_LINK);\r
+// } catch (Exception e) {\r
+// throw new FMILException(e.getMessage());\r
+// }\r
+// }\r
+// }\r
+//\r
+// private native String getStringValue_(String id, String name);\r
+//\r
+// /**\r
+// * Get an integer value for variable\r
+// * @param name Name of the variable\r
+// * @return value\r
+// * @throws FMILException\r
+// */\r
+// public int getIntegerValue(String name) throws FMILException {\r
+// synchronized(syncObject) {\r
+//\r
+// try {\r
+// return getIntegerValue_(getModelID(), name); \r
+// } catch (UnsatisfiedLinkError err) {\r
+// throw new FMILException(UNSATISFIED_LINK);\r
+// } catch (Exception e) {\r
+// throw new FMILException(e.getMessage());\r
+// }\r
+// }\r
+// }\r
+//\r
+// private native int getIntegerValue_(String id, String name);\r
+//\r
+// /**\r
+// * Get a real (double) value for variable\r
+// * @param name Name of the variable\r
+// * @return value\r
+// * @throws FMILException\r
+// */\r
+// public boolean getBooleanValue(String name) throws FMILException {\r
+// synchronized(syncObject) {\r
+//\r
+// try {\r
+// return getBooleanValue_(getModelID(), name); \r
+// } catch (UnsatisfiedLinkError err) {\r
+// throw new FMILException(UNSATISFIED_LINK);\r
+// } catch (Exception e) {\r
+// throw new FMILException(e.getMessage());\r
+// }\r
+// }\r
+// }\r
+//\r
+// private native boolean getBooleanValue_(String id, String name);\r
+\r
+ private FileChannel channel; \r
+ private FileLock lock;\r
+\r
+ @SuppressWarnings("resource")\r
+ private boolean lockFMUDirectory() {\r
+\r
+ try {\r
+ // Get a file channel for the lock file\r
+ File lockFile = new File(TEMP_FMU_DIRECTORY, LOCK_FILE_NAME);\r
+ if(!lockFile.isFile())\r
+ lockFile.createNewFile();\r
+\r
+ channel = new RandomAccessFile(lockFile, "rw").getChannel();\r
+\r
+ // Use the file channel to create a lock on the file.\r
+ // This method blocks until it can retrieve the lock.\r
+ lock = channel.lock();\r
+\r
+ // // Try acquiring the lock without blocking. This method returns\r
+ // // null or throws an exception if the file is already locked.\r
+ // try {\r
+ // lock = channel.tryLock();\r
+ // } catch (OverlappingFileLockException e) {\r
+ // // File is already locked in this thread or virtual machine\r
+ // }\r
+ } catch (IOException e) {\r
+ return false;\r
+ }\r
+\r
+ return true;\r
+ }\r
+\r
+ private boolean unlockFMUDirectory() {\r
+ try {\r
+ // Release the lock\r
+ if(lock != null)\r
+ lock.release();\r
+\r
+ // Close the file\r
+ if(channel != null)\r
+ channel.close();\r
+ } catch (IOException e) {\r
+ return false;\r
+ }\r
+ return true;\r
+ }\r
+\r
+ private boolean removeFMUDirectoryContents() {\r
+ // Remove contents\r
+ try {\r
+ File tempDir = new File(TEMP_FMU_DIRECTORY);\r
+ FileUtils.deleteAll(tempDir);\r
+ tempDir.delete();\r
+ } catch (IOException e) {\r
+ return false;\r
+ }\r
+ return true;\r
+ }\r
+}\r
--- /dev/null
+package org.simantics.fmil;\r
+\r
+/**\r
+ * Exception thrown when native fmu calls fail\r
+ * @author Teemu Lempinen\r
+ *\r
+ */\r
+public class FMILException extends Exception {\r
+ private static final long serialVersionUID = -7164064752664568008L;\r
+\r
+ public FMILException(String message) {\r
+ super(message);\r
+ }\r
+}\r
Code Review / simantics / fmil.git / commitdiff