removed model exchange part of the SDK

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/build_all.bat

@@ -1,27 +0,0 @@
-@echo off 
-
-rem ------------------------------------------------------------
-rem This batch builds both simulators and all FMUs of the FmuSDK
-rem Copyright QTronic GmbH. All rights reserved
-rem ------------------------------------------------------------
-
-rem First argument %1 should be empty for win32, and '-win64' for win64 build.
-call build_fmusim_me %1
-call build_fmusim_cs %1
-echo -----------------------------------------------------------
-echo Making the FMUs of the FmuSDK ...
-pushd models
-
-call build_fmu me dq  %1
-call build_fmu me inc %1
-call build_fmu me values %1
-call build_fmu me vanDerPol %1
-call build_fmu me bouncingBall %1
-
-call build_fmu cs dq %1
-call build_fmu cs inc %1
-call build_fmu cs values %1
-call build_fmu cs vanDerPol %1
-call build_fmu cs bouncingBall %1
-
-popd

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/build_fmusim_cs.bat

@@ -1,64 +0,0 @@
-@echo off 
-rem ------------------------------------------------------------
-rem This batch builds the FMU simulator fmu10sim_cs.exe
-rem Copyright QTronic GmbH. All rights reserved
-rem ------------------------------------------------------------
-
-setlocal
-
-echo -----------------------------------------------------------
-echo building fmu10sim_cs.exe - FMI for Co-Simulation 1.0
-echo -----------------------------------------------------------
-
-rem save env variable settings
-set PREV_PATH=%PATH%
-if defined INCLUDE set PREV_INCLUDE=%INLUDE%
-if defined LIB     set PREV_LIB=%LIB%
-if defined LIBPATH set PREV_LIBPATH=%LIBPATH%
-
-if "%1"=="-win64" (set x64=x64\) else set x64=
-
-rem setup the compiler
-if defined x64 (
-if not exist ..\..\bin\x64 mkdir ..\..\bin\x64
-if defined VS110COMNTOOLS (call "%VS110COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64) else ^
-if defined VS100COMNTOOLS (call "%VS100COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64) else ^
-if defined VS90COMNTOOLS (call "%VS90COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64) else ^
-if defined VS80COMNTOOLS (call "%VS80COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64) else ^
-goto noCompiler
-) else (
-if defined VS110COMNTOOLS (call "%VS110COMNTOOLS%\vsvars32.bat") else ^
-if defined VS100COMNTOOLS (call "%VS100COMNTOOLS%\vsvars32.bat") else ^
-if defined VS90COMNTOOLS (call "%VS90COMNTOOLS%\vsvars32.bat") else ^
-if defined VS80COMNTOOLS (call "%VS80COMNTOOLS%\vsvars32.bat") else ^
-goto noCompiler
-)
-
-set SRC=fmusim_cs\main.c ..\shared\xmlVersionParser.c ..\shared\xml_parser.c ..\shared\stack.c ..\shared\sim_support.c
-set INC=/Iinclude /I../shared /Ifmusim_cs
-set OPTIONS=/DSTANDALONE_XML_PARSER /nologo /DFMI_COSIMULATION /DLIBXML_STATIC
-
-rem create fmu10sim_cs.exe in the fmusim_cs dir
-pushd co_simulation
-cl %SRC% %INC% %OPTIONS% /Fefmu10sim_cs.exe /link ..\shared\%x64%libexpatMT.lib /LIBPATH:..\shared\%x64%
-del *.obj
-popd
-if not exist co_simulation\fmu10sim_cs.exe goto compileError
-move /Y co_simulation\fmu10sim_cs.exe ..\..\bin\%x64%
-goto done
-
-:noCompiler
-echo No Microsoft Visual C compiler found
-
-:compileError
-echo build of fmu10sim_cs.exe failed
-
-:done
-rem undo variable settings performed by vsvars32.bat
-set PATH=%PREV_PATH%
-if defined PREV_INCLUDE set INCLUDE=%PREV_INLUDE%
-if defined PREV_LIB     set LIB=%PREV_LIB%
-if defined PREV_LIBPATH set LIBPATH=%PREV_LIBPATH%
-echo done.
-
-endlocal

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/build_fmusim_me.bat

@@ -1,64 +0,0 @@
-@echo off 
-rem ------------------------------------------------------------
-rem This batch builds the FMU simulator fmu10sim_me.exe
-rem Copyright QTronic GmbH. All rights reserved
-rem ------------------------------------------------------------
-
-setlocal
-
-echo -----------------------------------------------------------
-echo building fmu10sim_me.exe - FMI for Model Exchange 1.0
-echo -----------------------------------------------------------
-
-rem save env variable settings
-set PREV_PATH=%PATH%
-if defined INCLUDE set PREV_INCLUDE=%INLUDE%
-if defined LIB     set PREV_LIB=%LIB%
-if defined LIBPATH set PREV_LIBPATH=%LIBPATH%
-
-if "%1"=="-win64" (set x64=x64\) else set x64=
-
-rem setup the compiler
-if defined x64 (
-if not exist ..\..\bin\x64 mkdir ..\..\bin\x64
-if defined VS110COMNTOOLS (call "%VS110COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64) else ^
-if defined VS100COMNTOOLS (call "%VS100COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64) else ^
-if defined VS90COMNTOOLS (call "%VS90COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64) else ^
-if defined VS80COMNTOOLS (call "%VS80COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64) else ^
-goto noCompiler
-) else (
-if defined VS110COMNTOOLS (call "%VS110COMNTOOLS%\vsvars32.bat") else ^
-if defined VS100COMNTOOLS (call "%VS100COMNTOOLS%\vsvars32.bat") else ^
-if defined VS90COMNTOOLS (call "%VS90COMNTOOLS%\vsvars32.bat") else ^
-if defined VS80COMNTOOLS (call "%VS80COMNTOOLS%\vsvars32.bat") else ^
-goto noCompiler
-)
-
-set SRC=fmusim_me\main.c ..\shared\xmlVersionParser.c ..\shared\xml_parser.c ..\shared\stack.c ..\shared\sim_support.c
-set INC=/Iinclude /I../shared /Ifmusim_me
-set OPTIONS=/nologo /DSTANDALONE_XML_PARSER /DLIBXML_STATIC
-
-rem create fmu10sim_me.exe in the fmusim_me dir
-pushd model_exchange
-cl %SRC% %INC% %OPTIONS% /Fefmu10sim_me.exe /link ..\shared\%x64%libexpatMT.lib /LIBPATH:..\shared\%x64%
-del *.obj
-popd
-if not exist model_exchange\fmu10sim_me.exe goto compileError
-move /Y model_exchange\fmu10sim_me.exe ..\..\bin\%x64%
-goto done
-
-:noCompiler
-echo No Microsoft Visual C compiler found
-
-:compileError
-echo build of fmu10sim_me.exe failed
-
-:done
-rem undo variable settings performed by vsvars32.bat
-set PATH=%PREV_PATH%
-if defined PREV_INCLUDE set INCLUDE=%PREV_INLUDE%
-if defined PREV_LIB     set LIB=%PREV_LIB%
-if defined PREV_LIBPATH set LIBPATH=%PREV_LIBPATH%
-echo done.
-
-endlocal

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/co_simulation/fmusim_cs/fmi_cs.h

@@ -1,77 +0,0 @@
-/* -------------------------------------------------------------------------
- * fmi_cs.h
- * Function types for all function of the "FMI for Co-Simulation 1.0"
- * and a struct with the corresponding function pointers.
- * Copyright QTronic GmbH. All rights reserved.
- * -------------------------------------------------------------------------*/
-
-#ifndef FMI_CS_H
-#define FMI_CS_H
-
-#include <windows.h>
-#include "fmiFunctions.h"
-#include "xml_parser.h"
-
-typedef const char* (*fGetTypesPlatform)();
-typedef const char* (*fGetVersion)();
-typedef fmiStatus (*fSetDebugLogging)    (fmiComponent c, fmiBoolean loggingOn);
-typedef fmiStatus (*fSetReal)   (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiReal    value[]);
-typedef fmiStatus (*fSetInteger)(fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiInteger value[]);
-typedef fmiStatus (*fSetBoolean)(fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiBoolean value[]);
-typedef fmiStatus (*fSetString) (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiString  value[]);
-typedef fmiStatus (*fGetReal)   (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiReal    value[]);
-typedef fmiStatus (*fGetInteger)(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiInteger value[]);
-typedef fmiStatus (*fGetBoolean)(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiBoolean value[]);
-typedef fmiStatus (*fGetString) (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiString  value[]);
-typedef fmiComponent (*fInstantiateSlave)  (fmiString  instanceName, fmiString  fmuGUID, fmiString  fmuLocation,
-        fmiString  mimeType, fmiReal timeout, fmiBoolean visible, fmiBoolean interactive, 
-        fmiCallbackFunctions functions, fmiBoolean loggingOn);
-typedef fmiStatus (*fInitializeSlave)(fmiComponent c, fmiReal tStart, fmiBoolean StopTimeDefined, fmiReal tStop);
-typedef fmiStatus (*fTerminateSlave)   (fmiComponent c);
-typedef fmiStatus (*fResetSlave)       (fmiComponent c);
-typedef void      (*fFreeSlaveInstance)(fmiComponent c);
-typedef fmiStatus (*fSetRealInputDerivatives)(fmiComponent c, const  fmiValueReference vr[], size_t nvr,
-        const fmiInteger order[], const  fmiReal value[]);
-typedef fmiStatus (*fGetRealOutputDerivatives)(fmiComponent c, const fmiValueReference vr[], size_t  nvr,
-        const fmiInteger order[], fmiReal value[]);
-typedef fmiStatus (*fCancelStep)(fmiComponent c);
-typedef fmiStatus (*fDoStep)(fmiComponent c, fmiReal currentCommunicationPoint, 
-        fmiReal communicationStepSize, fmiBoolean newStep);
-typedef fmiStatus (*fGetStatus)       (fmiComponent c, const fmiStatusKind s, fmiStatus*  value);
-typedef fmiStatus (*fGetRealStatus)   (fmiComponent c, const fmiStatusKind s, fmiReal*    value);
-typedef fmiStatus (*fGetIntegerStatus)(fmiComponent c, const fmiStatusKind s, fmiInteger* value);
-typedef fmiStatus (*fGetBooleanStatus)(fmiComponent c, const fmiStatusKind s, fmiBoolean* value);
-typedef fmiStatus (*fGetStringStatus) (fmiComponent c, const fmiStatusKind s, fmiString*  value);
-
-typedef struct {
-    ModelDescription* modelDescription;
-    HANDLE dllHandle;
-    fGetTypesPlatform getTypesPlatform;
-    fGetVersion getVersion;
-    fSetDebugLogging setDebugLogging;
-    fSetReal setReal;
-    fSetInteger setInteger;
-    fSetBoolean setBoolean;
-    fSetString setString;
-    fGetReal getReal;
-    fGetInteger getInteger;
-    fGetBoolean getBoolean;
-    fGetString getString;
-    fInstantiateSlave instantiateSlave;
-    fInitializeSlave initializeSlave;
-    fTerminateSlave terminateSlave;
-    fResetSlave resetSlave;
-    fFreeSlaveInstance freeSlaveInstance;
-    fGetRealOutputDerivatives getRealOutputDerivatives;
-    fSetRealInputDerivatives setRealInputDerivatives;
-    fDoStep doStep;
-    fCancelStep cancelStep;
-    fGetStatus getStatus;
-    fGetRealStatus getRealStatus;
-    fGetIntegerStatus getIntegerStatus;
-    fGetBooleanStatus getBooleanStatus;
-    fGetStringStatus getStringStatus;
-} FMU;
-
-#endif // FMI_CS_H
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/co_simulation/fmusim_cs/main.c

@@ -1,126 +0,0 @@
-/* -------------------------------------------------------------------------
- * main.c
- * Implements simulation of a single FMU instance
- * that implements the "FMI for Co-Simulation 1.0" interface.
- * Command syntax: see printHelp()
- * Simulates the given FMU from t = 0 .. tEnd with fixed step size h and
- * writes the computed solution to file 'result.csv'.
- * The CSV file (comma-separated values) may e.g. be plotted using 
- * OpenOffice Calc or Microsoft Excel. 
- * This progamm demonstrates basic use of an FMU.
- * Real applications may use advanced master algorithms to cosimulate 
- * many FMUs, limit the numerical error using error estimation
- * and back-stepping, provide graphical plotting utilities, debug support,
- * and user control of parameter and start values, or perform a clean
- * error handling (e.g. call freeSlaveInstance when a call to the fmu
- * returns with error). All this is missing here.
- *
- * Revision history
- *  22.08.2011 initial version released in FMU SDK 1.0.2
- *
- * Free libraries and tools used to implement this simulator:
- *  - header files from the FMU specification
- *  - eXpat 2.0.1 XML parser, see http://expat.sourceforge.net
- *  - 7z.exe 4.57 zip and unzip tool, see http://www.7-zip.org
- * Author: Jakob Mauss
- * Copyright QTronic GmbH. All rights reserved.
- * -------------------------------------------------------------------------*/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include "fmi_cs.h"
-#include "sim_support.h"
-
-FMU fmu; // the fmu to simulate
-
-// simulate the given FMU from tStart = 0 to tEnd.
-static int simulate(FMU* fmu, double tEnd, double h, fmiBoolean loggingOn, char separator) {
-    double time;
-    double tStart = 0;               // start time
-    const char* guid;                // global unique id of the fmu
-    fmiComponent c;                  // instance of the fmu 
-    fmiStatus fmiFlag;               // return code of the fmu functions
-    char* fmuLocation = getTempFmuLocation(); // path to the fmu as URL, "file://C:\QTronic\sales"
-    const char* mimeType = "application/x-fmu-sharedlibrary"; // denotes tool in case of tool coupling
-    fmiReal timeout = 1000;          // wait period in milli seconds, 0 for unlimited wait period"
-    fmiBoolean visible = fmiFalse;   // no simulator user interface
-    fmiBoolean interactive = fmiFalse; // simulation run without user interaction
-    fmiCallbackFunctions callbacks;  // called by the model during simulation
-    ModelDescription* md;            // handle to the parsed XML file
-    int nSteps = 0;
-    FILE* file;
-
-    // instantiate the fmu
-    md = fmu->modelDescription;
-    guid = getString(md, att_guid);
-    callbacks.logger = fmuLogger;
-    callbacks.allocateMemory = calloc;
-    callbacks.freeMemory = free;
-    callbacks.stepFinished = NULL; // fmiDoStep has to be carried out synchronously
-    c = fmu->instantiateSlave(getModelIdentifier(md), guid, fmuLocation, mimeType,
-                              timeout, visible, interactive, callbacks, loggingOn);
-    free(fmuLocation);
-    if (!c) return error("could not instantiate model");
-
-    // open result file
-    if (!(file=fopen(RESULT_FILE, "w"))) {
-        printf("could not write %s because:\n", RESULT_FILE);
-        printf("    %s\n", strerror(errno));
-        return 0; // failure
-    }
-
-    // StopTimeDefined=fmiFalse means: ignore value of tEnd
-    fmiFlag = fmu->initializeSlave(c, tStart, fmiTrue, tEnd);
-    if (fmiFlag > fmiWarning)  return error("could not initialize model");
-    
-    // output solution for time t0
-    outputRow(fmu, c, tStart, file, separator, fmiTrue);  // output column names
-    outputRow(fmu, c, tStart, file, separator, fmiFalse); // output values
-
-    // enter the simulation loop
-    time = tStart;
-    while (time < tEnd) {
-        fmiFlag = fmu->doStep(c, time, h, fmiTrue);
-        if (fmiFlag != fmiOK)  return error("could not complete simulation of the model");
-        time += h;
-        outputRow(fmu, c, time, file, separator, fmiFalse); // output values for this step
-        nSteps++;
-    }
-
-    // end simulation
-    fmiFlag = fmu->terminateSlave(c);
-    fmu->freeSlaveInstance(c);
-    fclose(file);
-
-    // print simulation summary 
-    printf("Simulation from %g to %g terminated successful\n", tStart, tEnd);
-    printf("  steps ............ %d\n", nSteps);
-    printf("  fixed step size .. %g\n", h);
-    return 1; // success
-}
-
-int main(int argc, char *argv[]) {
-    const char* fmuFileName;
-
-    // parse command line arguments and load the FMU
-    double tEnd = 1.0;
-    double h=0.1;
-    int loggingOn = 0;
-    char csv_separator = ',';
-    parseArguments(argc, argv, &fmuFileName, &tEnd, &h, &loggingOn, &csv_separator);
-    loadFMU(fmuFileName);
-
-    // run the simulation
-    printf("FMU Simulator: run '%s' from t=0..%g with step size h=%g, loggingOn=%d, csv separator='%c'\n",
-            fmuFileName, tEnd, h, loggingOn, csv_separator);
-    simulate(&fmu, tEnd, h, loggingOn, csv_separator);
-    printf("CSV file '%s' written\n", RESULT_FILE);
-
-    // release FMU 
-    FreeLibrary(fmu.dllHandle);
-    freeElement(fmu.modelDescription);
-    deleteUnzippedFiles();
-    return EXIT_SUCCESS;
-}
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/co_simulation/include/fmiFunctions.h

@@ -1,227 +0,0 @@
-#ifndef fmiFunctions_h
-#define fmiFunctions_h
-
-/* This header file must be utilized when compiling a FMU.
-   It defines all functions of Co-Simulation Interface.
-   In order to have unique function names even if several FMUs
-   are compiled together (e.g. for embedded systems), every "real" function name
-   is constructed by prepending the function name by
-   "MODEL_IDENTIFIER" + "_" where "MODEL_IDENTIFIER" is the short name
-   of the model used as the name of the zip-file where the model is stored.
-   Therefore, the typical usage is:
-
-      #define MODEL_IDENTIFIER MyModel
-      #include "fmiFunctions.h"
-
-   As a result, a function that is defined as "fmiGetDerivatives" in this header file,
-   is actually getting the name "MyModel_fmiGetDerivatives".
-
-   Revisions:
-   - November 4, 2010: Adapted to specification text:
-                       o fmiGetModelTypesPlatform renamed to fmiGetTypesPlatform
-                       o fmiInstantiateSlave: Argument GUID     replaced by fmuGUID
-                                              Argument mimetype replaced by mimeType
-                       o tabs replaced by spaces
-   - October 16, 2010: First public Version
-
-
-   Copyright © 2008-2010, MODELISAR consortium. All rights reserved.
-   This file is licensed by the copyright holders under the BSD License
-   (http://www.opensource.org/licenses/bsd-license.html):
-
-   ----------------------------------------------------------------------------
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-
-   - Redistributions of source code must retain the above copyright notice,
-     this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright notice,
-     this list of conditions and the following disclaimer in the documentation
-     and/or other materials provided with the distribution.
-   - Neither the name of the copyright holders nor the names of its
-     contributors may be used to endorse or promote products derived
-     from this software without specific prior written permission.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-   OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-   ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-   ----------------------------------------------------------------------------
-*/
-
-#include "fmiPlatformTypes.h"
-#include <stdlib.h>
-
-/* Export fmi functions on Windows */
-#ifdef _MSC_VER
-#define DllExport __declspec( dllexport )
-#else
-#define DllExport
-#endif
-
-/* Macros to construct the real function name
-   (prepend function name by MODEL_IDENTIFIER + "_") */
-
-#define fmiPaste(a,b)     a ## b
-#define fmiPasteB(a,b)    fmiPaste(a,b)
-#define fmiFullName(name) fmiPasteB(MODEL_IDENTIFIER, name)
-
-/***************************************************
-Common Functions
-****************************************************/
-#define fmiGetTypesPlatform fmiFullName(_fmiGetTypesPlatform)
-#define fmiGetVersion       fmiFullName(_fmiGetVersion)
-#define fmiSetDebugLogging  fmiFullName(_fmiSetDebugLogging)
-
-/*Data Exchange*/
-#define fmiSetReal               fmiFullName(_fmiSetReal)
-#define fmiSetInteger            fmiFullName(_fmiSetInteger)
-#define fmiSetBoolean            fmiFullName(_fmiSetBoolean)
-#define fmiSetString             fmiFullName(_fmiSetString)
-
-#define fmiGetReal               fmiFullName(_fmiGetReal)
-#define fmiGetInteger            fmiFullName(_fmiGetInteger)
-#define fmiGetBoolean            fmiFullName(_fmiGetBoolean)
-#define fmiGetString             fmiFullName(_fmiGetString)
-
-/***************************************************
-Functions for FMI for Co-Simulation
-****************************************************/
-#define fmiInstantiateSlave         fmiFullName(_fmiInstantiateSlave)
-#define fmiInitializeSlave          fmiFullName(_fmiInitializeSlave)
-#define fmiTerminateSlave           fmiFullName(_fmiTerminateSlave)
-#define fmiResetSlave               fmiFullName(_fmiResetSlave)
-#define fmiFreeSlaveInstance        fmiFullName(_fmiFreeSlaveInstance)
-#define fmiSetRealInputDerivatives  fmiFullName(_fmiSetRealInputDerivatives)
-#define fmiGetRealOutputDerivatives fmiFullName(_fmiGetRealOutputDerivatives)
-#define fmiDoStep                   fmiFullName(_fmiDoStep)
-#define fmiCancelStep               fmiFullName(_fmiCancelStep)
-#define fmiGetStatus                fmiFullName(_fmiGetStatus)
-#define fmiGetRealStatus            fmiFullName(_fmiGetRealStatus)
-#define fmiGetIntegerStatus         fmiFullName(_fmiGetIntegerStatus)
-#define fmiGetBooleanStatus         fmiFullName(_fmiGetBooleanStatus)
-#define fmiGetStringStatus          fmiFullName(_fmiGetStringStatus)
-
-/* Version number */
-#define fmiVersion "1.0"
-
-/* make sure all compiler use the same alignment policies for structures */
-#pragma pack(push,8)
-
-
-/* Type definitions */
-     typedef enum {fmiOK,
-                   fmiWarning,
-                   fmiDiscard,
-                   fmiError,
-                   fmiFatal,
-                   fmiPending} fmiStatus;
-
-     typedef void  (*fmiCallbackLogger) (fmiComponent c, fmiString instanceName, fmiStatus status,
-                                         fmiString category, fmiString message, ...);
-     typedef void* (*fmiCallbackAllocateMemory)(size_t nobj, size_t size);
-     typedef void  (*fmiCallbackFreeMemory)    (void* obj);
-     typedef void  (*fmiStepFinished)          (fmiComponent c, fmiStatus status);
-
-     typedef struct {
-     fmiCallbackLogger         logger;
-     fmiCallbackAllocateMemory allocateMemory;
-     fmiCallbackFreeMemory     freeMemory;
-     fmiStepFinished           stepFinished;
-     } fmiCallbackFunctions;
-
-   typedef struct {
-      fmiBoolean iterationConverged;
-      fmiBoolean stateValueReferencesChanged;
-      fmiBoolean stateValuesChanged;
-      fmiBoolean terminateSimulation;
-      fmiBoolean upcomingTimeEvent;
-      fmiReal    nextEventTime;
-   } fmiEventInfo;
-
-/* reset alignment policy to the one set before reading this file */
-#pragma pack(pop)
-
-/***************************************************
-Common Functions
-****************************************************/
-
-/* Inquire version numbers of header files */
-   DllExport const char* fmiGetTypesPlatform();
-   DllExport const char* fmiGetVersion();
-
-   DllExport fmiStatus fmiSetDebugLogging  (fmiComponent c, fmiBoolean loggingOn);
-
-/* Data Exchange Functions*/
-   DllExport fmiStatus fmiGetReal   (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiReal    value[]);
-   DllExport fmiStatus fmiGetInteger(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiInteger value[]);
-   DllExport fmiStatus fmiGetBoolean(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiBoolean value[]);
-   DllExport fmiStatus fmiGetString (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiString  value[]);
-
-   DllExport fmiStatus fmiSetReal    (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiReal    value[]);
-   DllExport fmiStatus fmiSetInteger (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiInteger value[]);
-   DllExport fmiStatus fmiSetBoolean (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiBoolean value[]);
-   DllExport fmiStatus fmiSetString  (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiString  value[]);
-
-/***************************************************
-Functions for FMI for Co-Simulation
-****************************************************/
-
-/* Creation and destruction of slave instances and setting debug status */
-   DllExport fmiComponent fmiInstantiateSlave(fmiString  instanceName,
-                                              fmiString  fmuGUID,
-                                              fmiString  fmuLocation,
-                                              fmiString  mimeType,
-                                              fmiReal    timeout,
-                                              fmiBoolean visible,
-                                              fmiBoolean interactive,
-                                              fmiCallbackFunctions functions,
-                                              fmiBoolean loggingOn);
-
-   DllExport fmiStatus fmiInitializeSlave(fmiComponent c,
-                                          fmiReal      tStart,
-                                          fmiBoolean   StopTimeDefined,
-                                          fmiReal      tStop);
-
-   DllExport fmiStatus fmiTerminateSlave   (fmiComponent c);
-   DllExport fmiStatus fmiResetSlave       (fmiComponent c);
-   DllExport void      fmiFreeSlaveInstance(fmiComponent c);
-
-   DllExport fmiStatus fmiSetRealInputDerivatives(fmiComponent c,
-                                                  const  fmiValueReference vr[],
-                                                  size_t nvr,
-                                                  const  fmiInteger order[],
-                                                  const  fmiReal value[]);
-
-   DllExport fmiStatus fmiGetRealOutputDerivatives(fmiComponent c,
-                                                   const   fmiValueReference vr[],
-                                                   size_t  nvr,
-                                                   const   fmiInteger order[],
-                                                   fmiReal value[]);
-
-   DllExport fmiStatus fmiCancelStep(fmiComponent c);
-   DllExport fmiStatus fmiDoStep    (fmiComponent c,
-                                     fmiReal      currentCommunicationPoint,
-                                     fmiReal      communicationStepSize,
-                                     fmiBoolean   newStep);
-
-
-   typedef enum {fmiDoStepStatus,
-                 fmiPendingStatus,
-                 fmiLastSuccessfulTime} fmiStatusKind;
-
-   DllExport fmiStatus fmiGetStatus       (fmiComponent c, const fmiStatusKind s, fmiStatus*  value);
-   DllExport fmiStatus fmiGetRealStatus   (fmiComponent c, const fmiStatusKind s, fmiReal*    value);
-   DllExport fmiStatus fmiGetIntegerStatus(fmiComponent c, const fmiStatusKind s, fmiInteger* value);
-   DllExport fmiStatus fmiGetBooleanStatus(fmiComponent c, const fmiStatusKind s, fmiBoolean* value);
-   DllExport fmiStatus fmiGetStringStatus (fmiComponent c, const fmiStatusKind s, fmiString*  value);
-
-
-#endif // fmiFunctions_h

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/co_simulation/include/fmiPlatformTypes.h

@@ -1,73 +0,0 @@
-#ifndef fmiPlatformTypes_h
-#define fmiPlatformTypes_h
-
-/* Standard header file to define the argument types of the
-   functions of the Model Execution Interface.
-   This header file must be utilized both by the model and
-   by the simulation engine.
-
-   Revisions:
-   - October 2010: First public Version
-
-
-   Copyright © 2008-2010, MODELISAR consortium. All rights reserved.
-   This file is licensed by the copyright holders under the BSD License
-   (http://www.opensource.org/licenses/bsd-license.html):
-
-
-   ----------------------------------------------------------------------------
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-
-   - Redistributions of source code must retain the above copyright notice,
-     this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright notice,
-     this list of conditions and the following disclaimer in the documentation
-     and/or other materials provided with the distribution.
-   - Neither the name of the copyright holders nor the names of its
-     contributors may be used to endorse or promote products derived
-     from this software without specific prior written permission.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-   OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-   ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-   ----------------------------------------------------------------------------
-*/
-
-/* Platform (combination of machine, compiler, operating system) */
-#define fmiPlatform "standard32"
-
-/* Type definitions of variables passed as arguments
-   Version "standard32" means:
-
-   fmiComponent     : 32 bit pointer
-   fmiValueReference: 32 bit
-   fmiReal          : 64 bit
-   fmiInteger       : 32 bit
-   fmiBoolean       :  8 bit
-   fmiString        : 32 bit pointer
-
-*/
-   typedef void*        fmiComponent;
-   typedef unsigned int fmiValueReference;
-   typedef double       fmiReal   ;
-   typedef int          fmiInteger;
-   typedef char         fmiBoolean;
-   typedef const char*  fmiString ;
-
-/* Values for fmiBoolean  */
-#define fmiTrue  1
-#define fmiFalse 0
-
-/* Undefined value for fmiValueReference (largest unsigned int value) */
-#define fmiUndefinedValueReference (fmiValueReference)(-1)
-
-#endif

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/model_exchange/fmusim_me/fmi_me.h

@@ -1,88 +0,0 @@
-/* -------------------------------------------------------------------------
- * fmi_me.h
- * Function types for all function of the "FMI for Model Exchange 1.0"
- * and a struct with the corresponding function pointers.
- * Copyright QTronic GmbH. All rights reserved.
- * -------------------------------------------------------------------------*/
-
-#ifndef FMI_ME_H
-#define FMI_ME_H
-
-#include <windows.h>
-#include "fmiModelFunctions.h"
-#include "xml_parser.h"
-
-typedef const char* (*fGetModelTypesPlatform)();
-typedef const char* (*fGetVersion)();
-typedef fmiComponent (*fInstantiateModel)(fmiString instanceName, fmiString GUID,
-                                        fmiCallbackFunctions functions, fmiBoolean loggingOn);
-typedef void      (*fFreeModelInstance)  (fmiComponent c);
-typedef fmiStatus (*fSetDebugLogging)    (fmiComponent c, fmiBoolean loggingOn);
-typedef fmiStatus (*fSetTime)            (fmiComponent c, fmiReal time);
-typedef fmiStatus (*fSetContinuousStates)(fmiComponent c, const fmiReal x[], size_t nx);
-typedef fmiStatus (*fCompletedIntegratorStep)(fmiComponent c, fmiBoolean* callEventUpdate);
-typedef fmiStatus (*fSetReal)   (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiReal    value[]);
-typedef fmiStatus (*fSetInteger)(fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiInteger value[]);
-typedef fmiStatus (*fSetBoolean)(fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiBoolean value[]);
-typedef fmiStatus (*fSetString) (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiString  value[]);
-typedef fmiStatus (*fInitialize)(fmiComponent c, fmiBoolean toleranceControlled, 
-                               fmiReal relativeTolerance, fmiEventInfo* eventInfo);
-typedef fmiStatus (*fGetDerivatives)    (fmiComponent c, fmiReal derivatives[]    , size_t nx);
-typedef fmiStatus (*fGetEventIndicators)(fmiComponent c, fmiReal eventIndicators[], size_t ni);
-typedef fmiStatus (*fGetReal)   (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiReal    value[]);
-typedef fmiStatus (*fGetInteger)(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiInteger value[]);
-typedef fmiStatus (*fGetBoolean)(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiBoolean value[]);
-typedef fmiStatus (*fGetString) (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiString  value[]);
-typedef fmiStatus (*fEventUpdate)               (fmiComponent c, fmiBoolean intermediateResults, fmiEventInfo* eventInfo);
-typedef fmiStatus (*fGetContinuousStates)       (fmiComponent c, fmiReal states[], size_t nx);
-typedef fmiStatus (*fGetNominalContinuousStates)(fmiComponent c, fmiReal x_nominal[], size_t nx);
-typedef fmiStatus (*fGetStateValueReferences)   (fmiComponent c, fmiValueReference vrx[], size_t nx);
-typedef fmiStatus (*fTerminate)                 (fmiComponent c);    
-
-typedef struct {
-    ModelDescription* modelDescription;
-    HANDLE dllHandle;
-    fGetModelTypesPlatform getModelTypesPlatform;
-    fGetVersion getVersion;
-    fInstantiateModel instantiateModel;
-    fFreeModelInstance freeModelInstance;
-    fSetDebugLogging setDebugLogging;
-    fSetTime setTime;
-    fSetContinuousStates setContinuousStates;
-    fCompletedIntegratorStep completedIntegratorStep;
-    fSetReal setReal;
-    fSetInteger setInteger;
-    fSetBoolean setBoolean;
-    fSetString setString;
-    fInitialize initialize;
-    fGetDerivatives getDerivatives;
-    fGetEventIndicators getEventIndicators;
-    fGetReal getReal;
-    fGetInteger getInteger;
-    fGetBoolean getBoolean;
-    fGetString getString;
-    fEventUpdate eventUpdate;
-    fGetContinuousStates getContinuousStates;
-    fGetNominalContinuousStates getNominalContinuousStates;
-    fGetStateValueReferences getStateValueReferences;
-    fTerminate terminate; 
-/*
-    fInstantiateSlave instantiateSlave;
-    fInitializeSlave initializeSlave;
-    fTerminateSlave terminateSlave;
-    fResetSlave resetSlave;
-    fFreeSlaveInstance freeSlaveInstance;
-    fGetRealOutputDerivatives getRealOutputDerivatives;
-    fSetRealInputDerivatives setRealInputDerivatives;
-    fDoStep doStep;
-    fCancelStep cancelStep;
-    fGetStatus getStatus;
-    fGetRealStatus getRealStatus;
-    fGetIntegerStatus getIntegerStatus;
-    fGetBooleanStatus getBooleanStatus;
-    fGetStringStatus getStringStatus;
-*/
-} FMU;
-
-#endif // FMI_ME_H
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/model_exchange/fmusim_me/main.c

@@ -1,240 +0,0 @@
-/* ------------------------------------------------------------------------- 
- * main.c
- * Implements simulation of a single FMU instance using the forward Euler
- * method for numerical integration.
- * Command syntax: see printHelp()
- * Simulates the given FMU from t = 0 .. tEnd with fixed step size h and
- * writes the computed solution to file 'result.csv'.
- * The CSV file (comma-separated values) may e.g. be plotted using
- * OpenOffice Calc or Microsoft Excel.
- * This program demonstrates basic use of an FMU.
- * Real applications may use advanced numerical solvers instead, means to 
- * exactly locate state events in time, graphical plotting utilities, support
- * for co-execution of many FMUs, stepping and debug support, user control
- * of parameter and start values etc. 
- * All this is missing here.
- *
- * Revision history
- *  07.02.2010 initial version released in FMU SDK 1.0
- *  05.03.2010 bug fix: removed strerror(GetLastError()) from error messages
- *  11.06.2010 bug fix: replaced win32 API call to OpenFile in getFmuPath
- *    which restricted path length to FMU to 128 chars. New limit is MAX_PATH.
- *  15.07.2010 fixed wrong label in xml parser: deault instead of default
- *  13.12.2010 added check for undefined 'declared type' to xml parser
- *  31.07.2011 bug fix: added missing freeModelInstance(c)
- *  31.07.2011 bug fix: added missing terminate(c)
- *  30.08.2012 fixed access violation in xmlParser after reporting unknown attribute name
- *
- * Free libraries and tools used to implement this simulator:
- *  - header files from the FMU specification
- *  - eXpat 2.0.1 XML parser, see http://expat.sourceforge.net
- *  - 7z.exe 4.57 zip and unzip tool, see http://www.7-zip.org
- * Author: Jakob Mauss
- * Copyright QTronic GmbH. All rights reserved.
- * -------------------------------------------------------------------------*/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h> //strerror()
-#include "fmi_me.h"
-#include "sim_support.h"
-
-FMU fmu; // the fmu to simulate
-
-// simulate the given FMU using the forward euler method.
-// time events are processed by reducing step size to exactly hit tNext.
-// state events are checked and fired only at the end of an Euler step. 
-// the simulator may therefore miss state events and fires state events typically too late.
-static int simulate(FMU* fmu, double tEnd, double h, fmiBoolean loggingOn, char separator) {
-    int i, n;
-    double dt, tPre;
-    fmiBoolean timeEvent, stateEvent, stepEvent;
-    double time;  
-    int nx;                          // number of state variables
-    int nz;                          // number of state event indicators
-    double *x;                       // continuous states
-    double *xdot;                    // the crresponding derivatives in same order
-    double *z = NULL;                // state event indicators
-    double *prez = NULL;             // previous values of state event indicators
-    fmiEventInfo eventInfo;          // updated by calls to initialize and eventUpdate
-    ModelDescription* md;            // handle to the parsed XML file
-    const char* guid;                // global unique id of the fmu
-    fmiCallbackFunctions callbacks;  // called by the model during simulation
-    fmiComponent c;                  // instance of the fmu 
-    fmiStatus fmiFlag;               // return code of the fmu functions
-    fmiReal t0 = 0;                  // start time
-    fmiBoolean toleranceControlled = fmiFalse;
-    int nSteps = 0;
-    int nTimeEvents = 0;
-    int nStepEvents = 0;
-    int nStateEvents = 0;
-    FILE* file;
-
-    // instantiate the fmu
-    md = fmu->modelDescription;
-    guid = getString(md, att_guid);
-    callbacks.logger = fmuLogger;
-    callbacks.allocateMemory = calloc;
-    callbacks.freeMemory = free;
-    c = fmu->instantiateModel(getModelIdentifier(md), guid, callbacks, loggingOn);
-    if (!c) return error("could not instantiate model");
-
-    // allocate memory 
-    nx = getNumberOfStates(md);
-    nz = getNumberOfEventIndicators(md);
-    x    = (double *) calloc(nx, sizeof(double));
-    xdot = (double *) calloc(nx, sizeof(double));
-    if (nz>0) {
-        z    =  (double *) calloc(nz, sizeof(double));
-        prez =  (double *) calloc(nz, sizeof(double));
-    }
-    if ((!x || !xdot) || (nz>0 && (!z || !prez))) return error("out of memory");
-
-    // open result file
-    if (!(file=fopen(RESULT_FILE, "w"))) {
-        printf("could not write %s because:\n", RESULT_FILE);
-        printf("    %s\n", strerror(errno));
-        free(x);
-        free(xdot);
-        free(z);
-        free(prez);
-
-        return 0; // failure
-    }
-
-    // set the start time and initialize
-    time = t0;
-    fmiFlag =  fmu->setTime(c, t0);
-    if (fmiFlag > fmiWarning) return error("could not set time");
-    fmiFlag =  fmu->initialize(c, toleranceControlled, t0, &eventInfo);
-    if (fmiFlag > fmiWarning)  return error("could not initialize model");
-    if (eventInfo.terminateSimulation) {
-        printf("model requested termination at init");
-        tEnd = time;
-    }
-
-    // output solution for time t0
-    outputRow(fmu, c, t0, file, separator, fmiTrue);  // output column names
-    outputRow(fmu, c, t0, file, separator, fmiFalse); // output values
-
-    // enter the simulation loop
-    while (time < tEnd) {
-     // get current state and derivatives
-     fmiFlag = fmu->getContinuousStates(c, x, nx);
-     if (fmiFlag > fmiWarning) return error("could not retrieve states");
-     fmiFlag = fmu->getDerivatives(c, xdot, nx);
-     if (fmiFlag > fmiWarning) return error("could not retrieve derivatives");
-
-     // advance time
-     tPre = time;
-     time = min(time+h, tEnd);
-     timeEvent = eventInfo.upcomingTimeEvent && eventInfo.nextEventTime < time;
-     if (timeEvent) time = eventInfo.nextEventTime;
-     dt = time - tPre; 
-     fmiFlag = fmu->setTime(c, time);
-     if (fmiFlag > fmiWarning) error("could not set time");
-
-     // perform one step
-     for (i=0; i<nx; i++) x[i] += dt*xdot[i]; // forward Euler method
-     fmiFlag = fmu->setContinuousStates(c, x, nx);
-     if (fmiFlag > fmiWarning) return error("could not set states");
-     if (loggingOn) printf("Step %d to t=%.16g\n", nSteps, time);
-
-     // Check for step event, e.g. dynamic state selection
-     fmiFlag = fmu->completedIntegratorStep(c, &stepEvent);
-     if (fmiFlag > fmiWarning) return error("could not complete integrator step");
-
-     // Check for state event
-     for (i=0; i<nz; i++) prez[i] = z[i]; 
-     fmiFlag = fmu->getEventIndicators(c, z, nz);
-     if (fmiFlag > fmiWarning) return error("could not retrieve event indicators");
-     stateEvent = FALSE;
-     for (i=0; i<nz; i++) 
-         stateEvent = stateEvent || (prez[i] * z[i] < 0);
-
-     // handle events
-     if (timeEvent || stateEvent || stepEvent) {
-
-        if (timeEvent) {
-            nTimeEvents++;
-            if (loggingOn) printf("time event at t=%.16g\n", time);
-        }
-        if (stateEvent) {
-            nStateEvents++;
-            if (loggingOn) for (i=0; i<nz; i++)
-                printf("state event %s z[%d] at t=%.16g\n", 
-                        (prez[i]>0 && z[i]<0) ? "-\\-" : "-/-", i, time);
-        }
-        if (stepEvent) {
-            nStepEvents++;
-            if (loggingOn) printf("step event at t=%.16g\n", time);
-        }
-
-        // event iteration in one step, ignoring intermediate results
-        fmiFlag = fmu->eventUpdate(c, fmiFalse, &eventInfo);
-        if (fmiFlag > fmiWarning) return error("could not perform event update");
-        
-        // terminate simulation, if requested by the model
-        if (eventInfo.terminateSimulation) {
-            printf("model requested termination at t=%.16g\n", time);
-            break; // success
-        }
-
-        // check for change of value of states
-        if (eventInfo.stateValuesChanged && loggingOn) {
-            printf("state values changed at t=%.16g\n", time);
-        }
-        
-        // check for selection of new state variables
-        if (eventInfo.stateValueReferencesChanged && loggingOn) {
-            printf("new state variables selected at t=%.16g\n", time);
-        }
-
-     } // if event
-     outputRow(fmu, c, time, file, separator, fmiFalse); // output values for this step
-     nSteps++;
-  } // while
-
-  // cleanup
-  if(! eventInfo.terminateSimulation) fmu->terminate(c);
-  fmu->freeModelInstance(c);
-  fclose(file);
-  if (x!=NULL) free(x);
-  if (xdot!= NULL) free(xdot);
-  if (z!= NULL) free(z);
-  if (prez!= NULL) free(prez);
-
-  // print simulation summary 
-  printf("Simulation from %g to %g terminated successful\n", t0, tEnd);
-  printf("  steps ............ %d\n", nSteps);
-  printf("  fixed step size .. %g\n", h);
-  printf("  time events ...... %d\n", nTimeEvents);
-  printf("  state events ..... %d\n", nStateEvents);
-  printf("  step events ...... %d\n", nStepEvents);
-
-  return 1; // success
-}
-
-int main(int argc, char *argv[]) {
-    const char* fmuFileName;
-
-    // parse command line arguments and load the FMU
-    double tEnd = 1.0;
-    double h=0.1;
-    int loggingOn = 0;
-    char csv_separator = ',';
-    parseArguments(argc, argv, &fmuFileName, &tEnd, &h, &loggingOn, &csv_separator);
-    loadFMU(fmuFileName);
-
-    // run the simulation
-    printf("FMU Simulator: run '%s' from t=0..%g with step size h=%g, loggingOn=%d, csv separator='%c'\n",
-            fmuFileName, tEnd, h, loggingOn, csv_separator);
-    simulate(&fmu, tEnd, h, loggingOn, csv_separator);
-    printf("CSV file '%s' written\n", RESULT_FILE);
-
-    // release FMU 
-    FreeLibrary(fmu.dllHandle);
-    freeElement(fmu.modelDescription);
-    deleteUnzippedFiles();
-    return EXIT_SUCCESS;
-}

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/model_exchange/include/fmiModelFunctions.h

@@ -1,206 +0,0 @@
-#ifndef fmiModelFunctions_h
-#define fmiModelFunctions_h
-
-/* This header file must be utilized when compiling a model.
-   It defines all functions of the Model Execution Interface.
-   In order to have unique function names even if several models
-   are compiled together (e.g. for embedded systems), every "real" function name
-   is constructed by prepending the function name by
-   "MODEL_IDENTIFIER" + "_" where "MODEL_IDENTIFIER" is the short name
-   of the model used as the name of the zip-file where the model is stored.
-   Therefore, the typical usage is:
-
-      #define MODEL_IDENTIFIER MyModel
-      #include "fmiModelFunctions.h"
-
-   As a result, a function that is defined as "fmiGetDerivatives" in this header file,
-   is actually getting the name "MyModel_fmiGetDerivatives".
-
-   Revisions:
-   - Jan. 20, 2010: stateValueReferencesChanged added to struct fmiEventInfo (ticket #27)
-                    (by M. Otter, DLR)
-                    Added WIN32 pragma to define the struct layout (ticket #34)
-                    (by J. Mauss, QTronic)
-   - Jan.  4, 2010: Removed argument intermediateResults from fmiInitialize
-                    Renamed macro fmiGetModelFunctionsVersion to fmiGetVersion
-                    Renamed macro fmiModelFunctionsVersion to fmiVersion
-                    Replaced fmiModel by fmiComponent in decl of fmiInstantiateModel
-                    (by J. Mauss, QTronic)
-   - Dec. 17, 2009: Changed extension "me" to "fmi" (by Martin Otter, DLR).
-   - Dez. 14, 2009: Added eventInfo to meInitialize and added
-                    meGetNominalContinuousStates (by Martin Otter, DLR)
-   - Sept. 9, 2009: Added DllExport (according to Peter Nilsson's suggestion)
-                    (by A. Junghanns, QTronic)
-   - Sept. 9, 2009: Changes according to FMI-meeting on July 21:
-                    meInquireModelTypesVersion     -> meGetModelTypesPlatform
-                    meInquireModelFunctionsVersion -> meGetModelFunctionsVersion
-                    meSetStates                    -> meSetContinuousStates
-                    meGetStates                    -> meGetContinuousStates
-                    removal of meInitializeModelClass
-                    removal of meGetTime
-                    change of arguments of meInstantiateModel
-                    change of arguments of meCompletedIntegratorStep
-                    (by Martin Otter, DLR):
-   - July 19, 2009: Added "me" as prefix to file names (by Martin Otter, DLR).
-   - March 2, 2009: Changed function definitions according to the last design
-                    meeting with additional improvements (by Martin Otter, DLR).
-   - Dec. 3 , 2008: First version by Martin Otter (DLR) and Hans Olsson (Dynasim).
-
-
-   Copyright © 2008-2009, MODELISAR consortium. All rights reserved.
-   This file is licensed by the copyright holders under the BSD License
-   (http://www.opensource.org/licenses/bsd-license.html):
-
-   ----------------------------------------------------------------------------
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-
-   - Redistributions of source code must retain the above copyright notice,
-     this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright notice,
-     this list of conditions and the following disclaimer in the documentation
-     and/or other materials provided with the distribution.
-   - Neither the name of the copyright holders nor the names of its
-     contributors may be used to endorse or promote products derived
-     from this software without specific prior written permission.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-   OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-   ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-   ----------------------------------------------------------------------------
-
-   with the extension:
-
-   You may distribute or publicly perform any modification only under the
-   terms of this license.
-*/
-
-#include "fmiModelTypes.h"
-#include <stdlib.h>
-
-/* Export fmi functions on Windows */
-#ifdef _MSC_VER
-#define DllExport __declspec( dllexport )
-#else
-#define DllExport
-#endif
-
-/* Macros to construct the real function name
-   (prepend function name by MODEL_IDENTIFIER + "_") */
-
-#define fmiPaste(a,b)     a ## b
-#define fmiPasteB(a,b)    fmiPaste(a,b)
-#define fmiFullName(name) fmiPasteB(MODEL_IDENTIFIER, name)
-
-#define fmiGetModelTypesPlatform      fmiFullName(_fmiGetModelTypesPlatform)
-#define fmiGetVersion                 fmiFullName(_fmiGetVersion)
-#define fmiInstantiateModel           fmiFullName(_fmiInstantiateModel)
-#define fmiFreeModelInstance          fmiFullName(_fmiFreeModelInstance)
-#define fmiSetDebugLogging            fmiFullName(_fmiSetDebugLogging)
-#define fmiSetTime                    fmiFullName(_fmiSetTime)
-#define fmiSetContinuousStates        fmiFullName(_fmiSetContinuousStates)
-#define fmiCompletedIntegratorStep    fmiFullName(_fmiCompletedIntegratorStep)
-#define fmiSetReal                    fmiFullName(_fmiSetReal)
-#define fmiSetInteger                 fmiFullName(_fmiSetInteger)
-#define fmiSetBoolean                 fmiFullName(_fmiSetBoolean)
-#define fmiSetString                  fmiFullName(_fmiSetString)
-#define fmiInitialize                 fmiFullName(_fmiInitialize)
-#define fmiGetDerivatives             fmiFullName(_fmiGetDerivatives)
-#define fmiGetEventIndicators         fmiFullName(_fmiGetEventIndicators)
-#define fmiGetReal                    fmiFullName(_fmiGetReal)
-#define fmiGetInteger                 fmiFullName(_fmiGetInteger)
-#define fmiGetBoolean                 fmiFullName(_fmiGetBoolean)
-#define fmiGetString                  fmiFullName(_fmiGetString)
-#define fmiEventUpdate                fmiFullName(_fmiEventUpdate)
-#define fmiGetContinuousStates        fmiFullName(_fmiGetContinuousStates)
-#define fmiGetNominalContinuousStates fmiFullName(_fmiGetNominalContinuousStates)
-#define fmiGetStateValueReferences    fmiFullName(_fmiGetStateValueReferences)
-#define fmiTerminate                  fmiFullName(_fmiTerminate)
-
-
-/* Version number */
-#define fmiVersion "1.0"
-
-/* Inquire version numbers of header files */
-   DllExport const char* fmiGetModelTypesPlatform();
-   DllExport const char* fmiGetVersion();
-
-/* make sure all compiler use the same alignment policies for structures */
-#pragma pack(push,8)
-
-/* Type definitions */
-   typedef enum  {fmiOK,
-                  fmiWarning,
-                  fmiDiscard,
-                  fmiError,
-                  fmiFatal} fmiStatus;
-
-   typedef void  (*fmiCallbackLogger)        (fmiComponent c, fmiString instanceName, fmiStatus status,
-                                              fmiString category, fmiString message, ...);
-   typedef void* (*fmiCallbackAllocateMemory)(size_t nobj, size_t size);
-   typedef void  (*fmiCallbackFreeMemory)    (void* obj);
-
-   typedef struct {
-     fmiCallbackLogger         logger;
-     fmiCallbackAllocateMemory allocateMemory;
-     fmiCallbackFreeMemory     freeMemory;
-   } fmiCallbackFunctions;
-
-   typedef struct {
-      fmiBoolean iterationConverged;
-      fmiBoolean stateValueReferencesChanged;
-      fmiBoolean stateValuesChanged;
-      fmiBoolean terminateSimulation;
-      fmiBoolean upcomingTimeEvent;
-      fmiReal    nextEventTime;
-   } fmiEventInfo;
-
-/* reset alignment policy to the one set before reading this file */
-#pragma pack(pop)
-
-/* Creation and destruction of model instances and setting debug status */
-   DllExport fmiComponent fmiInstantiateModel (fmiString            instanceName,
-                                               fmiString            GUID,
-                                               fmiCallbackFunctions functions,
-                                               fmiBoolean           loggingOn);
-   DllExport void      fmiFreeModelInstance(fmiComponent c);
-   DllExport fmiStatus fmiSetDebugLogging  (fmiComponent c, fmiBoolean loggingOn);
-
-
-/* Providing independent variables and re-initialization of caching */
-   DllExport fmiStatus fmiSetTime                (fmiComponent c, fmiReal time);
-   DllExport fmiStatus fmiSetContinuousStates    (fmiComponent c, const fmiReal x[], size_t nx);
-   DllExport fmiStatus fmiCompletedIntegratorStep(fmiComponent c, fmiBoolean* callEventUpdate);
-   DllExport fmiStatus fmiSetReal                (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiReal    value[]);
-   DllExport fmiStatus fmiSetInteger             (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiInteger value[]);
-   DllExport fmiStatus fmiSetBoolean             (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiBoolean value[]);
-   DllExport fmiStatus fmiSetString              (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiString  value[]);
-
-
-/* Evaluation of the model equations */
-   DllExport fmiStatus fmiInitialize(fmiComponent c, fmiBoolean toleranceControlled,
-                                     fmiReal relativeTolerance, fmiEventInfo* eventInfo);
-
-   DllExport fmiStatus fmiGetDerivatives    (fmiComponent c, fmiReal derivatives[]    , size_t nx);
-   DllExport fmiStatus fmiGetEventIndicators(fmiComponent c, fmiReal eventIndicators[], size_t ni);
-
-   DllExport fmiStatus fmiGetReal   (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiReal    value[]);
-   DllExport fmiStatus fmiGetInteger(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiInteger value[]);
-   DllExport fmiStatus fmiGetBoolean(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiBoolean value[]);
-   DllExport fmiStatus fmiGetString (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiString  value[]);
-
-   DllExport fmiStatus fmiEventUpdate               (fmiComponent c, fmiBoolean intermediateResults, fmiEventInfo* eventInfo);
-   DllExport fmiStatus fmiGetContinuousStates       (fmiComponent c, fmiReal states[], size_t nx);
-   DllExport fmiStatus fmiGetNominalContinuousStates(fmiComponent c, fmiReal x_nominal[], size_t nx);
-   DllExport fmiStatus fmiGetStateValueReferences   (fmiComponent c, fmiValueReference vrx[], size_t nx);
-   DllExport fmiStatus fmiTerminate                 (fmiComponent c);
-
-#endif // fmiModelFunctions_h

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/model_exchange/include/fmiModelTypes.h

@@ -1,91 +0,0 @@
-#ifndef fmiModelTypes_h
-#define fmiModelTypes_h
-
-/* Standard header file to define the argument types of the
-   functions of the Model Execution Interface.
-   This header file must be utilized both by the model and
-   by the simulation engine.
-
-   Revisions:
-   - Jan.  4, 2010: Renamed meModelTypes_h to fmiModelTypes_h (by Mauss, QTronic)
-   - Dec. 21, 2009: Changed "me" to "fmi" and "meModel" to "fmiComponent"
-                    according to meeting on Dec. 18 (by Martin Otter, DLR)
-   - Dec.  6, 2009: Added meUndefinedValueReference (by Martin Otter, DLR)
-   - Sept. 9, 2009: Changes according to FMI-meeting on July 21:
-                    Changed "version" to "platform", "standard" to "standard32",
-                    Added a precise definition of "standard32" as comment
-                    (by Martin Otter, DLR)
-   - July 19, 2009: Added "me" as prefix to file names, added meTrue/meFalse,
-                    and changed meValueReferenced from int to unsigned int
-                    (by Martin Otter, DLR).
-   - March 2, 2009: Moved enums and function pointer definitions to
-                    ModelFunctions.h (by Martin Otter, DLR).
-   - Dec. 3, 2008 : First version by Martin Otter (DLR) and
-                    Hans Olsson (Dynasim).
-
-
-   Copyright © 2008-2010, MODELISAR consortium. All rights reserved.
-   This file is licensed by the copyright holders under the BSD License
-   (http://www.opensource.org/licenses/bsd-license.html)
-
-   ----------------------------------------------------------------------------
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are met:
-
-   - Redistributions of source code must retain the above copyright notice,
-     this list of conditions and the following disclaimer.
-   - Redistributions in binary form must reproduce the above copyright notice,
-     this list of conditions and the following disclaimer in the documentation
-     and/or other materials provided with the distribution.
-   - Neither the name of the copyright holders nor the names of its
-     contributors may be used to endorse or promote products derived
-     from this software without specific prior written permission.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
-   OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
-   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-   ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-   ----------------------------------------------------------------------------
-
-   with the extension:
-
-   You may distribute or publicly perform any modification only under the
-   terms of this license.
-*/
-
-/* Platform (combination of machine, compiler, operating system) */
-#define fmiModelTypesPlatform "standard32"
-
-/* Type definitions of variables passed as arguments
-   Version "standard32" means:
-
-   fmiComponent     : 32 bit pointer
-   fmiValueReference: 32 bit
-   fmiReal          : 64 bit
-   fmiInteger       : 32 bit
-   fmiBoolean       :  8 bit
-   fmiString        : 32 bit pointer
-
-*/
-   typedef void*        fmiComponent;
-   typedef unsigned int fmiValueReference;
-   typedef double       fmiReal   ;
-   typedef int          fmiInteger;
-   typedef char         fmiBoolean;
-   typedef const char*  fmiString ;
-
-/* Values for fmiBoolean  */
-#define fmiTrue  1
-#define fmiFalse 0
-
-/* Undefined value for fmiValueReference (largest unsigned int value) */
-#define fmiUndefinedValueReference (fmiValueReference)(-1)
-
-#endif

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/bouncingBall/_main.html

@@ -1,55 +0,0 @@
-<html>
-<head>
-    <title>Documentation for bouncingBall.fmu</title>
-<style type="text/css">
-  html { font-family: Verdana, Arial, Helvetica, sans-serif; }
-  h1   { color: #000066; }
-</style>
-</head>
-<body>
-<h1>bouncingBall.fmu</h1>
-The bouncingBall implements the following equation: 
-<ul>
-<li> der(h) = v;
-<li> der(v) = -g;
-<li> when h<0 then v := -e* v
-</ul>
-with start values h=1, e=0.7, g = 9.81 and
-<ul>
-<li> h: height [m], used as state
-<li> v: velocity of ball [m/s], used as state
-<li> der(h): velocity of ball [m/s]
-<li> der(v): acceleration of ball [m/s2]
-<li> g: acceleration of gravity [m/s2], a parameter
-<li> e: a dimensionless parameter
-</ul>
-
-<br>
-<img src="plot_h.png">
-<br>
-The figure shows the solution computed with Silver 
-for height h of the ball for the start values given above.
-
-<p>
-The chain of events during simulation is as follows
-<ol>
-<li> initially h>0 and pos(0)=true </li>
-<li> continuous integration until a state event is detected, i.e.
-     until h + EPS_INDICATORS = 0.
-     At this time h < 0, the EPS_INDICATORS adds hysteresis.</li>
-<li> the simulator calls eventUpdate once which reverses the speed direction
-     v of the ball: v = -e * v, and sets pos(0)=false</li>
-<li> continuous integration until state event is detected, i.e.
-     until h - EPS_INDICATORS = 0.
-     At this time h > 0, the EPS_INDICATORS adds hysteresis.</li>
-<li> the simulator calls  eventUpdate once more which sets pos(0)=true.</li>
-<li> goto 2</li>
-</ol>
-The above description refers to the variables used 
-in file <code>bouncingBall.c</code>.
-
-<h2><a name="license">License conditions</a></h2>
-The FMU is provided by QTronic under the
-<a href="http://www.opensource.org/licenses/bsd-license.html">BSD License</a>.
-</body>
-</html>

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/bouncingBall/bouncingBall.c

@@ -1,104 +0,0 @@
-/* ---------------------------------------------------------------------------*
- * Sample implementation of an FMU - a bouncing ball. 
- * This demonstrates the use of state events and reinit of states.
- * Equations:
- *  der(h) = v;
- *  der(v) = -g;
- *  when h<0 then v := -e * v;  
- *  where
- *    h      height [m], used as state, start = 1
- *    v      velocity of ball [m/s], used as state
- *    der(h) velocity of ball [m/s] 
- *    der(v) acceleration of ball [m/s2] 
- *    g      acceleration of gravity [m/s2], a parameter, start = 9.81
- *    e      a dimensionless parameter, start = 0.7
- *
- * Copyright QTronic GmbH. All rights reserved.
- * ---------------------------------------------------------------------------*/
-
-// define class name and unique id
-#define MODEL_IDENTIFIER bouncingBall
-#define MODEL_GUID "{8c4e810f-3df3-4a00-8276-176fa3c9f003}"
-
-// define model size
-#define NUMBER_OF_REALS 6
-#define NUMBER_OF_INTEGERS 0
-#define NUMBER_OF_BOOLEANS 0
-#define NUMBER_OF_STRINGS 0
-#define NUMBER_OF_STATES 2
-#define NUMBER_OF_EVENT_INDICATORS 1
-
-// include fmu header files, typedefs and macros
-#include "fmuTemplate.h"
-
-// define all model variables and their value references
-// conventions used here:
-// - if x is a variable, then macro x_ is its variable reference
-// - the vr of a variable is its index in array  r, i, b or s
-// - if k is the vr of a real state, then k+1 is the vr of its derivative
-#define h_      0
-#define der_h_  1
-#define v_      2
-#define der_v_  3
-#define g_      4
-#define e_      5
-
-// define initial state vector as vector of value references
-#define STATES { h_, v_ }
-
-// called by fmiInstantiateModel
-// Set values for all variables that define a start value
-// Settings used unless changed by fmiSetX before fmiInitialize
-void setStartValues(ModelInstance *comp) {
-    r(h_)     =  1;
-    r(v_)     =  0;
-    r(der_v_) = -9.81;
-    r(g_)     =  9.81;
-    r(e_)     =  0.7;
-    pos(0) = r(h_) > 0;
-}
-
-// called by fmiGetReal, fmiGetContinuousStates and fmiGetDerivatives
-fmiReal getReal(ModelInstance* comp, fmiValueReference vr){
-    switch (vr) {
-        case h_     : return r(h_);
-        case der_h_ : return r(v_);
-        case v_     : return r(v_);
-        case der_v_ : return r(der_v_);
-        case g_     : return r(g_);
-        case e_     : return r(e_);
-        default: return 0;
-    }
-}
-
-// called by fmiInitialize() after setting eventInfo to defaults
-// Used to set the first time event, if any.
-void initialize(ModelInstance* comp, fmiEventInfo* eventInfo) {
-    r(der_v_) = -r(g_);
-}
-
-// offset for event indicator, adds hysteresis and prevents z=0 at restart
-#define EPS_INDICATORS 1e-14
-
-fmiReal getEventIndicator(ModelInstance* comp, int z) {
-    switch (z) {
-        case 0 : return r(h_) + (pos(0) ? EPS_INDICATORS : -EPS_INDICATORS);
-        default: return 0;
-    }
-}
-
-// Used to set the next time event, if any.
-void eventUpdate(ModelInstance* comp, fmiEventInfo* eventInfo) {
-    if (pos(0)) {
-        r(v_) = - r(e_) * r(v_);
-    }
-    pos(0) = r(h_) > 0;
-    eventInfo->iterationConverged  = fmiTrue;
-    eventInfo->stateValueReferencesChanged = fmiFalse;
-    eventInfo->stateValuesChanged  = fmiTrue;
-    eventInfo->terminateSimulation = fmiFalse;
-    eventInfo->upcomingTimeEvent   = fmiFalse;
- }
-
-// include code that implements the FMI based on the above definitions
-#include "fmuTemplate.c"

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/bouncingBall/modelDescription.xml

@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>
-<fmiModelDescription
-  fmiVersion="1.0"
-  modelName="bouncingBall"
-  modelIdentifier="bouncingBall"
-  guid="{8c4e810f-3df3-4a00-8276-176fa3c9f003}"
-  numberOfContinuousStates="2"
-  numberOfEventIndicators="1">
-<ModelVariables>
-  <ScalarVariable name="h" valueReference="0" description="height, used as state">
-     <Real start="1" fixed="true"/>
-  </ScalarVariable>
-  <ScalarVariable name="der(h)" valueReference="1" description="velocity of ball">
-     <Real/>
-  </ScalarVariable> 
-  <ScalarVariable name="v" valueReference="2" description="velocity of ball, used as state">
-     <Real/>
-  </ScalarVariable>
-  <ScalarVariable name="der(v)" valueReference="3" description="acceleration of ball">
-     <Real/>
-  </ScalarVariable>
-  <ScalarVariable name="g" valueReference="4" description="acceleration of gravity"
-                  variability="parameter">
-     <Real start="9.81" fixed="true"/>
-  </ScalarVariable>
-  <ScalarVariable name="e" valueReference="5" description="dimensionless parameter"
-                  variability="parameter">
-     <Real start="0.7" fixed="true"/>
-  </ScalarVariable>
-</ModelVariables>
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/build_fmu.bat

@@ -1,92 +0,0 @@
-@echo off 
-rem ------------------------------------------------------------
-rem This batch builds an FMU of the FMU SDK
-rem Usage: build_fmu (me|cs) <fmu_dir_name> 
-rem Copyright QTronic GmbH. All rights reserved
-rem ------------------------------------------------------------
-
-setlocal
-
-echo -----------------------------------------------------------
-if %1==cs (^
-echo building FMU %2 - FMI for Co-Simulation 1.0) else ^
-echo building FMU %2 - FMI for Model Exchange 1.0
-
-rem save env variable settings
-set PREV_PATH=%PATH%
-if defined INCLUDE set PREV_INCLUDE=%INLUDE%
-if defined LIB     set PREV_LIB=%LIB%
-if defined LIBPATH set PREV_LIBPATH=%LIBPATH%
-
-if "%3"=="-win64" (set x64=x64\) else set x64=
-
-rem setup the compiler
-if defined x64 (
-if defined VS110COMNTOOLS (call "%VS110COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64) else ^
-if defined VS100COMNTOOLS (call "%VS100COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64) else ^
-if defined VS90COMNTOOLS (call "%VS90COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64) else ^
-if defined VS80COMNTOOLS (call "%VS80COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64) else ^
-goto noCompiler
-) else (
-if defined VS110COMNTOOLS (call "%VS110COMNTOOLS%\vsvars32.bat") else ^
-if defined VS100COMNTOOLS (call "%VS100COMNTOOLS%\vsvars32.bat") else ^
-if defined VS90COMNTOOLS (call "%VS90COMNTOOLS%\vsvars32.bat") else ^
-if defined VS80COMNTOOLS (call "%VS80COMNTOOLS%\vsvars32.bat") else ^
-goto noCompiler
-)
-
-rem create the %2.dll in the temp dir
-if not exist temp mkdir temp 
-pushd temp
-if exist *.dll del /Q *.dll
-
-if %1==cs (set FMI_DIR=co_simulation) else set FMI_DIR=model_exchange
-if %1==cs (set DEF=/DFMI_COSIMULATION) else set DEF=
-cl /LD /nologo %DEF% ..\%2\%2.c /I ..\. /I ..\..\%FMI_DIR%\include
-if not exist %2.dll goto compileError
-
-rem create FMU dir structure with root 'fmu'
-if defined x64 (set BIN_DIR=fmu\binaries\win64) else set BIN_DIR=fmu\binaries\win32
-set SRC_DIR=fmu\sources
-set DOC_DIR=fmu\documentation
-if not exist %BIN_DIR% mkdir %BIN_DIR%
-if not exist %SRC_DIR% mkdir %SRC_DIR%
-if not exist %DOC_DIR% mkdir %DOC_DIR%
-move /Y %2.dll %BIN_DIR%
-if exist ..\%2\*~ del /Q ..\%2\*~
-copy ..\%2\%2.c %SRC_DIR%
-type ..\%2\modelDescription.xml ..\%1.xml > fmu\modelDescription.xml
-copy ..\%2\model.png fmu
-copy ..\fmuTemplate.c %SRC_DIR%
-copy ..\fmuTemplate.h %SRC_DIR%
-copy ..\%2\*.html %DOC_DIR%
-copy ..\%2\*.png  %DOC_DIR%
-del %DOC_DIR%\model.png
-
-rem zip the directory tree and move to fmu directory 
-cd fmu
-set FMU_FILE=..\..\..\..\fmu\%1\%x64%%2.fmu
-if exist %FMU_FILE% del %FMU_FILE%
-..\..\..\..\..\bin\7z.exe a -tzip -xr!.svn %FMU_FILE% ^
-  modelDescription.xml model.png binaries sources documentation
-goto cleanup
-
-:noCompiler
-echo No Microsoft Visual C compiler found
-exit
-
-:compileError
-echo build of %2 failed
-
-:cleanup
-popd
-if exist temp rmdir /S /Q temp
-
-rem undo variable settings performed by vsvars32.bat
-set PATH=%PREV_PATH%
-if defined PREV_INCLUDE set INCLUDE=%PREV_INLUDE%
-if defined PREV_LIB     set LIB=%PREV_LIB%
-if defined PREV_LIBPATH set LIBPATH=%PREV_LIBPATH%
-echo done.
-
-endlocal

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/cs.xml

@@ -1,8 +0,0 @@
-<Implementation>
-  <CoSimulation_StandAlone>
-    <Capabilities
-      canHandleVariableCommunicationStepSize="true"
-      canHandleEvents="true"/>
-  </CoSimulation_StandAlone>
-</Implementation>
-</fmiModelDescription>

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/dq/_main.html

@@ -1,33 +0,0 @@
-<html>
-<head>
-<title>Documentation for dq.fmu</title>
-<style type="text/css">
-  html { font-family: Verdana, Arial, Helvetica, sans-serif; }
-  h1   { color: #000066; }
-</style>
-</head>
-<body>
-<h1>dq.fmu</h1>
-This FMU implements the equation 
-<ul>
-<li> der(x) = -k * x </li>
-</ul>
-The analytical solution of this system is 
-<ul>
-<li> x(t) = exp(-k*t) </li>
-</ul>
-The above equation is also known as 
-<a href="http://en.wikipedia.org/wiki/Germund_Dahlquist" target="_blank">Dahlquist</a> 
-test equation.
-<br/>
-<img src="plot_x.png">
-<br/>
-The figure shows the solution for x computed with Silver 
-for start values k = 1 and x = 1.
-
-<h2><a name="license">License conditions</a></h2>
-The FMU is provided by QTronic under the
-<a href="http://www.opensource.org/licenses/bsd-license.html">BSD License</a>.
-</body>
-</html>
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/dq/dq.c

@@ -1,64 +0,0 @@
-/* ---------------------------------------------------------------------------*
- * Sample implementation of an FMU - the Dahlquist test equation.
- *
- *   der(x) = - k * x and x(0) = 1. 
- *   Analytical solution: x(t) = exp(-k*t).
- * Copyright QTronic GmbH. All rights reserved.
- * ---------------------------------------------------------------------------*/
-
-// define class name and unique id
-#define MODEL_IDENTIFIER dq
-#define MODEL_GUID "{8c4e810f-3df3-4a00-8276-176fa3c9f000}"
-
-// define model size
-#define NUMBER_OF_REALS 3
-#define NUMBER_OF_INTEGERS 0
-#define NUMBER_OF_BOOLEANS 0
-#define NUMBER_OF_STRINGS 0
-#define NUMBER_OF_STATES 1
-#define NUMBER_OF_EVENT_INDICATORS 0
-
-// include fmu header files, typedefs and macros
-#include "fmuTemplate.h"
-
-// define all model variables and their value references
-// conventions used here:
-// - if x is a variable, then macro x_ is its variable reference
-// - the vr of a variable is its index in array  r, i, b or s
-// - if k is the vr of a real state, then k+1 is the vr of its derivative
-#define x_     0
-#define der_x_ 1
-#define k_     2
-
-// define state vector as vector of value references
-#define STATES { x_ }
-
-// called by fmiInstantiateModel
-// Set values for all variables that define a start value
-// Settings used unless changed by fmiSetX before fmiInitialize
-void setStartValues(ModelInstance *comp) {
-    r(x_) = 1;
-    r(k_) = 1;
-}
-
-// called by fmiInitialize() after setting eventInfo to defaults
-// Used to set the first time event, if any.
-void initialize(ModelInstance* comp, fmiEventInfo* eventInfo) {
-}
-
-// called by fmiGetReal, fmiGetContinuousStates and fmiGetDerivatives
-fmiReal getReal(ModelInstance* comp, fmiValueReference vr){
-    switch (vr) {
-        case x_     : return r(x_);
-        case der_x_ : return - r(k_) * r(x_);
-        case k_     : return r(k_);
-        default: return 0;
-    }
-}
-
-// Used to set the next time event, if any.
-void eventUpdate(fmiComponent comp, fmiEventInfo* eventInfo) {
-} 
-
-// include code that implements the FMI based on the above definitions
-#include "fmuTemplate.c"

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/dq/modelDescription.xml

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>
-<fmiModelDescription
-  fmiVersion="1.0"
-  modelName="dq"
-  modelIdentifier="dq"
-  guid="{8c4e810f-3df3-4a00-8276-176fa3c9f000}"
-  numberOfContinuousStates="1"
-  numberOfEventIndicators="0">
-<ModelVariables>
-  <ScalarVariable name="x" valueReference="0" description="the only state">
-     <Real start="1" fixed="true"/>
-  </ScalarVariable>
-  <ScalarVariable name="der(x)" valueReference="1">
-     <Real/>
-  </ScalarVariable> 
-  <ScalarVariable name="k" valueReference="2" variability="parameter">
-     <Real start="1" fixed="true"/>
-  </ScalarVariable>
-</ModelVariables>
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/fmuTemplate.c

@@ -1,792 +0,0 @@
-/* ---------------------------------------------------------------------------*
- * Implementation of the FMI interface based on functions and macros to
- * be defined by the includer of this file. 
- * If FMI_COSIMULATION is defined, this implements "FMI for Co-Simulation 1.0",
- * otherwise "FMI for Model Exchange 1.0".
- * The "FMI for Co-Simulation 1.0", implementation assumes that exactly the 
- * following capability flags are set to fmiTrue:
- *    canHandleVariableCommunicationStepSize, i.e. fmiDoStep step size can vary
- *    canHandleEvents, i.e. fmiDoStep step size can be zero
- * and all other capability flags are set to default, i.e. to fmiFalse or 0.
- *
- * Revision history
- *  07.02.2010 initial version for "Model Exchange 1.0" released in FMU SDK 1.0
- *  05.03.2010 bug fix: fmiSetString now copies the passed string argument
- *     and fmiFreeModelInstance frees all string copies
- *  11.12.2010 replaced calloc by functions.allocateMemory in fmiInstantiateModel
- *  04.08.2011 added support for "FMI for Co-Simulation 1.0"
- *  02.08.2013 fixed a bug in instantiateModel reported by Markus Ende, TH Nuernberg
- *  02.04.2014 better time event handling
- *  02.06.2014 copy instanceName and GUID at instantiation
- *
- * Copyright QTronic GmbH. All rights reserved.
- * ---------------------------------------------------------------------------*/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// array of value references of states
-#if NUMBER_OF_STATES>0
-fmiValueReference vrStates[NUMBER_OF_STATES] = STATES; 
-#endif
-
-// ---------------------------------------------------------------------------
-// Private helpers used below to validate function arguments
-// ---------------------------------------------------------------------------
-
-static fmiBoolean invalidNumber(ModelInstance* comp, const char* f, const char* arg, int n, int nExpected){
-    if (n != nExpected) {
-        comp->state = modelError;
-        comp->functions.logger(comp, comp->instanceName, fmiError, "error", 
-                "%s: Invalid argument %s = %d. Expected %d.", f, arg, n, nExpected);
-        return fmiTrue;
-    }
-    return fmiFalse;
-}
-
-static fmiBoolean invalidState(ModelInstance* comp, const char* f, int statesExpected){
-    if (!comp) 
-        return fmiTrue;
-    if (!(comp->state & statesExpected)) {
-        comp->state = modelError;
-        comp->functions.logger(comp, comp->instanceName, fmiError, "error",
-                "%s: Illegal call sequence.", f);
-        return fmiTrue;
-    }
-    return fmiFalse;
-}
-
-static fmiBoolean nullPointer(ModelInstance* comp, const char* f, const char* arg, const void* p){
-    if (!p) {
-        comp->state = modelError;
-        comp->functions.logger(comp, comp->instanceName, fmiError, "error",
-                "%s: Invalid argument %s = NULL.", f, arg);
-        return fmiTrue;
-    }
-    return fmiFalse;
-}
-
-static fmiBoolean vrOutOfRange(ModelInstance* comp, const char* f, fmiValueReference vr, int end) {
-    if (vr >= end) {
-        comp->functions.logger(comp, comp->instanceName, fmiError, "error",
-                "%s: Illegal value reference %u.", f, vr);
-        comp->state = modelError;
-        return fmiTrue;
-    }
-    return fmiFalse;
-}  
-
-// ---------------------------------------------------------------------------
-// Private helpers used below to implement functions
-// ---------------------------------------------------------------------------
-
-fmiStatus setString(fmiComponent comp, fmiValueReference vr, fmiString value){
-    return fmiSetString(comp, &vr, 1, &value);
-}
-
-// fname is fmiInstantiateModel or fmiInstantiateSlave
-static fmiComponent instantiateModel(char* fname, fmiString instanceName, fmiString GUID,
-        fmiCallbackFunctions functions, fmiBoolean loggingOn) {
-    ModelInstance* comp;
-    if (!functions.logger) 
-        return NULL; // we cannot even log this problem
-    if (!instanceName || strlen(instanceName)==0) { 
-        functions.logger(NULL, "?", fmiError, "error",
-                "%s: Missing instance name.", fname);
-        return NULL;
-    }
-    if (!GUID || strlen(GUID)==0) {
-        functions.logger(NULL, instanceName, fmiError, "error",
-                "%s: Missing GUID.", fname);
-        return NULL;
-    }
-    if (!functions.allocateMemory || !functions.freeMemory){
-        functions.logger(NULL, instanceName, fmiError, "error",
-                "%s: Missing callback function.", fname);
-        return NULL;
-    }
-    if (strcmp(GUID, MODEL_GUID)) {
-        functions.logger(NULL, instanceName, fmiError, "error",
-                "%s: Wrong GUID %s. Expected %s.", fname, GUID, MODEL_GUID);
-        return NULL;
-    }
-    comp = (ModelInstance *)functions.allocateMemory(1, sizeof(ModelInstance));
-    if (comp) {
-        comp->r = (fmiReal *)functions.allocateMemory(NUMBER_OF_REALS,    sizeof(fmiReal));
-        comp->i = (fmiInteger *)functions.allocateMemory(NUMBER_OF_INTEGERS, sizeof(fmiInteger));
-        comp->b = (fmiBoolean *)functions.allocateMemory(NUMBER_OF_BOOLEANS, sizeof(fmiBoolean));
-        comp->s = (fmiString *)functions.allocateMemory(NUMBER_OF_STRINGS,  sizeof(fmiString));
-        comp->isPositive = (fmiBoolean *)functions.allocateMemory(NUMBER_OF_EVENT_INDICATORS, sizeof(fmiBoolean));
-        comp->instanceName = (char *)functions.allocateMemory(1 + strlen(instanceName), sizeof(char));
-        comp->GUID = (char *)functions.allocateMemory(1 + strlen(GUID), sizeof(char));
-    }
-    if (!comp || !comp->r || !comp->i || !comp->b || !comp->s || !comp->isPositive
-        || !comp->instanceName || !comp->GUID) {
-        functions.logger(NULL, instanceName, fmiError, "error",
-                "%s: Out of memory.", fname);
-        return NULL;
-    }
-    if (loggingOn) functions.logger(NULL, instanceName, fmiOK, "log",
-            "%s: GUID=%s", fname, GUID);
-
-    strcpy((char *)comp->instanceName, (char *)instanceName);
-    strcpy((char *)comp->GUID, (char *)GUID);
-    comp->functions = functions;
-    comp->loggingOn = loggingOn;
-    comp->state = modelInstantiated;
-    setStartValues(comp); // to be implemented by the includer of this file
-    return comp;
-}
-
-// fname is fmiInitialize or fmiInitializeSlave
-static fmiStatus init(char* fname, fmiComponent c, fmiBoolean toleranceControlled, fmiReal relativeTolerance,
-    fmiEventInfo* eventInfo) {
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, fname, modelInstantiated))
-         return fmiError;
-    if (nullPointer(comp, fname, "eventInfo", eventInfo))
-         return fmiError;
-    if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log", 
-        "%s: toleranceControlled=%d relativeTolerance=%g", 
-        fname, toleranceControlled, relativeTolerance);
-    eventInfo->iterationConverged  = fmiTrue;
-    eventInfo->stateValueReferencesChanged = fmiFalse;
-    eventInfo->stateValuesChanged  = fmiFalse;
-    eventInfo->terminateSimulation = fmiFalse;
-    eventInfo->upcomingTimeEvent   = fmiFalse;
-    initialize(comp, eventInfo); // to be implemented by the includer of this file
-    comp->state = modelInitialized;
-    return fmiOK;
-}
-
-// fname is fmiTerminate or fmiTerminateSlave
-static fmiStatus terminate(char* fname, fmiComponent c){
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, fname, modelInitialized))
-         return fmiError;
-    if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log", fname);
-    comp->state = modelTerminated;
-    return fmiOK;
-}
-
-// fname is freeModelInstance of freeSlaveInstance
-void freeInstance(char* fname, fmiComponent c) {
-    ModelInstance* comp = (ModelInstance *)c;
-    if (!comp) return;
-    if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log", fname);
-    if (comp->r) comp->functions.freeMemory(comp->r);
-    if (comp->i) comp->functions.freeMemory(comp->i);
-    if (comp->b) comp->functions.freeMemory(comp->b);
-    if (comp->s) {
-        int i;
-        for (i=0; i<NUMBER_OF_STRINGS; i++){
-            if (comp->s[i]) comp->functions.freeMemory((void *)comp->s[i]);
-        }
-        comp->functions.freeMemory((void *)comp->s);
-    }
-    if (comp->isPositive) comp->functions.freeMemory(comp->isPositive);
-    if (comp->instanceName) comp->functions.freeMemory((void *)comp->instanceName);
-    if (comp->GUID) comp->functions.freeMemory((void *)comp->GUID);
-    comp->functions.freeMemory(comp);
-}
-
-// ---------------------------------------------------------------------------
-// FMI functions: class methods not depending of a specific model instance
-// ---------------------------------------------------------------------------
-
-const char* fmiGetVersion() {
-    return fmiVersion;
-}
-
-// ---------------------------------------------------------------------------
-// FMI functions: for FMI Model Exchange 1.0 and for FMI Co-Simulation 1.0
-// logging control, setters and getters for Real, Integer, Boolean, String
-// ---------------------------------------------------------------------------
-
-fmiStatus fmiSetDebugLogging(fmiComponent c, fmiBoolean loggingOn) {
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiSetDebugLogging", not_modelError))
-         return fmiError;
-    if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-            "fmiSetDebugLogging: loggingOn=%d", loggingOn);
-    comp->loggingOn = loggingOn;
-    return fmiOK;
-}
-
-fmiStatus fmiSetReal(fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiReal value[]){
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiSetReal", modelInstantiated|modelInitialized))
-         return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiSetReal", "vr[]", vr))
-         return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiSetReal", "value[]", value))
-         return fmiError;
-    if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-            "fmiSetReal: nvr = %d", nvr);
-    // no check whether setting the value is allowed in the current state
-    for (i=0; i<nvr; i++) {
-       if (vrOutOfRange(comp, "fmiSetReal", vr[i], NUMBER_OF_REALS))
-           return fmiError;
-       if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-            "fmiSetReal: #r%d# = %.16g", vr[i], value[i]);
-       comp->r[vr[i]] = value[i];
-    }
-    return fmiOK;
-}
-
-fmiStatus fmiSetInteger(fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiInteger value[]){
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiSetInteger", modelInstantiated|modelInitialized))
-         return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiSetInteger", "vr[]", vr))
-         return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiSetInteger", "value[]", value))
-         return fmiError;
-    if (comp->loggingOn)
-        comp->functions.logger(c, comp->instanceName, fmiOK, "log", "fmiSetInteger: nvr = %d",  nvr);
-    for (i=0; i<nvr; i++) {
-       if (vrOutOfRange(comp, "fmiSetInteger", vr[i], NUMBER_OF_INTEGERS))
-           return fmiError;
-       if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-            "fmiSetInteger: #i%d# = %d", vr[i], value[i]);
-        comp->i[vr[i]] = value[i]; 
-    }
-    return fmiOK;
-}
-
-fmiStatus fmiSetBoolean(fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiBoolean value[]){
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiSetBoolean", modelInstantiated|modelInitialized))
-         return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiSetBoolean", "vr[]", vr))
-         return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiSetBoolean", "value[]", value))
-         return fmiError;
-    if (comp->loggingOn)
-        comp->functions.logger(c, comp->instanceName, fmiOK, "log", "fmiSetBoolean: nvr = %d",  nvr);
-    for (i=0; i<nvr; i++) {
-        if (vrOutOfRange(comp, "fmiSetBoolean", vr[i], NUMBER_OF_BOOLEANS))
-            return fmiError;
-       if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-            "fmiSetBoolean: #b%d# = %s", vr[i], value[i] ? "true" : "false");
-        comp->b[vr[i]] = value[i]; 
-    }
-    return fmiOK;
-}
-
-fmiStatus fmiSetString(fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiString value[]){
-    int i, n;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiSetString", modelInstantiated|modelInitialized))
-         return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiSetString", "vr[]", vr))
-         return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiSetString", "value[]", value))
-         return fmiError;
-    if (comp->loggingOn)
-        comp->functions.logger(c, comp->instanceName, fmiOK, "log", "fmiSetString: nvr = %d",  nvr);
-    for (i=0; i<nvr; i++) {
-        char *string = (char *)comp->s[vr[i]];
-        if (vrOutOfRange(comp, "fmiSetString", vr[i], NUMBER_OF_STRINGS))
-            return fmiError;
-        if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-            "fmiSetString: #s%d# = '%s'", vr[i], value[i]);
-        if (value[i] == NULL) {
-            if (string) comp->functions.freeMemory(string);
-            comp->s[vr[i]] = NULL;
-            comp->functions.logger(comp, comp->instanceName, fmiWarning, "warning",
-                            "fmiSetString: string argument value[%d] = NULL.", i);
-        } else {
-            if (string==NULL || strlen(string) < strlen(value[i])) {
-                if (string) comp->functions.freeMemory(string);
-                comp->s[vr[i]] = (char *)comp->functions.allocateMemory(1+strlen(value[i]), sizeof(char));
-                if (!comp->s[vr[i]]) {
-                    comp->state = modelError;
-                    comp->functions.logger(NULL, comp->instanceName, fmiError, "error", "fmiSetString: Out of memory.");
-                    return fmiError;
-                }
-            }
-            strcpy((char *)comp->s[vr[i]], (char *)value[i]);
-        }
-    }
-    return fmiOK;
-}
-
-fmiStatus fmiGetReal(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiReal value[]) {
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiGetReal", not_modelError))
-        return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiGetReal", "vr[]", vr))
-         return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiGetReal", "value[]", value))
-         return fmiError;
-#if NUMBER_OF_REALS>0
-    for (i=0; i<nvr; i++) {
-        if (vrOutOfRange(comp, "fmiGetReal", vr[i], NUMBER_OF_REALS))
-            return fmiError;
-        value[i] = getReal(comp, vr[i]); // to be implemented by the includer of this file
-        if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-                "fmiGetReal: #r%u# = %.16g", vr[i], value[i]);
-    }
-#endif
-    return fmiOK;
-}
-
-fmiStatus fmiGetInteger(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiInteger value[]) {
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiGetInteger", not_modelError))
-        return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiGetInteger", "vr[]", vr))
-         return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiGetInteger", "value[]", value))
-         return fmiError;
-    for (i=0; i<nvr; i++) {
-        if (vrOutOfRange(comp, "fmiGetInteger", vr[i], NUMBER_OF_INTEGERS))
-           return fmiError;
-        value[i] = comp->i[vr[i]];
-        if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-                "fmiGetInteger: #i%u# = %d", vr[i], value[i]);
-    }
-    return fmiOK;
-}
-
-fmiStatus fmiGetBoolean(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiBoolean value[]) {
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiGetBoolean", not_modelError))
-        return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiGetBoolean", "vr[]", vr))
-         return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiGetBoolean", "value[]", value))
-         return fmiError;
-    for (i=0; i<nvr; i++) {
-        if (vrOutOfRange(comp, "fmiGetBoolean", vr[i], NUMBER_OF_BOOLEANS))
-           return fmiError;
-        value[i] = comp->b[vr[i]];
-        if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-                "fmiGetBoolean: #b%u# = %s", vr[i], value[i]? "true" : "false");
-    }
-    return fmiOK;
-}
-
-fmiStatus fmiGetString(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiString  value[]) {
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiGetString", not_modelError))
-        return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiGetString", "vr[]", vr))
-         return fmiError;
-    if (nvr>0 && nullPointer(comp, "fmiGetString", "value[]", value))
-         return fmiError;
-    for (i=0; i<nvr; i++) {
-        if (vrOutOfRange(comp, "fmiGetString", vr[i], NUMBER_OF_STRINGS))
-           return fmiError;
-        value[i] = comp->s[vr[i]];
-        if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-                "fmiGetString: #s%u# = '%s'", vr[i], value[i]);
-    }
-    return fmiOK;
-}
-
-#ifdef FMI_COSIMULATION
-// ---------------------------------------------------------------------------
-// FMI functions: only for FMI Co-Simulation 1.0
-// ---------------------------------------------------------------------------
-
-const char* fmiGetTypesPlatform() {
-    return fmiPlatform;
-}
-
-fmiComponent fmiInstantiateSlave(fmiString  instanceName, fmiString GUID,
-    fmiString fmuLocation, fmiString mimeType, fmiReal timeout, fmiBoolean visible,
-    fmiBoolean interactive, fmiCallbackFunctions functions, fmiBoolean loggingOn) {
-    // ignoring arguments: fmuLocation, mimeType, timeout, visible, interactive
-    return instantiateModel("fmiInstantiateSlave", instanceName, GUID, functions, loggingOn);
-}
-
-fmiStatus fmiInitializeSlave(fmiComponent c, fmiReal tStart, fmiBoolean StopTimeDefined, fmiReal tStop) {
-    ModelInstance* comp = (ModelInstance *)c;
-    fmiBoolean toleranceControlled = fmiFalse;
-    fmiReal relativeTolerance = 0;
-    fmiStatus flag = fmiOK;
-    comp->eventInfo.iterationConverged = 0;
-    while (flag==fmiOK && !comp->eventInfo.iterationConverged) {
-        // ignoring arguments: tStart, StopTimeDefined, tStop
-        flag = init("fmiInitializeSlave", c, toleranceControlled, relativeTolerance, &comp->eventInfo);
-    }
-    return flag;
-}
-
-fmiStatus fmiTerminateSlave(fmiComponent c) {
-    return terminate("fmiTerminateSlave", c);
-}
-
-fmiStatus fmiResetSlave(fmiComponent c) {
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiResetSlave", modelInitialized))
-         return fmiError;
-    if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log", "fmiResetSlave");
-    comp->state = modelInstantiated;
-    setStartValues(comp); // to be implemented by the includer of this file
-    return fmiOK;
-}
-
-void fmiFreeSlaveInstance(fmiComponent c) {
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiFreeSlaveInstance", modelTerminated))
-         return;
-    freeInstance("fmiFreeSlaveInstance", c);
-}
-
-fmiStatus fmiSetRealInputDerivatives(fmiComponent c, const fmiValueReference vr[], size_t nvr,
-    const fmiInteger order[], const fmiReal value[]) {
-    ModelInstance* comp = (ModelInstance *)c;
-    fmiCallbackLogger log = comp->functions.logger;
-    if (invalidState(comp, "fmiSetRealInputDerivatives", modelInitialized))
-         return fmiError;
-    if (comp->loggingOn) log(c, comp->instanceName, fmiOK, "log", "fmiSetRealInputDerivatives: nvr= %d", nvr);
-    log(c, comp->instanceName, fmiError, "warning", "fmiSetRealInputDerivatives: ignoring function call."
-      " This model cannot interpolate inputs: canInterpolateInputs=\"fmiFalse\"");
-    return fmiWarning;
-}
-
-fmiStatus fmiGetRealOutputDerivatives(fmiComponent c, const fmiValueReference vr[], size_t nvr,
-    const fmiInteger order[], fmiReal value[]) {
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    fmiCallbackLogger log = comp->functions.logger;
-    if (invalidState(comp, "fmiGetRealOutputDerivatives", modelInitialized))
-         return fmiError;
-    if (comp->loggingOn) log(c, comp->instanceName, fmiOK, "log", "fmiGetRealOutputDerivatives: nvr= %d", nvr);
-    log(c, comp->instanceName, fmiError, "warning", "fmiGetRealOutputDerivatives: ignoring function call."
-      " This model cannot compute derivatives of outputs: MaxOutputDerivativeOrder=\"0\"");
-    for (i=0; i<nvr; i++) value[i] = 0;
-    return fmiWarning;
-}
-
-fmiStatus fmiCancelStep(fmiComponent c) {
-    ModelInstance* comp = (ModelInstance *)c;
-    fmiCallbackLogger log = comp->functions.logger;
-    if (invalidState(comp, "fmiCancelStep", modelInitialized))
-         return fmiError;
-    if (comp->loggingOn) log(c, comp->instanceName, fmiOK, "log", "fmiCancelStep");
-    log(c, comp->instanceName, fmiError, "error", 
-        "fmiCancelStep: Can be called when fmiDoStep returned fmiPending."
-        " This is not the case."); 
-    return fmiError;
-}
-
-fmiStatus fmiDoStep(fmiComponent c, fmiReal currentCommunicationPoint,
-    fmiReal communicationStepSize, fmiBoolean newStep) {
-    ModelInstance* comp = (ModelInstance *)c;
-    fmiCallbackLogger log = comp->functions.logger;
-    double h = communicationStepSize / 10;
-    int k,i;
-    const int n = 10; // how many Euler steps to perform for one do step
-    double prevState[max(NUMBER_OF_STATES, 1)];
-    double prevEventIndicators[max(NUMBER_OF_EVENT_INDICATORS, 1)];
-    int stateEvent = 0;
-
-    if (invalidState(comp, "fmiDoStep", modelInitialized))
-         return fmiError;
-
-    if (comp->loggingOn) log(c, comp->instanceName, fmiOK, "log", "fmiDoStep: "
-       "currentCommunicationPoint = %g, " 
-       "communicationStepSize = %g, " 
-       "newStep = fmi%s",
-       currentCommunicationPoint, communicationStepSize, newStep ? "True" : "False");
-    
-    // Treat also case of zero step, i.e. during an event iteration
-    if (communicationStepSize == 0) {
-        return fmiOK;
-    }
-
-#if NUMBER_OF_EVENT_INDICATORS>0
-    // initialize previous event indicators with current values
-    for (i=0; i<NUMBER_OF_EVENT_INDICATORS; i++) {
-        prevEventIndicators[i] = getEventIndicator(comp, i);
-    }
-#endif
-
-    // break the step into n steps and do forward Euler.
-    comp->time = currentCommunicationPoint;
-    for (k=0; k<n; k++) {
-        comp->time += h;
-
-#if NUMBER_OF_REALS>0
-        for (i=0; i<NUMBER_OF_STATES; i++) {
-            prevState[i] = r(vrStates[i]);
-        }
-        for (i=0; i<NUMBER_OF_STATES; i++) {
-            fmiValueReference vr = vrStates[i];
-            r(vr) += h * getReal(comp, vr+1); // forward Euler step
-        }
-#endif
-
-#if NUMBER_OF_EVENT_INDICATORS>0
-        // check for state event
-        for (i=0; i<NUMBER_OF_EVENT_INDICATORS; i++) {
-            double ei = getEventIndicator(comp, i);
-            if (ei * prevEventIndicators[i] < 0) {
-                if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log", 
-                    "fmiDoStep: state event at %g, z%d crosses zero -%c-", comp->time, i, ei<0 ? '\\' : '/');
-                stateEvent++;
-            }
-            prevEventIndicators[i] = ei;
-        }
-        if (stateEvent) {
-            eventUpdate(comp, &comp->eventInfo);
-            stateEvent = 0;
-        } 
-#endif
-        // check for time event
-        if (comp->eventInfo.upcomingTimeEvent && ((comp->time - comp->eventInfo.nextEventTime) > -0.0000000001)) {
-            if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-                "fmiDoStep: time event detected at %g", comp->time);
-            eventUpdate(comp, &comp->eventInfo);
-        }
-
-        // terminate simulation, if requested by the model
-        if (comp->eventInfo.terminateSimulation) {
-            comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-              "fmiDoStep: model requested termination at t=%g", comp->time);
-            return fmiError; // enforce termination of the simulation loop
-        }
-    }
-    return fmiOK;
-}
-
-static fmiStatus getStatus(char* fname, fmiComponent c, const fmiStatusKind s) {
-    const char* statusKind[3] = {"fmiDoStepStatus","fmiPendingStatus","fmiLastSuccessfulTime"};
-    ModelInstance* comp = (ModelInstance *)c;
-    fmiCallbackLogger log = comp->functions.logger;
-    if (invalidState(comp, fname, modelInstantiated|modelInitialized))
-         return fmiError;
-    if (comp->loggingOn) log(c, comp->instanceName, fmiOK, "log", "$s: fmiStatusKind = %s", fname, statusKind[s]);
-    switch(s) {
-        case fmiDoStepStatus:  log(c, comp->instanceName, fmiError, "error",
-           "%s: Can be called with fmiDoStepStatus when fmiDoStep returned fmiPending."
-           " This is not the case.", fname);
-           break;
-        case fmiPendingStatus:  log(c, comp->instanceName, fmiError, "error", 
-           "%s: Can be called with fmiPendingStatus when fmiDoStep returned fmiPending."
-           " This is not the case.", fname); 
-           break;
-        case fmiLastSuccessfulTime:  log(c, comp->instanceName, fmiError, "error",
-           "%s: Can be called with fmiLastSuccessfulTime when fmiDoStep returned fmiDiscard."
-           " This is not the case.", fname); 
-           break;
-    }
-    return fmiError;
-}
-
-fmiStatus fmiGetStatus(fmiComponent c, const fmiStatusKind s, fmiStatus* value) {
-    return getStatus("fmiGetStatus", c, s);
-}
-
-fmiStatus fmiGetRealStatus(fmiComponent c, const fmiStatusKind s, fmiReal* value){
-    return getStatus("fmiGetRealStatus", c, s);
-}
-
-fmiStatus fmiGetIntegerStatus(fmiComponent c, const fmiStatusKind s, fmiInteger* value){
-    return getStatus("fmiGetIntegerStatus", c, s);
-}
-
-fmiStatus fmiGetBooleanStatus(fmiComponent c, const fmiStatusKind s, fmiBoolean* value){
-    return getStatus("fmiGetBooleanStatus", c, s);
-}
-
-fmiStatus fmiGetStringStatus(fmiComponent c, const fmiStatusKind s, fmiString*  value){
-    return getStatus("fmiGetStringStatus", c, s);
-}
-
-#else
-// ---------------------------------------------------------------------------
-// FMI functions: only for Model Exchange 1.0
-// ---------------------------------------------------------------------------
-
-const char* fmiGetModelTypesPlatform() {
-    return fmiModelTypesPlatform;
-}
-
-fmiComponent fmiInstantiateModel(fmiString instanceName, fmiString GUID, 
-        fmiCallbackFunctions functions, fmiBoolean loggingOn) {
-    return instantiateModel("fmiInstantiateModel", instanceName, GUID, functions, loggingOn);
-}
-
-fmiStatus fmiInitialize(fmiComponent c, fmiBoolean toleranceControlled, fmiReal relativeTolerance,
-    fmiEventInfo* eventInfo) {
-    return init("fmiInitialize", c, toleranceControlled, relativeTolerance, eventInfo);
-}
-
-fmiStatus fmiSetTime(fmiComponent c, fmiReal time) {
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiSetTime", modelInstantiated|modelInitialized))
-         return fmiError;
-    if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-            "fmiSetTime: time=%.16g", time);
-    comp->time = time;
-    return fmiOK;
-}
-
-fmiStatus fmiSetContinuousStates(fmiComponent c, const fmiReal x[], size_t nx){
-    ModelInstance* comp = (ModelInstance *)c;
-    int i;
-    if (invalidState(comp, "fmiSetContinuousStates", modelInitialized))
-         return fmiError;
-    if (invalidNumber(comp, "fmiSetContinuousStates", "nx", nx, NUMBER_OF_STATES))
-        return fmiError;
-    if (nullPointer(comp, "fmiSetContinuousStates", "x[]", x))
-         return fmiError;
-#if NUMBER_OF_REALS>0
-    for (i=0; i<nx; i++) {
-        fmiValueReference vr = vrStates[i];
-        if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-            "fmiSetContinuousStates: #r%d#=%.16g", vr, x[i]);
-        assert(vr<NUMBER_OF_REALS);
-        comp->r[vr] = x[i];
-    }
-#endif
-    return fmiOK;
-}
-
-fmiStatus fmiEventUpdate(fmiComponent c, fmiBoolean intermediateResults, fmiEventInfo* eventInfo) {
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiEventUpdate", modelInitialized))
-        return fmiError;
-    if (nullPointer(comp, "fmiEventUpdate", "eventInfo", eventInfo))
-         return fmiError;
-    if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-        "fmiEventUpdate: intermediateResults = %d", intermediateResults);
-    eventInfo->iterationConverged  = fmiTrue;
-    eventInfo->stateValueReferencesChanged = fmiFalse;
-    eventInfo->stateValuesChanged  = fmiFalse;
-    eventInfo->terminateSimulation = fmiFalse;
-    eventInfo->upcomingTimeEvent   = fmiFalse;
-    eventUpdate(comp, eventInfo); // to be implemented by the includer of this file
-    return fmiOK;
-}
-
-fmiStatus fmiCompletedIntegratorStep(fmiComponent c, fmiBoolean* callEventUpdate){
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiCompletedIntegratorStep", modelInitialized))
-         return fmiError;
-    if (nullPointer(comp, "fmiCompletedIntegratorStep", "callEventUpdate", callEventUpdate))
-         return fmiError;
-    if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-            "fmiCompletedIntegratorStep");
-    *callEventUpdate = fmiFalse;
-    return fmiOK;
-}
-
-fmiStatus fmiGetStateValueReferences(fmiComponent c, fmiValueReference vrx[], size_t nx){
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiGetStateValueReferences", not_modelError))
-        return fmiError;
-    if (invalidNumber(comp, "fmiGetStateValueReferences", "nx", nx, NUMBER_OF_STATES))
-        return fmiError;
-    if (nullPointer(comp, "fmiGetStateValueReferences", "vrx[]", vrx))
-         return fmiError;
-#if NUMBER_OF_REALS>0
-    for (i=0; i<nx; i++) {
-        vrx[i] = vrStates[i];
-        if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-            "fmiGetStateValueReferences: vrx[%d] = %d", i, vrx[i]);
-    }
-#endif
-    return fmiOK;
-}
-
-fmiStatus fmiGetContinuousStates(fmiComponent c, fmiReal states[], size_t nx){
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiGetContinuousStates", not_modelError))
-        return fmiError;
-    if (invalidNumber(comp, "fmiGetContinuousStates", "nx", nx, NUMBER_OF_STATES))
-        return fmiError;
-    if (nullPointer(comp, "fmiGetContinuousStates", "states[]", states))
-         return fmiError;
-#if NUMBER_OF_REALS>0
-    for (i=0; i<nx; i++) {
-        fmiValueReference vr = vrStates[i];
-        states[i] = getReal(comp, vr); // to be implemented by the includer of this file
-        if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-            "fmiGetContinuousStates: #r%u# = %.16g", vr, states[i]);
-    }
-#endif
-    return fmiOK;
-}
-
-fmiStatus fmiGetNominalContinuousStates(fmiComponent c, fmiReal x_nominal[], size_t nx){
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiGetNominalContinuousStates", not_modelError))
-        return fmiError;
-    if (invalidNumber(comp, "fmiGetNominalContinuousStates", "nx", nx, NUMBER_OF_STATES))
-        return fmiError;
-    if (nullPointer(comp, "fmiGetNominalContinuousStates", "x_nominal[]", x_nominal))
-         return fmiError;
-    if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-        "fmiGetNominalContinuousStates: x_nominal[0..%d] = 1.0", nx-1);
-    for (i=0; i<nx; i++) 
-        x_nominal[i] = 1;
-    return fmiOK;
-}
-
-fmiStatus fmiGetDerivatives(fmiComponent c, fmiReal derivatives[], size_t nx) {
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiGetDerivatives", not_modelError))
-         return fmiError;
-    if (invalidNumber(comp, "fmiGetDerivatives", "nx", nx, NUMBER_OF_STATES)) 
-        return fmiError;
-    if (nullPointer(comp, "fmiGetDerivatives", "derivatives[]", derivatives))
-         return fmiError;
-#if NUMBER_OF_STATES>0
-    for (i=0; i<nx; i++) {
-        fmiValueReference vr = vrStates[i] + 1;
-        derivatives[i] = getReal(comp, vr); // to be implemented by the includer of this file
-        if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log",
-            "fmiGetDerivatives: #r%d# = %.16g", vr, derivatives[i]);
-    }
-#endif
-    return fmiOK;
-}
-
-fmiStatus fmiGetEventIndicators(fmiComponent c, fmiReal eventIndicators[], size_t ni) {
-    int i;
-    ModelInstance* comp = (ModelInstance *)c;
-    if (invalidState(comp, "fmiGetEventIndicators", not_modelError))
-        return fmiError;
-    if (invalidNumber(comp, "fmiGetEventIndicators", "ni", ni, NUMBER_OF_EVENT_INDICATORS)) 
-        return fmiError;
-#if NUMBER_OF_EVENT_INDICATORS>0
-    for (i=0; i<ni; i++) {
-        eventIndicators[i] = getEventIndicator(comp, i); // to be implemented by the includer of this file
-        if (comp->loggingOn) comp->functions.logger(c, comp->instanceName, fmiOK, "log", 
-            "fmiGetEventIndicators: z%d = %.16g", i, eventIndicators[i]);
-    }
-#endif
-    return fmiOK;
-}
-
-fmiStatus fmiTerminate(fmiComponent c){
-    return terminate("fmiTerminate", c);
-}
-
-void fmiFreeModelInstance(fmiComponent c) {
-    freeInstance("fmiFreeModelInstance", c);
-}
-
-#endif // Model Exchange 1.0
-
-#ifdef __cplusplus
-} // closing brace for extern "C"
-#endif

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/fmuTemplate.h

@@ -1,60 +0,0 @@
-/* ---------------------------------------------------------------------------*
- * fmuTemplate.h
- * Definitions used in fmiModelFunctions.c and by the includer of this file
- * Copyright QTronic GmbH. All rights reserved.
- * ---------------------------------------------------------------------------*/
-
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-#include <minmax.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef FMI_COSIMULATION
-#include "fmiFunctions.h"
-#else
-#include "fmiModelFunctions.h"
-#endif
-
-// macros used to define variables
-#define  r(vr) comp->r[vr]
-#define  i(vr) comp->i[vr]
-#define  b(vr) comp->b[vr]
-#define  s(vr) comp->s[vr]
-#define pos(z) comp->isPositive[z]
-#define copy(vr, value) setString(comp, vr, value)
-
-fmiStatus setString(fmiComponent comp, fmiValueReference vr, fmiString value);
-
-#define not_modelError (modelInstantiated|modelInitialized|modelTerminated)
-
-typedef enum {
-    modelInstantiated = 1<<0,
-    modelInitialized  = 1<<1,
-    modelTerminated   = 1<<2,
-    modelError        = 1<<3
-} ModelState;
-
-typedef struct {
-    fmiReal    *r;
-    fmiInteger *i;
-    fmiBoolean *b;
-    fmiString  *s;
-    fmiBoolean *isPositive;
-    fmiReal time;
-    fmiString instanceName;
-    fmiString GUID;
-    fmiCallbackFunctions functions;
-    fmiBoolean loggingOn;
-    ModelState state;
-#ifdef FMI_COSIMULATION
-    fmiEventInfo eventInfo;
-#endif
-} ModelInstance;
-
-#ifdef __cplusplus
-} // closing brace for extern "C"
-#endif

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/inc/_main.html

@@ -1,22 +0,0 @@
-<html>
-<head>
-    <title>Documentation for inc.fmu</title>
-<style type="text/css">
-  html { font-family: Verdana, Arial, Helvetica, sans-serif; }
-  h1   { color: #000066; }
-</style>
-</head>
-<body>
-<h1>inc.fmu</h1>
-This FMU generates time events to increment an integer counter every second and terminates simulation at t=12 sec.
-<br/>    
-<img src="plot_counter.PNG">
-<br/>
-The figure shows the solution computed with Silver.
-
-<h2><a name="license">License conditions</a></h2>
-The FMU is provided by QTronic under the
-<a href="http://www.opensource.org/licenses/bsd-license.html">BSD License</a>.
-</body>
-</html>
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/inc/inc.c

@@ -1,55 +0,0 @@
-/* ---------------------------------------------------------------------------*
- * Sample implementation of an FMU - increments an int counter every second.
- * Copyright QTronic GmbH. All rights reserved.
- * ---------------------------------------------------------------------------*/
-
-// define class name and unique id
-#define MODEL_IDENTIFIER inc
-#define MODEL_GUID "{8c4e810f-3df3-4a00-8276-176fa3c9f008}"
-
-// define model size
-#define NUMBER_OF_REALS 0
-#define NUMBER_OF_INTEGERS 1
-#define NUMBER_OF_BOOLEANS 0
-#define NUMBER_OF_STRINGS 0
-#define NUMBER_OF_STATES 0
-#define NUMBER_OF_EVENT_INDICATORS 0
-
-// include fmu header files, typedefs and macros
-#include "fmuTemplate.h"
-
-// define all model variables and their value references
-// conventions used here:
-// - if x is a variable, then macro x_ is its variable reference
-// - the vr of a variable is its index in array  r, i, b or s
-// - if k is the vr of a real state, then k+1 is the vr of its derivative
-#define counter_ 0
-
-// called by fmiInstantiateModel
-// Set values for all variables that define a start value
-// Settings used unless changed by fmiSetX before fmiInitialize
-void setStartValues(ModelInstance *comp) {
-    i(counter_) = 1;
-}
-
-// called by fmiInitialize() after setting eventInfo to defaults
-// Used to set the first time event, if any.
-void initialize(ModelInstance* comp, fmiEventInfo* eventInfo) {
-    eventInfo->upcomingTimeEvent   = fmiTrue;
-    eventInfo->nextEventTime       = 1 + comp->time;
-}
-
-// called by fmiEventUpdate() after setting eventInfo to defaults
-// Used to set the next time event, if any.
-void eventUpdate(ModelInstance* comp, fmiEventInfo* eventInfo) {
-    i(counter_) += 1;
-    if (i(counter_) == 13) 
-        eventInfo->terminateSimulation = fmiTrue;
-    else {
-        eventInfo->upcomingTimeEvent   = fmiTrue;
-        eventInfo->nextEventTime       = 1 + comp->time;
-    }
-} 
-
-// include code that implements the FMI based on the above definitions
-#include "fmuTemplate.c"

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/inc/modelDescription.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>
-<fmiModelDescription
-  fmiVersion="1.0"
-  modelName="inc"
-  modelIdentifier="inc"
-  guid="{8c4e810f-3df3-4a00-8276-176fa3c9f008}"
-  numberOfContinuousStates="0"
-  numberOfEventIndicators="0">
-<ModelVariables>
-  <ScalarVariable name="counter" valueReference="0" description="counts the seconds" causality = "output">
-     <Integer start="1" fixed="true"/>
-  </ScalarVariable>
-</ModelVariables>

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/me.xml

@@ -1 +0,0 @@
-</fmiModelDescription>

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/values/_main.html

@@ -1,23 +0,0 @@
-<html>
-<head>
-    <title>Documentation for values.fmu</title>
-<style type="text/css">
-  html { font-family: Verdana, Arial, Helvetica, sans-serif; }
-  h1   { color: #000066; }
-</style>
-</head>
-<body>
-    <h1>values.fmu</h1>
-    This FMU demonstrates the use of all four scalar FMU data types 
-    and terminates simulation at t=12 sec.
-    <img src="values.PNG">
-<br>
-The figure shows the solution computed with fmusim using the command 
-<code>fmusim me fmu\me\values.fmu 12 12</code>.
-
-<h2><a name="license">License conditions</a></h2>
-The FMU is provided by QTronic under the
-<a href="http://www.opensource.org/licenses/bsd-license.html">BSD License</a>.
-</body>
-</html>
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/values/modelDescription.xml

@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>
-<fmiModelDescription
-  fmiVersion="1.0"
-  modelName="values"
-  modelIdentifier="values"
-  guid="{8c4e810f-3df3-4a00-8276-176fa3c9f004}"
-  numberOfContinuousStates="1"
-  numberOfEventIndicators="0">
-<ModelVariables>
-  <ScalarVariable name="x" valueReference="0" description="used as continuous state">
-     <Real start="1" fixed="true"/>
-  </ScalarVariable>
-  <ScalarVariable name="der(x)" valueReference="1" description="time derivative of x">
-     <Real/>
-  </ScalarVariable> 
-  <ScalarVariable name="int_in" valueReference="0" description="integer input" causality = "input">
-     <Integer start="2"/>
-  </ScalarVariable>
-  <ScalarVariable name="int_out" valueReference="1" description="index in string array 'month'" causality = "output">
-     <Integer start="0" fixed="true"/>
-  </ScalarVariable>
-  <ScalarVariable name="bool_in" valueReference="0" description="boolean input" causality = "input">
-     <Boolean start="true"/>
-  </ScalarVariable>
-  <ScalarVariable name="bool_out" valueReference="1" description="boolean output" causality = "output">
-     <Boolean/>
-  </ScalarVariable>
-  <ScalarVariable name="string_in" valueReference="0" description="string input" causality = "input">
-     <String start="QTronic"/>
-  </ScalarVariable>
-  <ScalarVariable name="string_out" valueReference="1" description="the string month[int_out]" causality = "output">
-     <String/>
-  </ScalarVariable>
-</ModelVariables>

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/values/values.c

@@ -1,84 +0,0 @@
-/* ---------------------------------------------------------------------------*
- * Sample implementation of an FMU.
- * This demonstrates the use of all FMU variable types.
- * Copyright QTronic GmbH. All rights reserved.
- * ---------------------------------------------------------------------------*/
-
-// define class name and unique id
-#define MODEL_IDENTIFIER values
-#define MODEL_GUID "{8c4e810f-3df3-4a00-8276-176fa3c9f004}"
-
-// define model size
-#define NUMBER_OF_REALS 2
-#define NUMBER_OF_INTEGERS 2
-#define NUMBER_OF_BOOLEANS 2
-#define NUMBER_OF_STRINGS 2
-#define NUMBER_OF_STATES 1
-#define NUMBER_OF_EVENT_INDICATORS 0
-
-// include fmu header files, typedefs and macros
-#include "fmuTemplate.h"
-
-// define all model variables and their value references
-// conventions used here:
-// - if x is a variable, then macro x_ is its variable reference
-// - the vr of a variable is its index in array  r, i, b or s
-// - if k is the vr of a real state, then k+1 is the vr of its derivative
-#define x_          0
-#define der_x_      1
-#define int_in_     0
-#define int_out_    1
-#define bool_in_    0
-#define bool_out_   1
-#define string_in_  0
-#define string_out_ 1
-
-// define state vector as vector of value references
-#define STATES { x_ }
-
-const char* month[] = {
-    "jan","feb","march","april","may","june","july",
-    "august","sept","october","november","december"
-};
-
-// called by fmiInstantiateModel
-// Set values for all variables that define a start value
-// Settings used unless changed by fmiSetX before fmiInitialize
-void setStartValues(ModelInstance *comp) {
-    r(x_) = 1;
-    i(int_in_) = 2;
-    i(int_out_) = 0;
-    b(bool_in_) = fmiTrue;
-    b(bool_out_) = fmiFalse;
-    copy(string_in_, "QTronic");
-    copy(string_out_, month[0]);
-}
-
-// called by fmiInitialize() after setting eventInfo to defaults
-// Used to set the first time event, if any.
-void initialize(ModelInstance* comp, fmiEventInfo* eventInfo) {
-    eventInfo->upcomingTimeEvent   = fmiTrue;
-    eventInfo->nextEventTime       = 1 + comp->time;
-}
-
-// called by fmiGetReal, fmiGetContinuousStates and fmiGetDerivatives
-fmiReal getReal(ModelInstance* comp, fmiValueReference vr){
-    switch (vr) {
-        case x_     : return   r(x_);
-        case der_x_ : return - r(x_);
-        default: return 0;
-    }
-}
-
-// called by fmiEventUpdate() after setting eventInfo to defaults
-void eventUpdate(ModelInstance* comp, fmiEventInfo* eventInfo) {
-    eventInfo->upcomingTimeEvent   = fmiTrue;
-    eventInfo->nextEventTime       = 1 + comp->time;
-    i(int_out_) += 1;
-    b(bool_out_) = !b(bool_out_);
-    if (i(int_out_)<12) copy(string_out_, month[i(int_out_)]);
-    else eventInfo->terminateSimulation = fmiTrue;
-}
-
-// include code that implements the FMI based on the above definitions
-#include "fmuTemplate.c"

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/vanDerPol/_main.html

@@ -1,27 +0,0 @@
-<html>
-<head>
-<title>Documentation for vanDerPol.fmu</title>
-<style type="text/css">
-  html { font-family: Verdana, Arial, Helvetica, sans-serif; }
-  h1   { color: #000066; }
-</style>
-</head>
-<body>
-<h1>vanDerPol.fmu</h1>
-This FMU implements the famous
-<a href="http://en.wikipedia.org/wiki/Van_der_Pol_oscillator" target="_blank">Van der Pol oscillator</a>.
-<ul>
-<li> der(x0) = x1 </li>
-<li> der(x1) = mu * ((1 - x0 * x0) * x1) - x0</li>
-</ul>
-<img src="plot_states.png">
-<br/>
-The figure shows the solution computed with Silver 
-for start values x0 = 2, x1 = 0, mu = 1.
-
-<h2><a name="license">License conditions</a></h2>
-The FMU is provided by QTronic under the
-<a href="http://www.opensource.org/licenses/bsd-license.html">BSD License</a>.
-</body>
-</html>
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/vanDerPol/modelDescription.xml

@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>
-<fmiModelDescription
-  fmiVersion="1.0"
-  modelName="van der Pol oscillator"
-  modelIdentifier="vanDerPol"
-  guid="{8c4e810f-3da3-4a00-8276-176fa3c9f000}"
-  numberOfContinuousStates="2"
-  numberOfEventIndicators="0">
-<ModelVariables>
-  <ScalarVariable name="x0" valueReference="0" description="the first state">
-     <Real start="2" fixed="true"/>
-  </ScalarVariable>
-  <ScalarVariable name="der(x0)" valueReference="1">
-     <Real/>
-  </ScalarVariable> 
-  <ScalarVariable name="x1" valueReference="2" description="the second state">
-     <Real start="0" fixed="true"/>
-  </ScalarVariable>
-  <ScalarVariable name="der(x1)" valueReference="3">
-     <Real/>
-  </ScalarVariable> 
-  <ScalarVariable name="mu" valueReference="4" variability="parameter">
-     <Real start="1" fixed="true"/>
-  </ScalarVariable>
-</ModelVariables>

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/models/vanDerPol/vanDerPol.c

@@ -1,74 +0,0 @@
-/* ---------------------------------------------------------------------------*
- * Copyright QTronic GmbH. All rights reserved.
- * Sample implementation of an FMU - the Van der Pol oscillator.
- * See http://en.wikipedia.org/wiki/Van_der_Pol_oscillator
- *  
- *   der(x0) = x1
- *   der(x1) = mu * ((1 - x0 ^ 2) * x1) - x0;
- *
- *   start values: x0=2, x1=0, mue=1
- * ---------------------------------------------------------------------------*/
-
-// define class name and unique id
-#define MODEL_IDENTIFIER vanDerPol
-#define MODEL_GUID "{8c4e810f-3da3-4a00-8276-176fa3c9f000}"
-
-// define model size
-#define NUMBER_OF_REALS 5
-#define NUMBER_OF_INTEGERS 0
-#define NUMBER_OF_BOOLEANS 0
-#define NUMBER_OF_STRINGS 0
-#define NUMBER_OF_STATES 2
-#define NUMBER_OF_EVENT_INDICATORS 0
-
-// include fmu header files, typedefs and macros
-#include "fmuTemplate.h"
-
-// define all model variables and their value references
-// conventions used here:
-// - if x is a variable, then macro x_ is its variable reference
-// - the vr of a variable is its index in array  r, i, b or s
-// - if k is the vr of a real state, then k+1 is the vr of its derivative
-#define x0_     0
-#define der_x0_ 1
-#define x1_     2
-#define der_x1_ 3
-#define mu_     4
-
-// define state vector as vector of value references
-#define STATES { x0_, x1_ }
-
-// called by fmiInstantiateModel
-// Set values for all variables that define a start value
-// Settings used unless changed by fmiSetX before fmiInitialize
-void setStartValues(ModelInstance *comp) {
-    r(x0_) = 2;
-    r(x1_) = 0;
-    r(mu_) = 1;
-}
-
-// called by fmiInitialize() after setting eventInfo to defaults
-// Used to set the first time event, if any.
-void initialize(ModelInstance* comp, fmiEventInfo* eventInfo) {
-}
-
-// called by fmiGetReal, fmiGetContinuousStates and fmiGetDerivatives
-fmiReal getReal(ModelInstance* comp, fmiValueReference vr){
-    switch (vr) {
-        case x0_     : return r(x0_);
-        case x1_     : return r(x1_);
-        case der_x0_ : return r(x1_);
-        case der_x1_ : return r(mu_) * ((1.0-r(x0_)*r(x0_))*r(x1_)) - r(x0_);
-        case mu_     : return r(mu_);
-        default: return 0;
-    }
-}
-
-// Used to set the next time event, if any.
-void eventUpdate(fmiComponent comp, fmiEventInfo* eventInfo) {
-} 
-
-// include code that implements the FMI based on the above definitions
-#include "fmuTemplate.c"
-
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/COPYING.txt

@@ -1,24 +0,0 @@
-Files expat.h, expat_external.h and libexpatMT.lib
-
-Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
-                               and Clark Cooper
-Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Expat maintainers.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/expat_external.h

@@ -1,115 +0,0 @@
-/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
-   See the file COPYING for copying permission.
-*/
-
-#ifndef Expat_External_INCLUDED
-#define Expat_External_INCLUDED 1
-
-/* External API definitions */
-
-#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)
-#define XML_USE_MSC_EXTENSIONS 1
-#endif
-
-/* Expat tries very hard to make the API boundary very specifically
-   defined.  There are two macros defined to control this boundary;
-   each of these can be defined before including this header to
-   achieve some different behavior, but doing so it not recommended or
-   tested frequently.
-
-   XMLCALL    - The calling convention to use for all calls across the
-                "library boundary."  This will default to cdecl, and
-                try really hard to tell the compiler that's what we
-                want.
-
-   XMLIMPORT  - Whatever magic is needed to note that a function is
-                to be imported from a dynamically loaded library
-                (.dll, .so, or .sl, depending on your platform).
-
-   The XMLCALL macro was added in Expat 1.95.7.  The only one which is
-   expected to be directly useful in client code is XMLCALL.
-
-   Note that on at least some Unix versions, the Expat library must be
-   compiled with the cdecl calling convention as the default since
-   system headers may assume the cdecl convention.
-*/
-#ifndef XMLCALL
-#if defined(_MSC_VER)
-#define XMLCALL __cdecl
-#elif defined(__GNUC__) && defined(__i386) && !defined(__INTEL_COMPILER)
-#define XMLCALL __attribute__((cdecl))
-#else
-/* For any platform which uses this definition and supports more than
-   one calling convention, we need to extend this definition to
-   declare the convention used on that platform, if it's possible to
-   do so.
-
-   If this is the case for your platform, please file a bug report
-   with information on how to identify your platform via the C
-   pre-processor and how to specify the same calling convention as the
-   platform's malloc() implementation.
-*/
-#define XMLCALL
-#endif
-#endif  /* not defined XMLCALL */
-
-
-#if !defined(XML_STATIC) && !defined(XMLIMPORT)
-#ifndef XML_BUILDING_EXPAT
-/* using Expat from an application */
-
-#ifdef XML_USE_MSC_EXTENSIONS
-#define XMLIMPORT __declspec(dllimport)
-#endif
-
-#endif
-#endif  /* not defined XML_STATIC */
-
-
-/* If we didn't define it above, define it away: */
-#ifndef XMLIMPORT
-#define XMLIMPORT
-#endif
-
-
-#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef XML_UNICODE_WCHAR_T
-#define XML_UNICODE
-#endif
-
-#ifdef XML_UNICODE     /* Information is UTF-16 encoded. */
-#ifdef XML_UNICODE_WCHAR_T
-typedef wchar_t XML_Char;
-typedef wchar_t XML_LChar;
-#else
-typedef unsigned short XML_Char;
-typedef char XML_LChar;
-#endif /* XML_UNICODE_WCHAR_T */
-#else                  /* Information is UTF-8 encoded. */
-typedef char XML_Char;
-typedef char XML_LChar;
-#endif /* XML_UNICODE */
-
-#ifdef XML_LARGE_SIZE  /* Use large integers for file/stream positions. */
-#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
-typedef __int64 XML_Index; 
-typedef unsigned __int64 XML_Size;
-#else
-typedef long long XML_Index;
-typedef unsigned long long XML_Size;
-#endif
-#else
-typedef long XML_Index;
-typedef unsigned long XML_Size;
-#endif /* XML_LARGE_SIZE */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* not Expat_External_INCLUDED */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/SAX.h

@@ -1,173 +0,0 @@
-/*
- * Summary: Old SAX version 1 handler, deprecated
- * Description: DEPRECATED set of SAX version 1 interfaces used to
- *              build the DOM tree.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-
-#ifndef __XML_SAX_H__
-#define __XML_SAX_H__
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <libxml/xmlversion.h>
-#include <libxml/parser.h>
-#include <libxml/xlink.h>
-
-#ifdef LIBXML_LEGACY_ENABLED
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-XMLPUBFUN const xmlChar * XMLCALL
-		getPublicId			(void *ctx);
-XMLPUBFUN const xmlChar * XMLCALL
-		getSystemId			(void *ctx);
-XMLPUBFUN void XMLCALL
-		setDocumentLocator		(void *ctx,
-						 xmlSAXLocatorPtr loc);
-
-XMLPUBFUN int XMLCALL
-		getLineNumber			(void *ctx);
-XMLPUBFUN int XMLCALL
-		getColumnNumber			(void *ctx);
-
-XMLPUBFUN int XMLCALL
-		isStandalone			(void *ctx);
-XMLPUBFUN int XMLCALL
-		hasInternalSubset		(void *ctx);
-XMLPUBFUN int XMLCALL
-		hasExternalSubset		(void *ctx);
-
-XMLPUBFUN void XMLCALL
-		internalSubset			(void *ctx,
-						 const xmlChar *name,
-						 const xmlChar *ExternalID,
-						 const xmlChar *SystemID);
-XMLPUBFUN void XMLCALL
-		externalSubset			(void *ctx,
-						 const xmlChar *name,
-						 const xmlChar *ExternalID,
-						 const xmlChar *SystemID);
-XMLPUBFUN xmlEntityPtr XMLCALL
-		getEntity			(void *ctx,
-						 const xmlChar *name);
-XMLPUBFUN xmlEntityPtr XMLCALL
-		getParameterEntity		(void *ctx,
-						 const xmlChar *name);
-XMLPUBFUN xmlParserInputPtr XMLCALL
-		resolveEntity			(void *ctx,
-						 const xmlChar *publicId,
-						 const xmlChar *systemId);
-
-XMLPUBFUN void XMLCALL
-		entityDecl			(void *ctx,
-						 const xmlChar *name,
-						 int type,
-						 const xmlChar *publicId,
-						 const xmlChar *systemId,
-						 xmlChar *content);
-XMLPUBFUN void XMLCALL
-		attributeDecl			(void *ctx,
-						 const xmlChar *elem,
-						 const xmlChar *fullname,
-						 int type,
-						 int def,
-						 const xmlChar *defaultValue,
-						 xmlEnumerationPtr tree);
-XMLPUBFUN void XMLCALL
-		elementDecl			(void *ctx,
-						 const xmlChar *name,
-						 int type,
-						 xmlElementContentPtr content);
-XMLPUBFUN void XMLCALL
-		notationDecl			(void *ctx,
-						 const xmlChar *name,
-						 const xmlChar *publicId,
-						 const xmlChar *systemId);
-XMLPUBFUN void XMLCALL
-		unparsedEntityDecl		(void *ctx,
-						 const xmlChar *name,
-						 const xmlChar *publicId,
-						 const xmlChar *systemId,
-						 const xmlChar *notationName);
-
-XMLPUBFUN void XMLCALL
-		startDocument			(void *ctx);
-XMLPUBFUN void XMLCALL
-		endDocument			(void *ctx);
-XMLPUBFUN void XMLCALL
-		attribute			(void *ctx,
-						 const xmlChar *fullname,
-						 const xmlChar *value);
-XMLPUBFUN void XMLCALL
-		startElement			(void *ctx,
-						 const xmlChar *fullname,
-						 const xmlChar **atts);
-XMLPUBFUN void XMLCALL
-		endElement			(void *ctx,
-						 const xmlChar *name);
-XMLPUBFUN void XMLCALL
-		reference			(void *ctx,
-						 const xmlChar *name);
-XMLPUBFUN void XMLCALL
-		characters			(void *ctx,
-						 const xmlChar *ch,
-						 int len);
-XMLPUBFUN void XMLCALL
-		ignorableWhitespace		(void *ctx,
-						 const xmlChar *ch,
-						 int len);
-XMLPUBFUN void XMLCALL
-		processingInstruction		(void *ctx,
-						 const xmlChar *target,
-						 const xmlChar *data);
-XMLPUBFUN void XMLCALL
-		globalNamespace			(void *ctx,
-						 const xmlChar *href,
-						 const xmlChar *prefix);
-XMLPUBFUN void XMLCALL
-		setNamespace			(void *ctx,
-						 const xmlChar *name);
-XMLPUBFUN xmlNsPtr XMLCALL
-		getNamespace			(void *ctx);
-XMLPUBFUN int XMLCALL
-		checkNamespace			(void *ctx,
-						 xmlChar *nameSpace);
-XMLPUBFUN void XMLCALL
-		namespaceDecl			(void *ctx,
-						 const xmlChar *href,
-						 const xmlChar *prefix);
-XMLPUBFUN void XMLCALL
-		comment				(void *ctx,
-						 const xmlChar *value);
-XMLPUBFUN void XMLCALL
-		cdataBlock			(void *ctx,
-						 const xmlChar *value,
-						 int len);
-
-#ifdef LIBXML_SAX1_ENABLED
-XMLPUBFUN void XMLCALL
-		initxmlDefaultSAXHandler	(xmlSAXHandlerV1 *hdlr,
-						 int warning);
-#ifdef LIBXML_HTML_ENABLED
-XMLPUBFUN void XMLCALL
-		inithtmlDefaultSAXHandler	(xmlSAXHandlerV1 *hdlr);
-#endif
-#ifdef LIBXML_DOCB_ENABLED
-XMLPUBFUN void XMLCALL
-		initdocbDefaultSAXHandler	(xmlSAXHandlerV1 *hdlr);
-#endif
-#endif /* LIBXML_SAX1_ENABLED */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LIBXML_LEGACY_ENABLED */
-
-#endif /* __XML_SAX_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/SAX2.h

@@ -1,176 +0,0 @@
-/*
- * Summary: SAX2 parser interface used to build the DOM tree
- * Description: those are the default SAX2 interfaces used by
- *              the library when building DOM tree.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-
-#ifndef __XML_SAX2_H__
-#define __XML_SAX2_H__
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <libxml/xmlversion.h>
-#include <libxml/parser.h>
-#include <libxml/xlink.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-XMLPUBFUN const xmlChar * XMLCALL
-		xmlSAX2GetPublicId		(void *ctx);
-XMLPUBFUN const xmlChar * XMLCALL
-		xmlSAX2GetSystemId		(void *ctx);
-XMLPUBFUN void XMLCALL
-		xmlSAX2SetDocumentLocator	(void *ctx,
-						 xmlSAXLocatorPtr loc);
-
-XMLPUBFUN int XMLCALL
-		xmlSAX2GetLineNumber		(void *ctx);
-XMLPUBFUN int XMLCALL
-		xmlSAX2GetColumnNumber		(void *ctx);
-
-XMLPUBFUN int XMLCALL
-		xmlSAX2IsStandalone		(void *ctx);
-XMLPUBFUN int XMLCALL
-		xmlSAX2HasInternalSubset	(void *ctx);
-XMLPUBFUN int XMLCALL
-		xmlSAX2HasExternalSubset	(void *ctx);
-
-XMLPUBFUN void XMLCALL
-		xmlSAX2InternalSubset		(void *ctx,
-						 const xmlChar *name,
-						 const xmlChar *ExternalID,
-						 const xmlChar *SystemID);
-XMLPUBFUN void XMLCALL
-		xmlSAX2ExternalSubset		(void *ctx,
-						 const xmlChar *name,
-						 const xmlChar *ExternalID,
-						 const xmlChar *SystemID);
-XMLPUBFUN xmlEntityPtr XMLCALL
-		xmlSAX2GetEntity		(void *ctx,
-						 const xmlChar *name);
-XMLPUBFUN xmlEntityPtr XMLCALL
-		xmlSAX2GetParameterEntity	(void *ctx,
-						 const xmlChar *name);
-XMLPUBFUN xmlParserInputPtr XMLCALL
-		xmlSAX2ResolveEntity		(void *ctx,
-						 const xmlChar *publicId,
-						 const xmlChar *systemId);
-
-XMLPUBFUN void XMLCALL
-		xmlSAX2EntityDecl		(void *ctx,
-						 const xmlChar *name,
-						 int type,
-						 const xmlChar *publicId,
-						 const xmlChar *systemId,
-						 xmlChar *content);
-XMLPUBFUN void XMLCALL
-		xmlSAX2AttributeDecl		(void *ctx,
-						 const xmlChar *elem,
-						 const xmlChar *fullname,
-						 int type,
-						 int def,
-						 const xmlChar *defaultValue,
-						 xmlEnumerationPtr tree);
-XMLPUBFUN void XMLCALL
-		xmlSAX2ElementDecl		(void *ctx,
-						 const xmlChar *name,
-						 int type,
-						 xmlElementContentPtr content);
-XMLPUBFUN void XMLCALL
-		xmlSAX2NotationDecl		(void *ctx,
-						 const xmlChar *name,
-						 const xmlChar *publicId,
-						 const xmlChar *systemId);
-XMLPUBFUN void XMLCALL
-		xmlSAX2UnparsedEntityDecl	(void *ctx,
-						 const xmlChar *name,
-						 const xmlChar *publicId,
-						 const xmlChar *systemId,
-						 const xmlChar *notationName);
-
-XMLPUBFUN void XMLCALL
-		xmlSAX2StartDocument		(void *ctx);
-XMLPUBFUN void XMLCALL
-		xmlSAX2EndDocument		(void *ctx);
-#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
-XMLPUBFUN void XMLCALL
-		xmlSAX2StartElement		(void *ctx,
-						 const xmlChar *fullname,
-						 const xmlChar **atts);
-XMLPUBFUN void XMLCALL
-		xmlSAX2EndElement		(void *ctx,
-						 const xmlChar *name);
-#endif /* LIBXML_SAX1_ENABLED or LIBXML_HTML_ENABLED */
-XMLPUBFUN void XMLCALL
-		xmlSAX2StartElementNs		(void *ctx,
-						 const xmlChar *localname,
-						 const xmlChar *prefix,
-						 const xmlChar *URI,
-						 int nb_namespaces,
-						 const xmlChar **namespaces,
-						 int nb_attributes,
-						 int nb_defaulted,
-						 const xmlChar **attributes);
-XMLPUBFUN void XMLCALL
-		xmlSAX2EndElementNs		(void *ctx,
-						 const xmlChar *localname,
-						 const xmlChar *prefix,
-						 const xmlChar *URI);
-XMLPUBFUN void XMLCALL
-		xmlSAX2Reference		(void *ctx,
-						 const xmlChar *name);
-XMLPUBFUN void XMLCALL
-		xmlSAX2Characters		(void *ctx,
-						 const xmlChar *ch,
-						 int len);
-XMLPUBFUN void XMLCALL
-		xmlSAX2IgnorableWhitespace	(void *ctx,
-						 const xmlChar *ch,
-						 int len);
-XMLPUBFUN void XMLCALL
-		xmlSAX2ProcessingInstruction	(void *ctx,
-						 const xmlChar *target,
-						 const xmlChar *data);
-XMLPUBFUN void XMLCALL
-		xmlSAX2Comment			(void *ctx,
-						 const xmlChar *value);
-XMLPUBFUN void XMLCALL
-		xmlSAX2CDataBlock		(void *ctx,
-						 const xmlChar *value,
-						 int len);
-
-#ifdef LIBXML_SAX1_ENABLED
-XMLPUBFUN int XMLCALL
-		xmlSAXDefaultVersion		(int version);
-#endif /* LIBXML_SAX1_ENABLED */
-
-XMLPUBFUN int XMLCALL
-		xmlSAXVersion			(xmlSAXHandler *hdlr,
-						 int version);
-XMLPUBFUN void XMLCALL
-		xmlSAX2InitDefaultSAXHandler    (xmlSAXHandler *hdlr,
-						 int warning);
-#ifdef LIBXML_HTML_ENABLED
-XMLPUBFUN void XMLCALL
-		xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr);
-XMLPUBFUN void XMLCALL
-		htmlDefaultSAXHandlerInit	(void);
-#endif
-#ifdef LIBXML_DOCB_ENABLED
-XMLPUBFUN void XMLCALL
-		xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr);
-XMLPUBFUN void XMLCALL
-		docbDefaultSAXHandlerInit	(void);
-#endif
-XMLPUBFUN void XMLCALL
-		xmlDefaultSAXHandlerInit	(void);
-#ifdef __cplusplus
-}
-#endif
-#endif /* __XML_SAX2_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/dict.h

@@ -1,80 +0,0 @@
-/*
- * Summary: string dictionnary
- * Description: dictionary of reusable strings, just used to avoid allocation
- *         and freeing operations.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#ifndef __XML_DICT_H__
-#define __XML_DICT_H__
-
-#include <limits.h>
-#include <libxml/xmlversion.h>
-#include <libxml/tree.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * The dictionnary.
- */
-typedef struct _xmlDict xmlDict;
-typedef xmlDict *xmlDictPtr;
-
-/*
- * Initializer
- */
-XMLPUBFUN int XMLCALL  xmlInitializeDict(void);
-
-/*
- * Constructor and destructor.
- */
-XMLPUBFUN xmlDictPtr XMLCALL
-			xmlDictCreate	(void);
-XMLPUBFUN size_t XMLCALL
-			xmlDictSetLimit	(xmlDictPtr dict,
-                                         size_t limit);
-XMLPUBFUN size_t XMLCALL
-			xmlDictGetUsage (xmlDictPtr dict);
-XMLPUBFUN xmlDictPtr XMLCALL
-			xmlDictCreateSub(xmlDictPtr sub);
-XMLPUBFUN int XMLCALL
-			xmlDictReference(xmlDictPtr dict);
-XMLPUBFUN void XMLCALL
-			xmlDictFree	(xmlDictPtr dict);
-
-/*
- * Lookup of entry in the dictionnary.
- */
-XMLPUBFUN const xmlChar * XMLCALL
-			xmlDictLookup	(xmlDictPtr dict,
-		                         const xmlChar *name,
-		                         int len);
-XMLPUBFUN const xmlChar * XMLCALL
-			xmlDictExists	(xmlDictPtr dict,
-		                         const xmlChar *name,
-		                         int len);
-XMLPUBFUN const xmlChar * XMLCALL
-			xmlDictQLookup	(xmlDictPtr dict,
-		                         const xmlChar *prefix,
-		                         const xmlChar *name);
-XMLPUBFUN int XMLCALL
-			xmlDictOwns	(xmlDictPtr dict,
-					 const xmlChar *str);
-XMLPUBFUN int XMLCALL
-			xmlDictSize	(xmlDictPtr dict);
-
-/*
- * Cleanup function
- */
-XMLPUBFUN void XMLCALL
-                        xmlDictCleanup  (void);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* ! __XML_DICT_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/encoding.h

@@ -1,240 +0,0 @@
-/*
- * Summary: interface for the encoding conversion functions
- * Description: interface for the encoding conversion functions needed for
- *              XML basic encoding and iconv() support.
- *
- * Related specs are
- * rfc2044        (UTF-8 and UTF-16) F. Yergeau Alis Technologies
- * [ISO-10646]    UTF-8 and UTF-16 in Annexes
- * [ISO-8859-1]   ISO Latin-1 characters codes.
- * [UNICODE]      The Unicode Consortium, "The Unicode Standard --
- *                Worldwide Character Encoding -- Version 1.0", Addison-
- *                Wesley, Volume 1, 1991, Volume 2, 1992.  UTF-8 is
- *                described in Unicode Technical Report #4.
- * [US-ASCII]     Coded Character Set--7-bit American Standard Code for
- *                Information Interchange, ANSI X3.4-1986.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#ifndef __XML_CHAR_ENCODING_H__
-#define __XML_CHAR_ENCODING_H__
-
-#include <libxml/xmlversion.h>
-
-#ifdef LIBXML_ICONV_ENABLED
-#include <iconv.h>
-#endif
-#ifdef LIBXML_ICU_ENABLED
-#include <unicode/ucnv.h>
-#endif
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * xmlCharEncoding:
- *
- * Predefined values for some standard encodings.
- * Libxml does not do beforehand translation on UTF8 and ISOLatinX.
- * It also supports ASCII, ISO-8859-1, and UTF16 (LE and BE) by default.
- *
- * Anything else would have to be translated to UTF8 before being
- * given to the parser itself. The BOM for UTF16 and the encoding
- * declaration are looked at and a converter is looked for at that
- * point. If not found the parser stops here as asked by the XML REC. A
- * converter can be registered by the user using xmlRegisterCharEncodingHandler
- * but the current form doesn't allow stateful transcoding (a serious
- * problem agreed !). If iconv has been found it will be used
- * automatically and allow stateful transcoding, the simplest is then
- * to be sure to enable iconv and to provide iconv libs for the encoding
- * support needed.
- *
- * Note that the generic "UTF-16" is not a predefined value.  Instead, only
- * the specific UTF-16LE and UTF-16BE are present.
- */
-typedef enum {
-    XML_CHAR_ENCODING_ERROR=   -1, /* No char encoding detected */
-    XML_CHAR_ENCODING_NONE=	0, /* No char encoding detected */
-    XML_CHAR_ENCODING_UTF8=	1, /* UTF-8 */
-    XML_CHAR_ENCODING_UTF16LE=	2, /* UTF-16 little endian */
-    XML_CHAR_ENCODING_UTF16BE=	3, /* UTF-16 big endian */
-    XML_CHAR_ENCODING_UCS4LE=	4, /* UCS-4 little endian */
-    XML_CHAR_ENCODING_UCS4BE=	5, /* UCS-4 big endian */
-    XML_CHAR_ENCODING_EBCDIC=	6, /* EBCDIC uh! */
-    XML_CHAR_ENCODING_UCS4_2143=7, /* UCS-4 unusual ordering */
-    XML_CHAR_ENCODING_UCS4_3412=8, /* UCS-4 unusual ordering */
-    XML_CHAR_ENCODING_UCS2=	9, /* UCS-2 */
-    XML_CHAR_ENCODING_8859_1=	10,/* ISO-8859-1 ISO Latin 1 */
-    XML_CHAR_ENCODING_8859_2=	11,/* ISO-8859-2 ISO Latin 2 */
-    XML_CHAR_ENCODING_8859_3=	12,/* ISO-8859-3 */
-    XML_CHAR_ENCODING_8859_4=	13,/* ISO-8859-4 */
-    XML_CHAR_ENCODING_8859_5=	14,/* ISO-8859-5 */
-    XML_CHAR_ENCODING_8859_6=	15,/* ISO-8859-6 */
-    XML_CHAR_ENCODING_8859_7=	16,/* ISO-8859-7 */
-    XML_CHAR_ENCODING_8859_8=	17,/* ISO-8859-8 */
-    XML_CHAR_ENCODING_8859_9=	18,/* ISO-8859-9 */
-    XML_CHAR_ENCODING_2022_JP=  19,/* ISO-2022-JP */
-    XML_CHAR_ENCODING_SHIFT_JIS=20,/* Shift_JIS */
-    XML_CHAR_ENCODING_EUC_JP=   21,/* EUC-JP */
-    XML_CHAR_ENCODING_ASCII=    22 /* pure ASCII */
-} xmlCharEncoding;
-
-/**
- * xmlCharEncodingInputFunc:
- * @out:  a pointer to an array of bytes to store the UTF-8 result
- * @outlen:  the length of @out
- * @in:  a pointer to an array of chars in the original encoding
- * @inlen:  the length of @in
- *
- * Take a block of chars in the original encoding and try to convert
- * it to an UTF-8 block of chars out.
- *
- * Returns the number of bytes written, -1 if lack of space, or -2
- *     if the transcoding failed.
- * The value of @inlen after return is the number of octets consumed
- *     if the return value is positive, else unpredictiable.
- * The value of @outlen after return is the number of octets consumed.
- */
-typedef int (* xmlCharEncodingInputFunc)(unsigned char *out, int *outlen,
-                                         const unsigned char *in, int *inlen);
-
-
-/**
- * xmlCharEncodingOutputFunc:
- * @out:  a pointer to an array of bytes to store the result
- * @outlen:  the length of @out
- * @in:  a pointer to an array of UTF-8 chars
- * @inlen:  the length of @in
- *
- * Take a block of UTF-8 chars in and try to convert it to another
- * encoding.
- * Note: a first call designed to produce heading info is called with
- * in = NULL. If stateful this should also initialize the encoder state.
- *
- * Returns the number of bytes written, -1 if lack of space, or -2
- *     if the transcoding failed.
- * The value of @inlen after return is the number of octets consumed
- *     if the return value is positive, else unpredictiable.
- * The value of @outlen after return is the number of octets produced.
- */
-typedef int (* xmlCharEncodingOutputFunc)(unsigned char *out, int *outlen,
-                                          const unsigned char *in, int *inlen);
-
-
-/*
- * Block defining the handlers for non UTF-8 encodings.
- * If iconv is supported, there are two extra fields.
- */
-#ifdef LIBXML_ICU_ENABLED
-struct _uconv_t {
-  UConverter *uconv; /* for conversion between an encoding and UTF-16 */
-  UConverter *utf8; /* for conversion between UTF-8 and UTF-16 */
-};
-typedef struct _uconv_t uconv_t;
-#endif
-
-typedef struct _xmlCharEncodingHandler xmlCharEncodingHandler;
-typedef xmlCharEncodingHandler *xmlCharEncodingHandlerPtr;
-struct _xmlCharEncodingHandler {
-    char                       *name;
-    xmlCharEncodingInputFunc   input;
-    xmlCharEncodingOutputFunc  output;
-#ifdef LIBXML_ICONV_ENABLED
-    iconv_t                    iconv_in;
-    iconv_t                    iconv_out;
-#endif /* LIBXML_ICONV_ENABLED */
-#ifdef LIBXML_ICU_ENABLED
-    uconv_t                    *uconv_in;
-    uconv_t                    *uconv_out;
-#endif /* LIBXML_ICU_ENABLED */
-};
-
-#ifdef __cplusplus
-}
-#endif
-#include <libxml/tree.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Interfaces for encoding handlers.
- */
-XMLPUBFUN void XMLCALL
-	xmlInitCharEncodingHandlers	(void);
-XMLPUBFUN void XMLCALL
-	xmlCleanupCharEncodingHandlers	(void);
-XMLPUBFUN void XMLCALL
-	xmlRegisterCharEncodingHandler	(xmlCharEncodingHandlerPtr handler);
-XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
-	xmlGetCharEncodingHandler	(xmlCharEncoding enc);
-XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
-	xmlFindCharEncodingHandler	(const char *name);
-XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL
-	xmlNewCharEncodingHandler	(const char *name,
-					 xmlCharEncodingInputFunc input,
-					 xmlCharEncodingOutputFunc output);
-
-/*
- * Interfaces for encoding names and aliases.
- */
-XMLPUBFUN int XMLCALL
-	xmlAddEncodingAlias		(const char *name,
-					 const char *alias);
-XMLPUBFUN int XMLCALL
-	xmlDelEncodingAlias		(const char *alias);
-XMLPUBFUN const char * XMLCALL
-	xmlGetEncodingAlias		(const char *alias);
-XMLPUBFUN void XMLCALL
-	xmlCleanupEncodingAliases	(void);
-XMLPUBFUN xmlCharEncoding XMLCALL
-	xmlParseCharEncoding		(const char *name);
-XMLPUBFUN const char * XMLCALL
-	xmlGetCharEncodingName		(xmlCharEncoding enc);
-
-/*
- * Interfaces directly used by the parsers.
- */
-XMLPUBFUN xmlCharEncoding XMLCALL
-	xmlDetectCharEncoding		(const unsigned char *in,
-					 int len);
-
-XMLPUBFUN int XMLCALL
-	xmlCharEncOutFunc		(xmlCharEncodingHandler *handler,
-					 xmlBufferPtr out,
-					 xmlBufferPtr in);
-
-XMLPUBFUN int XMLCALL
-	xmlCharEncInFunc		(xmlCharEncodingHandler *handler,
-					 xmlBufferPtr out,
-					 xmlBufferPtr in);
-XMLPUBFUN int XMLCALL
-	xmlCharEncFirstLine		(xmlCharEncodingHandler *handler,
-					 xmlBufferPtr out,
-					 xmlBufferPtr in);
-XMLPUBFUN int XMLCALL
-	xmlCharEncCloseFunc		(xmlCharEncodingHandler *handler);
-
-/*
- * Export a few useful functions
- */
-#ifdef LIBXML_OUTPUT_ENABLED
-XMLPUBFUN int XMLCALL
-	UTF8Toisolat1			(unsigned char *out,
-					 int *outlen,
-					 const unsigned char *in,
-					 int *inlen);
-#endif /* LIBXML_OUTPUT_ENABLED */
-XMLPUBFUN int XMLCALL
-	isolat1ToUTF8			(unsigned char *out,
-					 int *outlen,
-					 const unsigned char *in,
-					 int *inlen);
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __XML_CHAR_ENCODING_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/entities.h

@@ -1,150 +0,0 @@
-/*
- * Summary: interface for the XML entities handling
- * Description: this module provides some of the entity API needed
- *              for the parser and applications.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#ifndef __XML_ENTITIES_H__
-#define __XML_ENTITIES_H__
-
-#include <libxml/xmlversion.h>
-#include <libxml/tree.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * The different valid entity types.
- */
-typedef enum {
-    XML_INTERNAL_GENERAL_ENTITY = 1,
-    XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2,
-    XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3,
-    XML_INTERNAL_PARAMETER_ENTITY = 4,
-    XML_EXTERNAL_PARAMETER_ENTITY = 5,
-    XML_INTERNAL_PREDEFINED_ENTITY = 6
-} xmlEntityType;
-
-/*
- * An unit of storage for an entity, contains the string, the value
- * and the linkind data needed for the linking in the hash table.
- */
-
-struct _xmlEntity {
-    void           *_private;	        /* application data */
-    xmlElementType          type;       /* XML_ENTITY_DECL, must be second ! */
-    const xmlChar          *name;	/* Entity name */
-    struct _xmlNode    *children;	/* First child link */
-    struct _xmlNode        *last;	/* Last child link */
-    struct _xmlDtd       *parent;	/* -> DTD */
-    struct _xmlNode        *next;	/* next sibling link  */
-    struct _xmlNode        *prev;	/* previous sibling link  */
-    struct _xmlDoc          *doc;       /* the containing document */
-
-    xmlChar                *orig;	/* content without ref substitution */
-    xmlChar             *content;	/* content or ndata if unparsed */
-    int                   length;	/* the content length */
-    xmlEntityType          etype;	/* The entity type */
-    const xmlChar    *ExternalID;	/* External identifier for PUBLIC */
-    const xmlChar      *SystemID;	/* URI for a SYSTEM or PUBLIC Entity */
-
-    struct _xmlEntity     *nexte;	/* unused */
-    const xmlChar           *URI;	/* the full URI as computed */
-    int                    owner;	/* does the entity own the childrens */
-    int			 checked;	/* was the entity content checked */
-					/* this is also used to count entites
-					 * references done from that entity */
-};
-
-/*
- * All entities are stored in an hash table.
- * There is 2 separate hash tables for global and parameter entities.
- */
-
-typedef struct _xmlHashTable xmlEntitiesTable;
-typedef xmlEntitiesTable *xmlEntitiesTablePtr;
-
-/*
- * External functions:
- */
-
-#ifdef LIBXML_LEGACY_ENABLED
-XMLPUBFUN void XMLCALL
-		xmlInitializePredefinedEntities	(void);
-#endif /* LIBXML_LEGACY_ENABLED */
-
-XMLPUBFUN xmlEntityPtr XMLCALL
-			xmlNewEntity		(xmlDocPtr doc,
-						 const xmlChar *name,
-						 int type,
-						 const xmlChar *ExternalID,
-						 const xmlChar *SystemID,
-						 const xmlChar *content);
-XMLPUBFUN xmlEntityPtr XMLCALL
-			xmlAddDocEntity		(xmlDocPtr doc,
-						 const xmlChar *name,
-						 int type,
-						 const xmlChar *ExternalID,
-						 const xmlChar *SystemID,
-						 const xmlChar *content);
-XMLPUBFUN xmlEntityPtr XMLCALL
-			xmlAddDtdEntity		(xmlDocPtr doc,
-						 const xmlChar *name,
-						 int type,
-						 const xmlChar *ExternalID,
-						 const xmlChar *SystemID,
-						 const xmlChar *content);
-XMLPUBFUN xmlEntityPtr XMLCALL
-			xmlGetPredefinedEntity	(const xmlChar *name);
-XMLPUBFUN xmlEntityPtr XMLCALL
-			xmlGetDocEntity		(xmlDocPtr doc,
-						 const xmlChar *name);
-XMLPUBFUN xmlEntityPtr XMLCALL
-			xmlGetDtdEntity		(xmlDocPtr doc,
-						 const xmlChar *name);
-XMLPUBFUN xmlEntityPtr XMLCALL
-			xmlGetParameterEntity	(xmlDocPtr doc,
-						 const xmlChar *name);
-#ifdef LIBXML_LEGACY_ENABLED
-XMLPUBFUN const xmlChar * XMLCALL
-			xmlEncodeEntities	(xmlDocPtr doc,
-						 const xmlChar *input);
-#endif /* LIBXML_LEGACY_ENABLED */
-XMLPUBFUN xmlChar * XMLCALL
-			xmlEncodeEntitiesReentrant(xmlDocPtr doc,
-						 const xmlChar *input);
-XMLPUBFUN xmlChar * XMLCALL
-			xmlEncodeSpecialChars	(xmlDocPtr doc,
-						 const xmlChar *input);
-XMLPUBFUN xmlEntitiesTablePtr XMLCALL
-			xmlCreateEntitiesTable	(void);
-#ifdef LIBXML_TREE_ENABLED
-XMLPUBFUN xmlEntitiesTablePtr XMLCALL
-			xmlCopyEntitiesTable	(xmlEntitiesTablePtr table);
-#endif /* LIBXML_TREE_ENABLED */
-XMLPUBFUN void XMLCALL
-			xmlFreeEntitiesTable	(xmlEntitiesTablePtr table);
-#ifdef LIBXML_OUTPUT_ENABLED
-XMLPUBFUN void XMLCALL
-			xmlDumpEntitiesTable	(xmlBufferPtr buf,
-						 xmlEntitiesTablePtr table);
-XMLPUBFUN void XMLCALL
-			xmlDumpEntityDecl	(xmlBufferPtr buf,
-						 xmlEntityPtr ent);
-#endif /* LIBXML_OUTPUT_ENABLED */
-#ifdef LIBXML_LEGACY_ENABLED
-XMLPUBFUN void XMLCALL
-			xmlCleanupPredefinedEntities(void);
-#endif /* LIBXML_LEGACY_ENABLED */
-
-
-#ifdef __cplusplus
-}
-#endif
-
-# endif /* __XML_ENTITIES_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/globals.h

@@ -1,502 +0,0 @@
-/*
- * Summary: interface for all global variables of the library
- * Description: all the global variables and thread handling for
- *              those variables is handled by this module.
- *
- * The bottom of this file is automatically generated by build_glob.py
- * based on the description file global.data
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Gary Pennington <Gary.Pennington@uk.sun.com>, Daniel Veillard
- */
-
-#ifndef __XML_GLOBALS_H
-#define __XML_GLOBALS_H
-
-#include <libxml/xmlversion.h>
-#include <libxml/parser.h>
-#include <libxml/xmlerror.h>
-#include <libxml/SAX.h>
-#include <libxml/SAX2.h>
-#include <libxml/xmlmemory.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-XMLPUBFUN void XMLCALL xmlInitGlobals(void);
-XMLPUBFUN void XMLCALL xmlCleanupGlobals(void);
-
-/**
- * xmlParserInputBufferCreateFilenameFunc:
- * @URI: the URI to read from
- * @enc: the requested source encoding
- *
- * Signature for the function doing the lookup for a suitable input method
- * corresponding to an URI.
- *
- * Returns the new xmlParserInputBufferPtr in case of success or NULL if no
- *         method was found.
- */
-typedef xmlParserInputBufferPtr (*xmlParserInputBufferCreateFilenameFunc) (const char *URI, xmlCharEncoding enc);
-
-/**
- * xmlOutputBufferCreateFilenameFunc:
- * @URI: the URI to write to
- * @enc: the requested target encoding
- *
- * Signature for the function doing the lookup for a suitable output method
- * corresponding to an URI.
- *
- * Returns the new xmlOutputBufferPtr in case of success or NULL if no
- *         method was found.
- */
-typedef xmlOutputBufferPtr (*xmlOutputBufferCreateFilenameFunc) (const char *URI, xmlCharEncodingHandlerPtr encoder, int compression);
-
-XMLPUBFUN xmlParserInputBufferCreateFilenameFunc
-XMLCALL xmlParserInputBufferCreateFilenameDefault (xmlParserInputBufferCreateFilenameFunc func);
-XMLPUBFUN xmlOutputBufferCreateFilenameFunc
-XMLCALL xmlOutputBufferCreateFilenameDefault (xmlOutputBufferCreateFilenameFunc func);
-
-/*
- * Externally global symbols which need to be protected for backwards
- * compatibility support.
- */
-
-#undef	docbDefaultSAXHandler
-#undef	htmlDefaultSAXHandler
-#undef	oldXMLWDcompatibility
-#undef	xmlBufferAllocScheme
-#undef	xmlDefaultBufferSize
-#undef	xmlDefaultSAXHandler
-#undef	xmlDefaultSAXLocator
-#undef	xmlDoValidityCheckingDefaultValue
-#undef	xmlFree
-#undef	xmlGenericError
-#undef	xmlStructuredError
-#undef	xmlGenericErrorContext
-#undef	xmlStructuredErrorContext
-#undef	xmlGetWarningsDefaultValue
-#undef	xmlIndentTreeOutput
-#undef  xmlTreeIndentString
-#undef	xmlKeepBlanksDefaultValue
-#undef	xmlLineNumbersDefaultValue
-#undef	xmlLoadExtDtdDefaultValue
-#undef	xmlMalloc
-#undef	xmlMallocAtomic
-#undef	xmlMemStrdup
-#undef	xmlParserDebugEntities
-#undef	xmlParserVersion
-#undef	xmlPedanticParserDefaultValue
-#undef	xmlRealloc
-#undef	xmlSaveNoEmptyTags
-#undef	xmlSubstituteEntitiesDefaultValue
-#undef  xmlRegisterNodeDefaultValue
-#undef  xmlDeregisterNodeDefaultValue
-#undef  xmlLastError
-#undef  xmlParserInputBufferCreateFilenameValue
-#undef  xmlOutputBufferCreateFilenameValue
-
-/**
- * xmlRegisterNodeFunc:
- * @node: the current node
- *
- * Signature for the registration callback of a created node
- */
-typedef void (*xmlRegisterNodeFunc) (xmlNodePtr node);
-/**
- * xmlDeregisterNodeFunc:
- * @node: the current node
- *
- * Signature for the deregistration callback of a discarded node
- */
-typedef void (*xmlDeregisterNodeFunc) (xmlNodePtr node);
-
-typedef struct _xmlGlobalState xmlGlobalState;
-typedef xmlGlobalState *xmlGlobalStatePtr;
-struct _xmlGlobalState
-{
-	const char *xmlParserVersion;
-
-	xmlSAXLocator xmlDefaultSAXLocator;
-	xmlSAXHandlerV1 xmlDefaultSAXHandler;
-	xmlSAXHandlerV1 docbDefaultSAXHandler;
-	xmlSAXHandlerV1 htmlDefaultSAXHandler;
-
-	xmlFreeFunc xmlFree;
-	xmlMallocFunc xmlMalloc;
-	xmlStrdupFunc xmlMemStrdup;
-	xmlReallocFunc xmlRealloc;
-
-	xmlGenericErrorFunc xmlGenericError;
-	xmlStructuredErrorFunc xmlStructuredError;
-	void *xmlGenericErrorContext;
-
-	int oldXMLWDcompatibility;
-
-	xmlBufferAllocationScheme xmlBufferAllocScheme;
-	int xmlDefaultBufferSize;
-
-	int xmlSubstituteEntitiesDefaultValue;
-	int xmlDoValidityCheckingDefaultValue;
-	int xmlGetWarningsDefaultValue;
-	int xmlKeepBlanksDefaultValue;
-	int xmlLineNumbersDefaultValue;
-	int xmlLoadExtDtdDefaultValue;
-	int xmlParserDebugEntities;
-	int xmlPedanticParserDefaultValue;
-
-	int xmlSaveNoEmptyTags;
-	int xmlIndentTreeOutput;
-	const char *xmlTreeIndentString;
-
-	xmlRegisterNodeFunc xmlRegisterNodeDefaultValue;
-	xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue;
-
-	xmlMallocFunc xmlMallocAtomic;
-	xmlError xmlLastError;
-
-	xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue;
-	xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue;
-
-	void *xmlStructuredErrorContext;
-};
-
-#ifdef __cplusplus
-}
-#endif
-#include <libxml/threads.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-XMLPUBFUN void XMLCALL	xmlInitializeGlobalState(xmlGlobalStatePtr gs);
-
-XMLPUBFUN void XMLCALL xmlThrDefSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler);
-
-XMLPUBFUN void XMLCALL xmlThrDefSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler);
-
-XMLPUBFUN xmlRegisterNodeFunc XMLCALL xmlRegisterNodeDefault(xmlRegisterNodeFunc func);
-XMLPUBFUN xmlRegisterNodeFunc XMLCALL xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func);
-XMLPUBFUN xmlDeregisterNodeFunc XMLCALL xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func);
-XMLPUBFUN xmlDeregisterNodeFunc XMLCALL xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func);
-
-XMLPUBFUN xmlOutputBufferCreateFilenameFunc XMLCALL
-	xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func);
-XMLPUBFUN xmlParserInputBufferCreateFilenameFunc XMLCALL
-	xmlThrDefParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilenameFunc func);
-
-/** DOC_DISABLE */
-/*
- * In general the memory allocation entry points are not kept
- * thread specific but this can be overridden by LIBXML_THREAD_ALLOC_ENABLED
- *    - xmlMalloc
- *    - xmlMallocAtomic
- *    - xmlRealloc
- *    - xmlMemStrdup
- *    - xmlFree
- */
-
-#ifdef LIBXML_THREAD_ALLOC_ENABLED
-#ifdef LIBXML_THREAD_ENABLED
-XMLPUBFUN  xmlMallocFunc * XMLCALL __xmlMalloc(void);
-#define xmlMalloc \
-(*(__xmlMalloc()))
-#else
-XMLPUBVAR xmlMallocFunc xmlMalloc;
-#endif
-
-#ifdef LIBXML_THREAD_ENABLED
-XMLPUBFUN  xmlMallocFunc * XMLCALL __xmlMallocAtomic(void);
-#define xmlMallocAtomic \
-(*(__xmlMallocAtomic()))
-#else
-XMLPUBVAR xmlMallocFunc xmlMallocAtomic;
-#endif
-
-#ifdef LIBXML_THREAD_ENABLED
-XMLPUBFUN  xmlReallocFunc * XMLCALL __xmlRealloc(void);
-#define xmlRealloc \
-(*(__xmlRealloc()))
-#else
-XMLPUBVAR xmlReallocFunc xmlRealloc;
-#endif
-
-#ifdef LIBXML_THREAD_ENABLED
-XMLPUBFUN  xmlFreeFunc * XMLCALL __xmlFree(void);
-#define xmlFree \
-(*(__xmlFree()))
-#else
-XMLPUBVAR xmlFreeFunc xmlFree;
-#endif
-
-#ifdef LIBXML_THREAD_ENABLED
-XMLPUBFUN  xmlStrdupFunc * XMLCALL __xmlMemStrdup(void);
-#define xmlMemStrdup \
-(*(__xmlMemStrdup()))
-#else
-XMLPUBVAR xmlStrdupFunc xmlMemStrdup;
-#endif
-
-#else /* !LIBXML_THREAD_ALLOC_ENABLED */
-XMLPUBVAR xmlMallocFunc xmlMalloc;
-XMLPUBVAR xmlMallocFunc xmlMallocAtomic;
-XMLPUBVAR xmlReallocFunc xmlRealloc;
-XMLPUBVAR xmlFreeFunc xmlFree;
-XMLPUBVAR xmlStrdupFunc xmlMemStrdup;
-#endif /* LIBXML_THREAD_ALLOC_ENABLED */
-
-#ifdef LIBXML_DOCB_ENABLED
-XMLPUBFUN  xmlSAXHandlerV1 * XMLCALL __docbDefaultSAXHandler(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define docbDefaultSAXHandler \
-(*(__docbDefaultSAXHandler()))
-#else
-XMLPUBVAR xmlSAXHandlerV1 docbDefaultSAXHandler;
-#endif
-#endif
-
-#ifdef LIBXML_HTML_ENABLED
-XMLPUBFUN xmlSAXHandlerV1 * XMLCALL __htmlDefaultSAXHandler(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define htmlDefaultSAXHandler \
-(*(__htmlDefaultSAXHandler()))
-#else
-XMLPUBVAR xmlSAXHandlerV1 htmlDefaultSAXHandler;
-#endif
-#endif
-
-XMLPUBFUN xmlError * XMLCALL __xmlLastError(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlLastError \
-(*(__xmlLastError()))
-#else
-XMLPUBVAR xmlError xmlLastError;
-#endif
-
-/*
- * Everything starting from the line below is
- * Automatically generated by build_glob.py.
- * Do not modify the previous line.
- */
-
-
-XMLPUBFUN int * XMLCALL __oldXMLWDcompatibility(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define oldXMLWDcompatibility \
-(*(__oldXMLWDcompatibility()))
-#else
-XMLPUBVAR int oldXMLWDcompatibility;
-#endif
-
-XMLPUBFUN xmlBufferAllocationScheme * XMLCALL __xmlBufferAllocScheme(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlBufferAllocScheme \
-(*(__xmlBufferAllocScheme()))
-#else
-XMLPUBVAR xmlBufferAllocationScheme xmlBufferAllocScheme;
-#endif
-XMLPUBFUN xmlBufferAllocationScheme XMLCALL xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v);
-
-XMLPUBFUN int * XMLCALL __xmlDefaultBufferSize(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlDefaultBufferSize \
-(*(__xmlDefaultBufferSize()))
-#else
-XMLPUBVAR int xmlDefaultBufferSize;
-#endif
-XMLPUBFUN int XMLCALL xmlThrDefDefaultBufferSize(int v);
-
-XMLPUBFUN xmlSAXHandlerV1 * XMLCALL __xmlDefaultSAXHandler(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlDefaultSAXHandler \
-(*(__xmlDefaultSAXHandler()))
-#else
-XMLPUBVAR xmlSAXHandlerV1 xmlDefaultSAXHandler;
-#endif
-
-XMLPUBFUN xmlSAXLocator * XMLCALL __xmlDefaultSAXLocator(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlDefaultSAXLocator \
-(*(__xmlDefaultSAXLocator()))
-#else
-XMLPUBVAR xmlSAXLocator xmlDefaultSAXLocator;
-#endif
-
-XMLPUBFUN int * XMLCALL __xmlDoValidityCheckingDefaultValue(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlDoValidityCheckingDefaultValue \
-(*(__xmlDoValidityCheckingDefaultValue()))
-#else
-XMLPUBVAR int xmlDoValidityCheckingDefaultValue;
-#endif
-XMLPUBFUN int XMLCALL xmlThrDefDoValidityCheckingDefaultValue(int v);
-
-XMLPUBFUN xmlGenericErrorFunc * XMLCALL __xmlGenericError(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlGenericError \
-(*(__xmlGenericError()))
-#else
-XMLPUBVAR xmlGenericErrorFunc xmlGenericError;
-#endif
-
-XMLPUBFUN xmlStructuredErrorFunc * XMLCALL __xmlStructuredError(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlStructuredError \
-(*(__xmlStructuredError()))
-#else
-XMLPUBVAR xmlStructuredErrorFunc xmlStructuredError;
-#endif
-
-XMLPUBFUN void * * XMLCALL __xmlGenericErrorContext(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlGenericErrorContext \
-(*(__xmlGenericErrorContext()))
-#else
-XMLPUBVAR void * xmlGenericErrorContext;
-#endif
-
-XMLPUBFUN void * * XMLCALL __xmlStructuredErrorContext(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlStructuredErrorContext \
-(*(__xmlStructuredErrorContext()))
-#else
-XMLPUBVAR void * xmlStructuredErrorContext;
-#endif
-
-XMLPUBFUN int * XMLCALL __xmlGetWarningsDefaultValue(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlGetWarningsDefaultValue \
-(*(__xmlGetWarningsDefaultValue()))
-#else
-XMLPUBVAR int xmlGetWarningsDefaultValue;
-#endif
-XMLPUBFUN int XMLCALL xmlThrDefGetWarningsDefaultValue(int v);
-
-XMLPUBFUN int * XMLCALL __xmlIndentTreeOutput(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlIndentTreeOutput \
-(*(__xmlIndentTreeOutput()))
-#else
-XMLPUBVAR int xmlIndentTreeOutput;
-#endif
-XMLPUBFUN int XMLCALL xmlThrDefIndentTreeOutput(int v);
-
-XMLPUBFUN const char * * XMLCALL __xmlTreeIndentString(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlTreeIndentString \
-(*(__xmlTreeIndentString()))
-#else
-XMLPUBVAR const char * xmlTreeIndentString;
-#endif
-XMLPUBFUN const char * XMLCALL xmlThrDefTreeIndentString(const char * v);
-
-XMLPUBFUN int * XMLCALL __xmlKeepBlanksDefaultValue(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlKeepBlanksDefaultValue \
-(*(__xmlKeepBlanksDefaultValue()))
-#else
-XMLPUBVAR int xmlKeepBlanksDefaultValue;
-#endif
-XMLPUBFUN int XMLCALL xmlThrDefKeepBlanksDefaultValue(int v);
-
-XMLPUBFUN int * XMLCALL __xmlLineNumbersDefaultValue(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlLineNumbersDefaultValue \
-(*(__xmlLineNumbersDefaultValue()))
-#else
-XMLPUBVAR int xmlLineNumbersDefaultValue;
-#endif
-XMLPUBFUN int XMLCALL xmlThrDefLineNumbersDefaultValue(int v);
-
-XMLPUBFUN int * XMLCALL __xmlLoadExtDtdDefaultValue(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlLoadExtDtdDefaultValue \
-(*(__xmlLoadExtDtdDefaultValue()))
-#else
-XMLPUBVAR int xmlLoadExtDtdDefaultValue;
-#endif
-XMLPUBFUN int XMLCALL xmlThrDefLoadExtDtdDefaultValue(int v);
-
-XMLPUBFUN int * XMLCALL __xmlParserDebugEntities(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlParserDebugEntities \
-(*(__xmlParserDebugEntities()))
-#else
-XMLPUBVAR int xmlParserDebugEntities;
-#endif
-XMLPUBFUN int XMLCALL xmlThrDefParserDebugEntities(int v);
-
-XMLPUBFUN const char * * XMLCALL __xmlParserVersion(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlParserVersion \
-(*(__xmlParserVersion()))
-#else
-XMLPUBVAR const char * xmlParserVersion;
-#endif
-
-XMLPUBFUN int * XMLCALL __xmlPedanticParserDefaultValue(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlPedanticParserDefaultValue \
-(*(__xmlPedanticParserDefaultValue()))
-#else
-XMLPUBVAR int xmlPedanticParserDefaultValue;
-#endif
-XMLPUBFUN int XMLCALL xmlThrDefPedanticParserDefaultValue(int v);
-
-XMLPUBFUN int * XMLCALL __xmlSaveNoEmptyTags(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlSaveNoEmptyTags \
-(*(__xmlSaveNoEmptyTags()))
-#else
-XMLPUBVAR int xmlSaveNoEmptyTags;
-#endif
-XMLPUBFUN int XMLCALL xmlThrDefSaveNoEmptyTags(int v);
-
-XMLPUBFUN int * XMLCALL __xmlSubstituteEntitiesDefaultValue(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlSubstituteEntitiesDefaultValue \
-(*(__xmlSubstituteEntitiesDefaultValue()))
-#else
-XMLPUBVAR int xmlSubstituteEntitiesDefaultValue;
-#endif
-XMLPUBFUN int XMLCALL xmlThrDefSubstituteEntitiesDefaultValue(int v);
-
-XMLPUBFUN xmlRegisterNodeFunc * XMLCALL __xmlRegisterNodeDefaultValue(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlRegisterNodeDefaultValue \
-(*(__xmlRegisterNodeDefaultValue()))
-#else
-XMLPUBVAR xmlRegisterNodeFunc xmlRegisterNodeDefaultValue;
-#endif
-
-XMLPUBFUN xmlDeregisterNodeFunc * XMLCALL __xmlDeregisterNodeDefaultValue(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlDeregisterNodeDefaultValue \
-(*(__xmlDeregisterNodeDefaultValue()))
-#else
-XMLPUBVAR xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue;
-#endif
-
-XMLPUBFUN xmlParserInputBufferCreateFilenameFunc * XMLCALL __xmlParserInputBufferCreateFilenameValue(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlParserInputBufferCreateFilenameValue \
-(*(__xmlParserInputBufferCreateFilenameValue()))
-#else
-XMLPUBVAR xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue;
-#endif
-
-XMLPUBFUN xmlOutputBufferCreateFilenameFunc * XMLCALL __xmlOutputBufferCreateFilenameValue(void);
-#ifdef LIBXML_THREAD_ENABLED
-#define xmlOutputBufferCreateFilenameValue \
-(*(__xmlOutputBufferCreateFilenameValue()))
-#else
-XMLPUBVAR xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue;
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __XML_GLOBALS_H */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/hash.h

@@ -1,233 +0,0 @@
-/*
- * Summary: Chained hash tables
- * Description: This module implements the hash table support used in
- *		various places in the library.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Bjorn Reese <bjorn.reese@systematic.dk>
- */
-
-#ifndef __XML_HASH_H__
-#define __XML_HASH_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * The hash table.
- */
-typedef struct _xmlHashTable xmlHashTable;
-typedef xmlHashTable *xmlHashTablePtr;
-
-#ifdef __cplusplus
-}
-#endif
-
-#include <libxml/xmlversion.h>
-#include <libxml/parser.h>
-#include <libxml/dict.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Recent version of gcc produce a warning when a function pointer is assigned
- * to an object pointer, or vice versa.  The following macro is a dirty hack
- * to allow suppression of the warning.  If your architecture has function
- * pointers which are a different size than a void pointer, there may be some
- * serious trouble within the library.
- */
-/**
- * XML_CAST_FPTR:
- * @fptr:  pointer to a function
- *
- * Macro to do a casting from an object pointer to a
- * function pointer without encountering a warning from
- * gcc
- *
- * #define XML_CAST_FPTR(fptr) (*(void **)(&fptr))
- * This macro violated ISO C aliasing rules (gcc4 on s390 broke)
- * so it is disabled now
- */
-
-#define XML_CAST_FPTR(fptr) fptr
-
-
-/*
- * function types:
- */
-/**
- * xmlHashDeallocator:
- * @payload:  the data in the hash
- * @name:  the name associated
- *
- * Callback to free data from a hash.
- */
-typedef void (*xmlHashDeallocator)(void *payload, xmlChar *name);
-/**
- * xmlHashCopier:
- * @payload:  the data in the hash
- * @name:  the name associated
- *
- * Callback to copy data from a hash.
- *
- * Returns a copy of the data or NULL in case of error.
- */
-typedef void *(*xmlHashCopier)(void *payload, xmlChar *name);
-/**
- * xmlHashScanner:
- * @payload:  the data in the hash
- * @data:  extra scannner data
- * @name:  the name associated
- *
- * Callback when scanning data in a hash with the simple scanner.
- */
-typedef void (*xmlHashScanner)(void *payload, void *data, xmlChar *name);
-/**
- * xmlHashScannerFull:
- * @payload:  the data in the hash
- * @data:  extra scannner data
- * @name:  the name associated
- * @name2:  the second name associated
- * @name3:  the third name associated
- *
- * Callback when scanning data in a hash with the full scanner.
- */
-typedef void (*xmlHashScannerFull)(void *payload, void *data,
-				   const xmlChar *name, const xmlChar *name2,
-				   const xmlChar *name3);
-
-/*
- * Constructor and destructor.
- */
-XMLPUBFUN xmlHashTablePtr XMLCALL
-			xmlHashCreate	(int size);
-XMLPUBFUN xmlHashTablePtr XMLCALL
-			xmlHashCreateDict(int size,
-					 xmlDictPtr dict);
-XMLPUBFUN void XMLCALL
-			xmlHashFree	(xmlHashTablePtr table,
-					 xmlHashDeallocator f);
-
-/*
- * Add a new entry to the hash table.
- */
-XMLPUBFUN int XMLCALL
-			xmlHashAddEntry	(xmlHashTablePtr table,
-		                         const xmlChar *name,
-		                         void *userdata);
-XMLPUBFUN int XMLCALL
-			xmlHashUpdateEntry(xmlHashTablePtr table,
-		                         const xmlChar *name,
-		                         void *userdata,
-					 xmlHashDeallocator f);
-XMLPUBFUN int XMLCALL
-			xmlHashAddEntry2(xmlHashTablePtr table,
-		                         const xmlChar *name,
-		                         const xmlChar *name2,
-		                         void *userdata);
-XMLPUBFUN int XMLCALL
-			xmlHashUpdateEntry2(xmlHashTablePtr table,
-		                         const xmlChar *name,
-		                         const xmlChar *name2,
-		                         void *userdata,
-					 xmlHashDeallocator f);
-XMLPUBFUN int XMLCALL
-			xmlHashAddEntry3(xmlHashTablePtr table,
-		                         const xmlChar *name,
-		                         const xmlChar *name2,
-		                         const xmlChar *name3,
-		                         void *userdata);
-XMLPUBFUN int XMLCALL
-			xmlHashUpdateEntry3(xmlHashTablePtr table,
-		                         const xmlChar *name,
-		                         const xmlChar *name2,
-		                         const xmlChar *name3,
-		                         void *userdata,
-					 xmlHashDeallocator f);
-
-/*
- * Remove an entry from the hash table.
- */
-XMLPUBFUN int XMLCALL
-			xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name,
-                           xmlHashDeallocator f);
-XMLPUBFUN int XMLCALL
-			xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name,
-                            const xmlChar *name2, xmlHashDeallocator f);
-XMLPUBFUN int  XMLCALL
-			xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar *name,
-                            const xmlChar *name2, const xmlChar *name3,
-                            xmlHashDeallocator f);
-
-/*
- * Retrieve the userdata.
- */
-XMLPUBFUN void * XMLCALL
-			xmlHashLookup	(xmlHashTablePtr table,
-					 const xmlChar *name);
-XMLPUBFUN void * XMLCALL
-			xmlHashLookup2	(xmlHashTablePtr table,
-					 const xmlChar *name,
-					 const xmlChar *name2);
-XMLPUBFUN void * XMLCALL
-			xmlHashLookup3	(xmlHashTablePtr table,
-					 const xmlChar *name,
-					 const xmlChar *name2,
-					 const xmlChar *name3);
-XMLPUBFUN void * XMLCALL
-			xmlHashQLookup	(xmlHashTablePtr table,
-					 const xmlChar *name,
-					 const xmlChar *prefix);
-XMLPUBFUN void * XMLCALL
-			xmlHashQLookup2	(xmlHashTablePtr table,
-					 const xmlChar *name,
-					 const xmlChar *prefix,
-					 const xmlChar *name2,
-					 const xmlChar *prefix2);
-XMLPUBFUN void * XMLCALL
-			xmlHashQLookup3	(xmlHashTablePtr table,
-					 const xmlChar *name,
-					 const xmlChar *prefix,
-					 const xmlChar *name2,
-					 const xmlChar *prefix2,
-					 const xmlChar *name3,
-					 const xmlChar *prefix3);
-
-/*
- * Helpers.
- */
-XMLPUBFUN xmlHashTablePtr XMLCALL
-			xmlHashCopy	(xmlHashTablePtr table,
-					 xmlHashCopier f);
-XMLPUBFUN int XMLCALL
-			xmlHashSize	(xmlHashTablePtr table);
-XMLPUBFUN void XMLCALL
-			xmlHashScan	(xmlHashTablePtr table,
-					 xmlHashScanner f,
-					 void *data);
-XMLPUBFUN void XMLCALL
-			xmlHashScan3	(xmlHashTablePtr table,
-					 const xmlChar *name,
-					 const xmlChar *name2,
-					 const xmlChar *name3,
-					 xmlHashScanner f,
-					 void *data);
-XMLPUBFUN void XMLCALL
-			xmlHashScanFull	(xmlHashTablePtr table,
-					 xmlHashScannerFull f,
-					 void *data);
-XMLPUBFUN void XMLCALL
-			xmlHashScanFull3(xmlHashTablePtr table,
-					 const xmlChar *name,
-					 const xmlChar *name2,
-					 const xmlChar *name3,
-					 xmlHashScannerFull f,
-					 void *data);
-#ifdef __cplusplus
-}
-#endif
-#endif /* ! __XML_HASH_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/list.h

@@ -1,137 +0,0 @@
-/*
- * Summary: lists interfaces
- * Description: this module implement the list support used in
- * various place in the library.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Gary Pennington <Gary.Pennington@uk.sun.com>
- */
-
-#ifndef __XML_LINK_INCLUDE__
-#define __XML_LINK_INCLUDE__
-
-#include <libxml/xmlversion.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct _xmlLink xmlLink;
-typedef xmlLink *xmlLinkPtr;
-
-typedef struct _xmlList xmlList;
-typedef xmlList *xmlListPtr;
-
-/**
- * xmlListDeallocator:
- * @lk:  the data to deallocate
- *
- * Callback function used to free data from a list.
- */
-typedef void (*xmlListDeallocator) (xmlLinkPtr lk);
-/**
- * xmlListDataCompare:
- * @data0: the first data
- * @data1: the second data
- *
- * Callback function used to compare 2 data.
- *
- * Returns 0 is equality, -1 or 1 otherwise depending on the ordering.
- */
-typedef int  (*xmlListDataCompare) (const void *data0, const void *data1);
-/**
- * xmlListWalker:
- * @data: the data found in the list
- * @user: extra user provided data to the walker
- *
- * Callback function used when walking a list with xmlListWalk().
- *
- * Returns 0 to stop walking the list, 1 otherwise.
- */
-typedef int (*xmlListWalker) (const void *data, const void *user);
-
-/* Creation/Deletion */
-XMLPUBFUN xmlListPtr XMLCALL
-		xmlListCreate		(xmlListDeallocator deallocator,
-	                                 xmlListDataCompare compare);
-XMLPUBFUN void XMLCALL
-		xmlListDelete		(xmlListPtr l);
-
-/* Basic Operators */
-XMLPUBFUN void * XMLCALL
-		xmlListSearch		(xmlListPtr l,
-					 void *data);
-XMLPUBFUN void * XMLCALL
-		xmlListReverseSearch	(xmlListPtr l,
-					 void *data);
-XMLPUBFUN int XMLCALL
-		xmlListInsert		(xmlListPtr l,
-					 void *data) ;
-XMLPUBFUN int XMLCALL
-		xmlListAppend		(xmlListPtr l,
-					 void *data) ;
-XMLPUBFUN int XMLCALL
-		xmlListRemoveFirst	(xmlListPtr l,
-					 void *data);
-XMLPUBFUN int XMLCALL
-		xmlListRemoveLast	(xmlListPtr l,
-					 void *data);
-XMLPUBFUN int XMLCALL
-		xmlListRemoveAll	(xmlListPtr l,
-					 void *data);
-XMLPUBFUN void XMLCALL
-		xmlListClear		(xmlListPtr l);
-XMLPUBFUN int XMLCALL
-		xmlListEmpty		(xmlListPtr l);
-XMLPUBFUN xmlLinkPtr XMLCALL
-		xmlListFront		(xmlListPtr l);
-XMLPUBFUN xmlLinkPtr XMLCALL
-		xmlListEnd		(xmlListPtr l);
-XMLPUBFUN int XMLCALL
-		xmlListSize		(xmlListPtr l);
-
-XMLPUBFUN void XMLCALL
-		xmlListPopFront		(xmlListPtr l);
-XMLPUBFUN void XMLCALL
-		xmlListPopBack		(xmlListPtr l);
-XMLPUBFUN int XMLCALL
-		xmlListPushFront	(xmlListPtr l,
-					 void *data);
-XMLPUBFUN int XMLCALL
-		xmlListPushBack		(xmlListPtr l,
-					 void *data);
-
-/* Advanced Operators */
-XMLPUBFUN void XMLCALL
-		xmlListReverse		(xmlListPtr l);
-XMLPUBFUN void XMLCALL
-		xmlListSort		(xmlListPtr l);
-XMLPUBFUN void XMLCALL
-		xmlListWalk		(xmlListPtr l,
-					 xmlListWalker walker,
-					 const void *user);
-XMLPUBFUN void XMLCALL
-		xmlListReverseWalk	(xmlListPtr l,
-					 xmlListWalker walker,
-					 const void *user);
-XMLPUBFUN void XMLCALL
-		xmlListMerge		(xmlListPtr l1,
-					 xmlListPtr l2);
-XMLPUBFUN xmlListPtr XMLCALL
-		xmlListDup		(const xmlListPtr old);
-XMLPUBFUN int XMLCALL
-		xmlListCopy		(xmlListPtr cur,
-					 const xmlListPtr old);
-/* Link operators */
-XMLPUBFUN void * XMLCALL
-		xmlLinkGetData          (xmlLinkPtr lk);
-
-/* xmlListUnique() */
-/* xmlListSwap */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __XML_LINK_INCLUDE__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/relaxng.h

@@ -1,213 +0,0 @@
-/*
- * Summary: implementation of the Relax-NG validation
- * Description: implementation of the Relax-NG validation
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#ifndef __XML_RELAX_NG__
-#define __XML_RELAX_NG__
-
-#include <libxml/xmlversion.h>
-#include <libxml/hash.h>
-#include <libxml/xmlstring.h>
-
-#ifdef LIBXML_SCHEMAS_ENABLED
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct _xmlRelaxNG xmlRelaxNG;
-typedef xmlRelaxNG *xmlRelaxNGPtr;
-
-
-/**
- * xmlRelaxNGValidityErrorFunc:
- * @ctx: the validation context
- * @msg: the message
- * @...: extra arguments
- *
- * Signature of an error callback from a Relax-NG validation
- */
-typedef void (XMLCDECL *xmlRelaxNGValidityErrorFunc) (void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
-
-/**
- * xmlRelaxNGValidityWarningFunc:
- * @ctx: the validation context
- * @msg: the message
- * @...: extra arguments
- *
- * Signature of a warning callback from a Relax-NG validation
- */
-typedef void (XMLCDECL *xmlRelaxNGValidityWarningFunc) (void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
-
-/**
- * A schemas validation context
- */
-typedef struct _xmlRelaxNGParserCtxt xmlRelaxNGParserCtxt;
-typedef xmlRelaxNGParserCtxt *xmlRelaxNGParserCtxtPtr;
-
-typedef struct _xmlRelaxNGValidCtxt xmlRelaxNGValidCtxt;
-typedef xmlRelaxNGValidCtxt *xmlRelaxNGValidCtxtPtr;
-
-/*
- * xmlRelaxNGValidErr:
- *
- * List of possible Relax NG validation errors
- */
-typedef enum {
-    XML_RELAXNG_OK = 0,
-    XML_RELAXNG_ERR_MEMORY,
-    XML_RELAXNG_ERR_TYPE,
-    XML_RELAXNG_ERR_TYPEVAL,
-    XML_RELAXNG_ERR_DUPID,
-    XML_RELAXNG_ERR_TYPECMP,
-    XML_RELAXNG_ERR_NOSTATE,
-    XML_RELAXNG_ERR_NODEFINE,
-    XML_RELAXNG_ERR_LISTEXTRA,
-    XML_RELAXNG_ERR_LISTEMPTY,
-    XML_RELAXNG_ERR_INTERNODATA,
-    XML_RELAXNG_ERR_INTERSEQ,
-    XML_RELAXNG_ERR_INTEREXTRA,
-    XML_RELAXNG_ERR_ELEMNAME,
-    XML_RELAXNG_ERR_ATTRNAME,
-    XML_RELAXNG_ERR_ELEMNONS,
-    XML_RELAXNG_ERR_ATTRNONS,
-    XML_RELAXNG_ERR_ELEMWRONGNS,
-    XML_RELAXNG_ERR_ATTRWRONGNS,
-    XML_RELAXNG_ERR_ELEMEXTRANS,
-    XML_RELAXNG_ERR_ATTREXTRANS,
-    XML_RELAXNG_ERR_ELEMNOTEMPTY,
-    XML_RELAXNG_ERR_NOELEM,
-    XML_RELAXNG_ERR_NOTELEM,
-    XML_RELAXNG_ERR_ATTRVALID,
-    XML_RELAXNG_ERR_CONTENTVALID,
-    XML_RELAXNG_ERR_EXTRACONTENT,
-    XML_RELAXNG_ERR_INVALIDATTR,
-    XML_RELAXNG_ERR_DATAELEM,
-    XML_RELAXNG_ERR_VALELEM,
-    XML_RELAXNG_ERR_LISTELEM,
-    XML_RELAXNG_ERR_DATATYPE,
-    XML_RELAXNG_ERR_VALUE,
-    XML_RELAXNG_ERR_LIST,
-    XML_RELAXNG_ERR_NOGRAMMAR,
-    XML_RELAXNG_ERR_EXTRADATA,
-    XML_RELAXNG_ERR_LACKDATA,
-    XML_RELAXNG_ERR_INTERNAL,
-    XML_RELAXNG_ERR_ELEMWRONG,
-    XML_RELAXNG_ERR_TEXTWRONG
-} xmlRelaxNGValidErr;
-
-/*
- * xmlRelaxNGParserFlags:
- *
- * List of possible Relax NG Parser flags
- */
-typedef enum {
-    XML_RELAXNGP_NONE = 0,
-    XML_RELAXNGP_FREE_DOC = 1,
-    XML_RELAXNGP_CRNG = 2
-} xmlRelaxNGParserFlag;
-
-XMLPUBFUN int XMLCALL
-		    xmlRelaxNGInitTypes		(void);
-XMLPUBFUN void XMLCALL
-		    xmlRelaxNGCleanupTypes	(void);
-
-/*
- * Interfaces for parsing.
- */
-XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL
-		    xmlRelaxNGNewParserCtxt	(const char *URL);
-XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL
-		    xmlRelaxNGNewMemParserCtxt	(const char *buffer,
-						 int size);
-XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL
-		    xmlRelaxNGNewDocParserCtxt	(xmlDocPtr doc);
-
-XMLPUBFUN int XMLCALL
-		    xmlRelaxParserSetFlag	(xmlRelaxNGParserCtxtPtr ctxt,
-						 int flag);
-
-XMLPUBFUN void XMLCALL
-		    xmlRelaxNGFreeParserCtxt	(xmlRelaxNGParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL
-		    xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
-					 xmlRelaxNGValidityErrorFunc err,
-					 xmlRelaxNGValidityWarningFunc warn,
-					 void *ctx);
-XMLPUBFUN int XMLCALL
-		    xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
-					 xmlRelaxNGValidityErrorFunc *err,
-					 xmlRelaxNGValidityWarningFunc *warn,
-					 void **ctx);
-XMLPUBFUN void XMLCALL
-		    xmlRelaxNGSetParserStructuredErrors(
-					 xmlRelaxNGParserCtxtPtr ctxt,
-					 xmlStructuredErrorFunc serror,
-					 void *ctx);
-XMLPUBFUN xmlRelaxNGPtr XMLCALL
-		    xmlRelaxNGParse		(xmlRelaxNGParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL
-		    xmlRelaxNGFree		(xmlRelaxNGPtr schema);
-#ifdef LIBXML_OUTPUT_ENABLED
-XMLPUBFUN void XMLCALL
-		    xmlRelaxNGDump		(FILE *output,
-					 xmlRelaxNGPtr schema);
-XMLPUBFUN void XMLCALL
-		    xmlRelaxNGDumpTree	(FILE * output,
-					 xmlRelaxNGPtr schema);
-#endif /* LIBXML_OUTPUT_ENABLED */
-/*
- * Interfaces for validating
- */
-XMLPUBFUN void XMLCALL
-		    xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
-					 xmlRelaxNGValidityErrorFunc err,
-					 xmlRelaxNGValidityWarningFunc warn,
-					 void *ctx);
-XMLPUBFUN int XMLCALL
-		    xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
-					 xmlRelaxNGValidityErrorFunc *err,
-					 xmlRelaxNGValidityWarningFunc *warn,
-					 void **ctx);
-XMLPUBFUN void XMLCALL
-			xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt,
-					  xmlStructuredErrorFunc serror, void *ctx);
-XMLPUBFUN xmlRelaxNGValidCtxtPtr XMLCALL
-		    xmlRelaxNGNewValidCtxt	(xmlRelaxNGPtr schema);
-XMLPUBFUN void XMLCALL
-		    xmlRelaxNGFreeValidCtxt	(xmlRelaxNGValidCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL
-		    xmlRelaxNGValidateDoc	(xmlRelaxNGValidCtxtPtr ctxt,
-						 xmlDocPtr doc);
-/*
- * Interfaces for progressive validation when possible
- */
-XMLPUBFUN int XMLCALL
-		    xmlRelaxNGValidatePushElement	(xmlRelaxNGValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem);
-XMLPUBFUN int XMLCALL
-		    xmlRelaxNGValidatePushCData	(xmlRelaxNGValidCtxtPtr ctxt,
-					 const xmlChar *data,
-					 int len);
-XMLPUBFUN int XMLCALL
-		    xmlRelaxNGValidatePopElement	(xmlRelaxNGValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem);
-XMLPUBFUN int XMLCALL
-		    xmlRelaxNGValidateFullElement	(xmlRelaxNGValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LIBXML_SCHEMAS_ENABLED */
-
-#endif /* __XML_RELAX_NG__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/threads.h

@@ -1,84 +0,0 @@
-/**
- * Summary: interfaces for thread handling
- * Description: set of generic threading related routines
- *              should work with pthreads, Windows native or TLS threads
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#ifndef __XML_THREADS_H__
-#define __XML_THREADS_H__
-
-#include <libxml/xmlversion.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * xmlMutex are a simple mutual exception locks.
- */
-typedef struct _xmlMutex xmlMutex;
-typedef xmlMutex *xmlMutexPtr;
-
-/*
- * xmlRMutex are reentrant mutual exception locks.
- */
-typedef struct _xmlRMutex xmlRMutex;
-typedef xmlRMutex *xmlRMutexPtr;
-
-#ifdef __cplusplus
-}
-#endif
-#include <libxml/globals.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-XMLPUBFUN xmlMutexPtr XMLCALL
-			xmlNewMutex	(void);
-XMLPUBFUN void XMLCALL
-			xmlMutexLock	(xmlMutexPtr tok);
-XMLPUBFUN void XMLCALL
-			xmlMutexUnlock	(xmlMutexPtr tok);
-XMLPUBFUN void XMLCALL
-			xmlFreeMutex	(xmlMutexPtr tok);
-
-XMLPUBFUN xmlRMutexPtr XMLCALL
-			xmlNewRMutex	(void);
-XMLPUBFUN void XMLCALL
-			xmlRMutexLock	(xmlRMutexPtr tok);
-XMLPUBFUN void XMLCALL
-			xmlRMutexUnlock	(xmlRMutexPtr tok);
-XMLPUBFUN void XMLCALL
-			xmlFreeRMutex	(xmlRMutexPtr tok);
-
-/*
- * Library wide APIs.
- */
-XMLPUBFUN void XMLCALL
-			xmlInitThreads	(void);
-XMLPUBFUN void XMLCALL
-			xmlLockLibrary	(void);
-XMLPUBFUN void XMLCALL
-			xmlUnlockLibrary(void);
-XMLPUBFUN int XMLCALL
-			xmlGetThreadId	(void);
-XMLPUBFUN int XMLCALL
-			xmlIsMainThread	(void);
-XMLPUBFUN void XMLCALL
-			xmlCleanupThreads(void);
-XMLPUBFUN xmlGlobalStatePtr XMLCALL
-			xmlGetGlobalState(void);
-
-#if defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && defined(LIBXML_STATIC_FOR_DLL)
-int XMLCALL xmlDllMain(void *hinstDLL, unsigned long fdwReason, void *lpvReserved);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif /* __XML_THREADS_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/valid.h

@@ -1,458 +0,0 @@
-/*
- * Summary: The DTD validation
- * Description: API for the DTD handling and the validity checking
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-
-#ifndef __XML_VALID_H__
-#define __XML_VALID_H__
-
-#include <libxml/xmlversion.h>
-#include <libxml/xmlerror.h>
-#include <libxml/tree.h>
-#include <libxml/list.h>
-#include <libxml/xmlautomata.h>
-#include <libxml/xmlregexp.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Validation state added for non-determinist content model.
- */
-typedef struct _xmlValidState xmlValidState;
-typedef xmlValidState *xmlValidStatePtr;
-
-/**
- * xmlValidityErrorFunc:
- * @ctx:  usually an xmlValidCtxtPtr to a validity error context,
- *        but comes from ctxt->userData (which normally contains such
- *        a pointer); ctxt->userData can be changed by the user.
- * @msg:  the string to format *printf like vararg
- * @...:  remaining arguments to the format
- *
- * Callback called when a validity error is found. This is a message
- * oriented function similar to an *printf function.
- */
-typedef void (XMLCDECL *xmlValidityErrorFunc) (void *ctx,
-			     const char *msg,
-			     ...) LIBXML_ATTR_FORMAT(2,3);
-
-/**
- * xmlValidityWarningFunc:
- * @ctx:  usually an xmlValidCtxtPtr to a validity error context,
- *        but comes from ctxt->userData (which normally contains such
- *        a pointer); ctxt->userData can be changed by the user.
- * @msg:  the string to format *printf like vararg
- * @...:  remaining arguments to the format
- *
- * Callback called when a validity warning is found. This is a message
- * oriented function similar to an *printf function.
- */
-typedef void (XMLCDECL *xmlValidityWarningFunc) (void *ctx,
-			       const char *msg,
-			       ...) LIBXML_ATTR_FORMAT(2,3);
-
-#ifdef IN_LIBXML
-/**
- * XML_CTXT_FINISH_DTD_0:
- *
- * Special value for finishDtd field when embedded in an xmlParserCtxt
- */
-#define XML_CTXT_FINISH_DTD_0 0xabcd1234
-/**
- * XML_CTXT_FINISH_DTD_1:
- *
- * Special value for finishDtd field when embedded in an xmlParserCtxt
- */
-#define XML_CTXT_FINISH_DTD_1 0xabcd1235
-#endif
-
-/*
- * xmlValidCtxt:
- * An xmlValidCtxt is used for error reporting when validating.
- */
-typedef struct _xmlValidCtxt xmlValidCtxt;
-typedef xmlValidCtxt *xmlValidCtxtPtr;
-struct _xmlValidCtxt {
-    void *userData;			/* user specific data block */
-    xmlValidityErrorFunc error;		/* the callback in case of errors */
-    xmlValidityWarningFunc warning;	/* the callback in case of warning */
-
-    /* Node analysis stack used when validating within entities */
-    xmlNodePtr         node;          /* Current parsed Node */
-    int                nodeNr;        /* Depth of the parsing stack */
-    int                nodeMax;       /* Max depth of the parsing stack */
-    xmlNodePtr        *nodeTab;       /* array of nodes */
-
-    unsigned int     finishDtd;       /* finished validating the Dtd ? */
-    xmlDocPtr              doc;       /* the document */
-    int                  valid;       /* temporary validity check result */
-
-    /* state state used for non-determinist content validation */
-    xmlValidState     *vstate;        /* current state */
-    int                vstateNr;      /* Depth of the validation stack */
-    int                vstateMax;     /* Max depth of the validation stack */
-    xmlValidState     *vstateTab;     /* array of validation states */
-
-#ifdef LIBXML_REGEXP_ENABLED
-    xmlAutomataPtr            am;     /* the automata */
-    xmlAutomataStatePtr    state;     /* used to build the automata */
-#else
-    void                     *am;
-    void                  *state;
-#endif
-};
-
-/*
- * ALL notation declarations are stored in a table.
- * There is one table per DTD.
- */
-
-typedef struct _xmlHashTable xmlNotationTable;
-typedef xmlNotationTable *xmlNotationTablePtr;
-
-/*
- * ALL element declarations are stored in a table.
- * There is one table per DTD.
- */
-
-typedef struct _xmlHashTable xmlElementTable;
-typedef xmlElementTable *xmlElementTablePtr;
-
-/*
- * ALL attribute declarations are stored in a table.
- * There is one table per DTD.
- */
-
-typedef struct _xmlHashTable xmlAttributeTable;
-typedef xmlAttributeTable *xmlAttributeTablePtr;
-
-/*
- * ALL IDs attributes are stored in a table.
- * There is one table per document.
- */
-
-typedef struct _xmlHashTable xmlIDTable;
-typedef xmlIDTable *xmlIDTablePtr;
-
-/*
- * ALL Refs attributes are stored in a table.
- * There is one table per document.
- */
-
-typedef struct _xmlHashTable xmlRefTable;
-typedef xmlRefTable *xmlRefTablePtr;
-
-/* Notation */
-XMLPUBFUN xmlNotationPtr XMLCALL
-		xmlAddNotationDecl	(xmlValidCtxtPtr ctxt,
-					 xmlDtdPtr dtd,
-					 const xmlChar *name,
-					 const xmlChar *PublicID,
-					 const xmlChar *SystemID);
-#ifdef LIBXML_TREE_ENABLED
-XMLPUBFUN xmlNotationTablePtr XMLCALL
-		xmlCopyNotationTable	(xmlNotationTablePtr table);
-#endif /* LIBXML_TREE_ENABLED */
-XMLPUBFUN void XMLCALL
-		xmlFreeNotationTable	(xmlNotationTablePtr table);
-#ifdef LIBXML_OUTPUT_ENABLED
-XMLPUBFUN void XMLCALL
-		xmlDumpNotationDecl	(xmlBufferPtr buf,
-					 xmlNotationPtr nota);
-XMLPUBFUN void XMLCALL
-		xmlDumpNotationTable	(xmlBufferPtr buf,
-					 xmlNotationTablePtr table);
-#endif /* LIBXML_OUTPUT_ENABLED */
-
-/* Element Content */
-/* the non Doc version are being deprecated */
-XMLPUBFUN xmlElementContentPtr XMLCALL
-		xmlNewElementContent	(const xmlChar *name,
-					 xmlElementContentType type);
-XMLPUBFUN xmlElementContentPtr XMLCALL
-		xmlCopyElementContent	(xmlElementContentPtr content);
-XMLPUBFUN void XMLCALL
-		xmlFreeElementContent	(xmlElementContentPtr cur);
-/* the new versions with doc argument */
-XMLPUBFUN xmlElementContentPtr XMLCALL
-		xmlNewDocElementContent	(xmlDocPtr doc,
-					 const xmlChar *name,
-					 xmlElementContentType type);
-XMLPUBFUN xmlElementContentPtr XMLCALL
-		xmlCopyDocElementContent(xmlDocPtr doc,
-					 xmlElementContentPtr content);
-XMLPUBFUN void XMLCALL
-		xmlFreeDocElementContent(xmlDocPtr doc,
-					 xmlElementContentPtr cur);
-XMLPUBFUN void XMLCALL
-		xmlSnprintfElementContent(char *buf,
-					 int size,
-	                                 xmlElementContentPtr content,
-					 int englob);
-#ifdef LIBXML_OUTPUT_ENABLED
-/* DEPRECATED */
-XMLPUBFUN void XMLCALL
-		xmlSprintfElementContent(char *buf,
-	                                 xmlElementContentPtr content,
-					 int englob);
-#endif /* LIBXML_OUTPUT_ENABLED */
-/* DEPRECATED */
-
-/* Element */
-XMLPUBFUN xmlElementPtr XMLCALL
-		xmlAddElementDecl	(xmlValidCtxtPtr ctxt,
-					 xmlDtdPtr dtd,
-					 const xmlChar *name,
-					 xmlElementTypeVal type,
-					 xmlElementContentPtr content);
-#ifdef LIBXML_TREE_ENABLED
-XMLPUBFUN xmlElementTablePtr XMLCALL
-		xmlCopyElementTable	(xmlElementTablePtr table);
-#endif /* LIBXML_TREE_ENABLED */
-XMLPUBFUN void XMLCALL
-		xmlFreeElementTable	(xmlElementTablePtr table);
-#ifdef LIBXML_OUTPUT_ENABLED
-XMLPUBFUN void XMLCALL
-		xmlDumpElementTable	(xmlBufferPtr buf,
-					 xmlElementTablePtr table);
-XMLPUBFUN void XMLCALL
-		xmlDumpElementDecl	(xmlBufferPtr buf,
-					 xmlElementPtr elem);
-#endif /* LIBXML_OUTPUT_ENABLED */
-
-/* Enumeration */
-XMLPUBFUN xmlEnumerationPtr XMLCALL
-		xmlCreateEnumeration	(const xmlChar *name);
-XMLPUBFUN void XMLCALL
-		xmlFreeEnumeration	(xmlEnumerationPtr cur);
-#ifdef LIBXML_TREE_ENABLED
-XMLPUBFUN xmlEnumerationPtr XMLCALL
-		xmlCopyEnumeration	(xmlEnumerationPtr cur);
-#endif /* LIBXML_TREE_ENABLED */
-
-/* Attribute */
-XMLPUBFUN xmlAttributePtr XMLCALL
-		xmlAddAttributeDecl	(xmlValidCtxtPtr ctxt,
-					 xmlDtdPtr dtd,
-					 const xmlChar *elem,
-					 const xmlChar *name,
-					 const xmlChar *ns,
-					 xmlAttributeType type,
-					 xmlAttributeDefault def,
-					 const xmlChar *defaultValue,
-					 xmlEnumerationPtr tree);
-#ifdef LIBXML_TREE_ENABLED
-XMLPUBFUN xmlAttributeTablePtr XMLCALL
-		xmlCopyAttributeTable  (xmlAttributeTablePtr table);
-#endif /* LIBXML_TREE_ENABLED */
-XMLPUBFUN void XMLCALL
-		xmlFreeAttributeTable  (xmlAttributeTablePtr table);
-#ifdef LIBXML_OUTPUT_ENABLED
-XMLPUBFUN void XMLCALL
-		xmlDumpAttributeTable  (xmlBufferPtr buf,
-					xmlAttributeTablePtr table);
-XMLPUBFUN void XMLCALL
-		xmlDumpAttributeDecl   (xmlBufferPtr buf,
-					xmlAttributePtr attr);
-#endif /* LIBXML_OUTPUT_ENABLED */
-
-/* IDs */
-XMLPUBFUN xmlIDPtr XMLCALL
-		xmlAddID	       (xmlValidCtxtPtr ctxt,
-					xmlDocPtr doc,
-					const xmlChar *value,
-					xmlAttrPtr attr);
-XMLPUBFUN void XMLCALL
-		xmlFreeIDTable	       (xmlIDTablePtr table);
-XMLPUBFUN xmlAttrPtr XMLCALL
-		xmlGetID	       (xmlDocPtr doc,
-					const xmlChar *ID);
-XMLPUBFUN int XMLCALL
-		xmlIsID		       (xmlDocPtr doc,
-					xmlNodePtr elem,
-					xmlAttrPtr attr);
-XMLPUBFUN int XMLCALL
-		xmlRemoveID	       (xmlDocPtr doc,
-					xmlAttrPtr attr);
-
-/* IDREFs */
-XMLPUBFUN xmlRefPtr XMLCALL
-		xmlAddRef	       (xmlValidCtxtPtr ctxt,
-					xmlDocPtr doc,
-					const xmlChar *value,
-					xmlAttrPtr attr);
-XMLPUBFUN void XMLCALL
-		xmlFreeRefTable	       (xmlRefTablePtr table);
-XMLPUBFUN int XMLCALL
-		xmlIsRef	       (xmlDocPtr doc,
-					xmlNodePtr elem,
-					xmlAttrPtr attr);
-XMLPUBFUN int XMLCALL
-		xmlRemoveRef	       (xmlDocPtr doc,
-					xmlAttrPtr attr);
-XMLPUBFUN xmlListPtr XMLCALL
-		xmlGetRefs	       (xmlDocPtr doc,
-					const xmlChar *ID);
-
-/**
- * The public function calls related to validity checking.
- */
-#ifdef LIBXML_VALID_ENABLED
-/* Allocate/Release Validation Contexts */
-XMLPUBFUN xmlValidCtxtPtr XMLCALL
-		xmlNewValidCtxt(void);
-XMLPUBFUN void XMLCALL
-		xmlFreeValidCtxt(xmlValidCtxtPtr);
-
-XMLPUBFUN int XMLCALL
-		xmlValidateRoot		(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc);
-XMLPUBFUN int XMLCALL
-		xmlValidateElementDecl	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-		                         xmlElementPtr elem);
-XMLPUBFUN xmlChar * XMLCALL
-		xmlValidNormalizeAttributeValue(xmlDocPtr doc,
-					 xmlNodePtr elem,
-					 const xmlChar *name,
-					 const xmlChar *value);
-XMLPUBFUN xmlChar * XMLCALL
-		xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem,
-					 const xmlChar *name,
-					 const xmlChar *value);
-XMLPUBFUN int XMLCALL
-		xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-		                         xmlAttributePtr attr);
-XMLPUBFUN int XMLCALL
-		xmlValidateAttributeValue(xmlAttributeType type,
-					 const xmlChar *value);
-XMLPUBFUN int XMLCALL
-		xmlValidateNotationDecl	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-		                         xmlNotationPtr nota);
-XMLPUBFUN int XMLCALL
-		xmlValidateDtd		(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlDtdPtr dtd);
-XMLPUBFUN int XMLCALL
-		xmlValidateDtdFinal	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc);
-XMLPUBFUN int XMLCALL
-		xmlValidateDocument	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc);
-XMLPUBFUN int XMLCALL
-		xmlValidateElement	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem);
-XMLPUBFUN int XMLCALL
-		xmlValidateOneElement	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-		                         xmlNodePtr elem);
-XMLPUBFUN int XMLCALL
-		xmlValidateOneAttribute	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr	elem,
-					 xmlAttrPtr attr,
-					 const xmlChar *value);
-XMLPUBFUN int XMLCALL
-		xmlValidateOneNamespace	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem,
-					 const xmlChar *prefix,
-					 xmlNsPtr ns,
-					 const xmlChar *value);
-XMLPUBFUN int XMLCALL
-		xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc);
-#endif /* LIBXML_VALID_ENABLED */
-
-#if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
-XMLPUBFUN int XMLCALL
-		xmlValidateNotationUse	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 const xmlChar *notationName);
-#endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */
-
-XMLPUBFUN int XMLCALL
-		xmlIsMixedElement	(xmlDocPtr doc,
-					 const xmlChar *name);
-XMLPUBFUN xmlAttributePtr XMLCALL
-		xmlGetDtdAttrDesc	(xmlDtdPtr dtd,
-					 const xmlChar *elem,
-					 const xmlChar *name);
-XMLPUBFUN xmlAttributePtr XMLCALL
-		xmlGetDtdQAttrDesc	(xmlDtdPtr dtd,
-					 const xmlChar *elem,
-					 const xmlChar *name,
-					 const xmlChar *prefix);
-XMLPUBFUN xmlNotationPtr XMLCALL
-		xmlGetDtdNotationDesc	(xmlDtdPtr dtd,
-					 const xmlChar *name);
-XMLPUBFUN xmlElementPtr XMLCALL
-		xmlGetDtdQElementDesc	(xmlDtdPtr dtd,
-					 const xmlChar *name,
-					 const xmlChar *prefix);
-XMLPUBFUN xmlElementPtr XMLCALL
-		xmlGetDtdElementDesc	(xmlDtdPtr dtd,
-					 const xmlChar *name);
-
-#ifdef LIBXML_VALID_ENABLED
-
-XMLPUBFUN int XMLCALL
-		xmlValidGetPotentialChildren(xmlElementContent *ctree,
-					 const xmlChar **names,
-					 int *len,
-					 int max);
-
-XMLPUBFUN int XMLCALL
-		xmlValidGetValidElements(xmlNode *prev,
-					 xmlNode *next,
-					 const xmlChar **names,
-					 int max);
-XMLPUBFUN int XMLCALL
-		xmlValidateNameValue	(const xmlChar *value);
-XMLPUBFUN int XMLCALL
-		xmlValidateNamesValue	(const xmlChar *value);
-XMLPUBFUN int XMLCALL
-		xmlValidateNmtokenValue	(const xmlChar *value);
-XMLPUBFUN int XMLCALL
-		xmlValidateNmtokensValue(const xmlChar *value);
-
-#ifdef LIBXML_REGEXP_ENABLED
-/*
- * Validation based on the regexp support
- */
-XMLPUBFUN int XMLCALL
-		xmlValidBuildContentModel(xmlValidCtxtPtr ctxt,
-					 xmlElementPtr elem);
-
-XMLPUBFUN int XMLCALL
-		xmlValidatePushElement	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem,
-					 const xmlChar *qname);
-XMLPUBFUN int XMLCALL
-		xmlValidatePushCData	(xmlValidCtxtPtr ctxt,
-					 const xmlChar *data,
-					 int len);
-XMLPUBFUN int XMLCALL
-		xmlValidatePopElement	(xmlValidCtxtPtr ctxt,
-					 xmlDocPtr doc,
-					 xmlNodePtr elem,
-					 const xmlChar *qname);
-#endif /* LIBXML_REGEXP_ENABLED */
-#endif /* LIBXML_VALID_ENABLED */
-#ifdef __cplusplus
-}
-#endif
-#endif /* __XML_VALID_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/xlink.h

@@ -1,189 +0,0 @@
-/*
- * Summary: unfinished XLink detection module
- * Description: unfinished XLink detection module
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#ifndef __XML_XLINK_H__
-#define __XML_XLINK_H__
-
-#include <libxml/xmlversion.h>
-#include <libxml/tree.h>
-
-#ifdef LIBXML_XPTR_ENABLED
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Various defines for the various Link properties.
- *
- * NOTE: the link detection layer will try to resolve QName expansion
- *       of namespaces. If "foo" is the prefix for "http://foo.com/"
- *       then the link detection layer will expand role="foo:myrole"
- *       to "http://foo.com/:myrole".
- * NOTE: the link detection layer will expand URI-Refences found on
- *       href attributes by using the base mechanism if found.
- */
-typedef xmlChar *xlinkHRef;
-typedef xmlChar *xlinkRole;
-typedef xmlChar *xlinkTitle;
-
-typedef enum {
-    XLINK_TYPE_NONE = 0,
-    XLINK_TYPE_SIMPLE,
-    XLINK_TYPE_EXTENDED,
-    XLINK_TYPE_EXTENDED_SET
-} xlinkType;
-
-typedef enum {
-    XLINK_SHOW_NONE = 0,
-    XLINK_SHOW_NEW,
-    XLINK_SHOW_EMBED,
-    XLINK_SHOW_REPLACE
-} xlinkShow;
-
-typedef enum {
-    XLINK_ACTUATE_NONE = 0,
-    XLINK_ACTUATE_AUTO,
-    XLINK_ACTUATE_ONREQUEST
-} xlinkActuate;
-
-/**
- * xlinkNodeDetectFunc:
- * @ctx:  user data pointer
- * @node:  the node to check
- *
- * This is the prototype for the link detection routine.
- * It calls the default link detection callbacks upon link detection.
- */
-typedef void (*xlinkNodeDetectFunc) (void *ctx, xmlNodePtr node);
-
-/*
- * The link detection module interact with the upper layers using
- * a set of callback registered at parsing time.
- */
-
-/**
- * xlinkSimpleLinkFunk:
- * @ctx:  user data pointer
- * @node:  the node carrying the link
- * @href:  the target of the link
- * @role:  the role string
- * @title:  the link title
- *
- * This is the prototype for a simple link detection callback.
- */
-typedef void
-(*xlinkSimpleLinkFunk)	(void *ctx,
-			 xmlNodePtr node,
-			 const xlinkHRef href,
-			 const xlinkRole role,
-			 const xlinkTitle title);
-
-/**
- * xlinkExtendedLinkFunk:
- * @ctx:  user data pointer
- * @node:  the node carrying the link
- * @nbLocators: the number of locators detected on the link
- * @hrefs:  pointer to the array of locator hrefs
- * @roles:  pointer to the array of locator roles
- * @nbArcs: the number of arcs detected on the link
- * @from:  pointer to the array of source roles found on the arcs
- * @to:  pointer to the array of target roles found on the arcs
- * @show:  array of values for the show attributes found on the arcs
- * @actuate:  array of values for the actuate attributes found on the arcs
- * @nbTitles: the number of titles detected on the link
- * @title:  array of titles detected on the link
- * @langs:  array of xml:lang values for the titles
- *
- * This is the prototype for a extended link detection callback.
- */
-typedef void
-(*xlinkExtendedLinkFunk)(void *ctx,
-			 xmlNodePtr node,
-			 int nbLocators,
-			 const xlinkHRef *hrefs,
-			 const xlinkRole *roles,
-			 int nbArcs,
-			 const xlinkRole *from,
-			 const xlinkRole *to,
-			 xlinkShow *show,
-			 xlinkActuate *actuate,
-			 int nbTitles,
-			 const xlinkTitle *titles,
-			 const xmlChar **langs);
-
-/**
- * xlinkExtendedLinkSetFunk:
- * @ctx:  user data pointer
- * @node:  the node carrying the link
- * @nbLocators: the number of locators detected on the link
- * @hrefs:  pointer to the array of locator hrefs
- * @roles:  pointer to the array of locator roles
- * @nbTitles: the number of titles detected on the link
- * @title:  array of titles detected on the link
- * @langs:  array of xml:lang values for the titles
- *
- * This is the prototype for a extended link set detection callback.
- */
-typedef void
-(*xlinkExtendedLinkSetFunk)	(void *ctx,
-				 xmlNodePtr node,
-				 int nbLocators,
-				 const xlinkHRef *hrefs,
-				 const xlinkRole *roles,
-				 int nbTitles,
-				 const xlinkTitle *titles,
-				 const xmlChar **langs);
-
-/**
- * This is the structure containing a set of Links detection callbacks.
- *
- * There is no default xlink callbacks, if one want to get link
- * recognition activated, those call backs must be provided before parsing.
- */
-typedef struct _xlinkHandler xlinkHandler;
-typedef xlinkHandler *xlinkHandlerPtr;
-struct _xlinkHandler {
-    xlinkSimpleLinkFunk simple;
-    xlinkExtendedLinkFunk extended;
-    xlinkExtendedLinkSetFunk set;
-};
-
-/*
- * The default detection routine, can be overridden, they call the default
- * detection callbacks.
- */
-
-XMLPUBFUN xlinkNodeDetectFunc XMLCALL
-		xlinkGetDefaultDetect	(void);
-XMLPUBFUN void XMLCALL
-		xlinkSetDefaultDetect	(xlinkNodeDetectFunc func);
-
-/*
- * Routines to set/get the default handlers.
- */
-XMLPUBFUN xlinkHandlerPtr XMLCALL
-		xlinkGetDefaultHandler	(void);
-XMLPUBFUN void XMLCALL
-		xlinkSetDefaultHandler	(xlinkHandlerPtr handler);
-
-/*
- * Link detection module itself.
- */
-XMLPUBFUN xlinkType XMLCALL
-		xlinkIsLink		(xmlDocPtr doc,
-					 xmlNodePtr node);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LIBXML_XPTR_ENABLED */
-
-#endif /* __XML_XLINK_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/xmlIO.h

@@ -1,366 +0,0 @@
-/*
- * Summary: interface for the I/O interfaces used by the parser
- * Description: interface for the I/O interfaces used by the parser
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#ifndef __XML_IO_H__
-#define __XML_IO_H__
-
-#include <stdio.h>
-#include <libxml/xmlversion.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Those are the functions and datatypes for the parser input
- * I/O structures.
- */
-
-/**
- * xmlInputMatchCallback:
- * @filename: the filename or URI
- *
- * Callback used in the I/O Input API to detect if the current handler
- * can provide input fonctionnalities for this resource.
- *
- * Returns 1 if yes and 0 if another Input module should be used
- */
-typedef int (XMLCALL *xmlInputMatchCallback) (char const *filename);
-/**
- * xmlInputOpenCallback:
- * @filename: the filename or URI
- *
- * Callback used in the I/O Input API to open the resource
- *
- * Returns an Input context or NULL in case or error
- */
-typedef void * (XMLCALL *xmlInputOpenCallback) (char const *filename);
-/**
- * xmlInputReadCallback:
- * @context:  an Input context
- * @buffer:  the buffer to store data read
- * @len:  the length of the buffer in bytes
- *
- * Callback used in the I/O Input API to read the resource
- *
- * Returns the number of bytes read or -1 in case of error
- */
-typedef int (XMLCALL *xmlInputReadCallback) (void * context, char * buffer, int len);
-/**
- * xmlInputCloseCallback:
- * @context:  an Input context
- *
- * Callback used in the I/O Input API to close the resource
- *
- * Returns 0 or -1 in case of error
- */
-typedef int (XMLCALL *xmlInputCloseCallback) (void * context);
-
-#ifdef LIBXML_OUTPUT_ENABLED
-/*
- * Those are the functions and datatypes for the library output
- * I/O structures.
- */
-
-/**
- * xmlOutputMatchCallback:
- * @filename: the filename or URI
- *
- * Callback used in the I/O Output API to detect if the current handler
- * can provide output fonctionnalities for this resource.
- *
- * Returns 1 if yes and 0 if another Output module should be used
- */
-typedef int (XMLCALL *xmlOutputMatchCallback) (char const *filename);
-/**
- * xmlOutputOpenCallback:
- * @filename: the filename or URI
- *
- * Callback used in the I/O Output API to open the resource
- *
- * Returns an Output context or NULL in case or error
- */
-typedef void * (XMLCALL *xmlOutputOpenCallback) (char const *filename);
-/**
- * xmlOutputWriteCallback:
- * @context:  an Output context
- * @buffer:  the buffer of data to write
- * @len:  the length of the buffer in bytes
- *
- * Callback used in the I/O Output API to write to the resource
- *
- * Returns the number of bytes written or -1 in case of error
- */
-typedef int (XMLCALL *xmlOutputWriteCallback) (void * context, const char * buffer,
-                                       int len);
-/**
- * xmlOutputCloseCallback:
- * @context:  an Output context
- *
- * Callback used in the I/O Output API to close the resource
- *
- * Returns 0 or -1 in case of error
- */
-typedef int (XMLCALL *xmlOutputCloseCallback) (void * context);
-#endif /* LIBXML_OUTPUT_ENABLED */
-
-#ifdef __cplusplus
-}
-#endif
-
-#include <libxml/globals.h>
-#include <libxml/tree.h>
-#include <libxml/parser.h>
-#include <libxml/encoding.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-struct _xmlParserInputBuffer {
-    void*                  context;
-    xmlInputReadCallback   readcallback;
-    xmlInputCloseCallback  closecallback;
-
-    xmlCharEncodingHandlerPtr encoder; /* I18N conversions to UTF-8 */
-
-    xmlBufPtr buffer;    /* Local buffer encoded in UTF-8 */
-    xmlBufPtr raw;       /* if encoder != NULL buffer for raw input */
-    int	compressed;	    /* -1=unknown, 0=not compressed, 1=compressed */
-    int error;
-    unsigned long rawconsumed;/* amount consumed from raw */
-};
-
-
-#ifdef LIBXML_OUTPUT_ENABLED
-struct _xmlOutputBuffer {
-    void*                   context;
-    xmlOutputWriteCallback  writecallback;
-    xmlOutputCloseCallback  closecallback;
-
-    xmlCharEncodingHandlerPtr encoder; /* I18N conversions to UTF-8 */
-
-    xmlBufPtr buffer;    /* Local buffer encoded in UTF-8 or ISOLatin */
-    xmlBufPtr conv;      /* if encoder != NULL buffer for output */
-    int written;            /* total number of byte written */
-    int error;
-};
-#endif /* LIBXML_OUTPUT_ENABLED */
-
-/*
- * Interfaces for input
- */
-XMLPUBFUN void XMLCALL
-	xmlCleanupInputCallbacks		(void);
-
-XMLPUBFUN int XMLCALL
-	xmlPopInputCallbacks			(void);
-
-XMLPUBFUN void XMLCALL
-	xmlRegisterDefaultInputCallbacks	(void);
-XMLPUBFUN xmlParserInputBufferPtr XMLCALL
-	xmlAllocParserInputBuffer		(xmlCharEncoding enc);
-
-XMLPUBFUN xmlParserInputBufferPtr XMLCALL
-	xmlParserInputBufferCreateFilename	(const char *URI,
-                                                 xmlCharEncoding enc);
-XMLPUBFUN xmlParserInputBufferPtr XMLCALL
-	xmlParserInputBufferCreateFile		(FILE *file,
-                                                 xmlCharEncoding enc);
-XMLPUBFUN xmlParserInputBufferPtr XMLCALL
-	xmlParserInputBufferCreateFd		(int fd,
-	                                         xmlCharEncoding enc);
-XMLPUBFUN xmlParserInputBufferPtr XMLCALL
-	xmlParserInputBufferCreateMem		(const char *mem, int size,
-	                                         xmlCharEncoding enc);
-XMLPUBFUN xmlParserInputBufferPtr XMLCALL
-	xmlParserInputBufferCreateStatic	(const char *mem, int size,
-	                                         xmlCharEncoding enc);
-XMLPUBFUN xmlParserInputBufferPtr XMLCALL
-	xmlParserInputBufferCreateIO		(xmlInputReadCallback   ioread,
-						 xmlInputCloseCallback  ioclose,
-						 void *ioctx,
-	                                         xmlCharEncoding enc);
-XMLPUBFUN int XMLCALL
-	xmlParserInputBufferRead		(xmlParserInputBufferPtr in,
-						 int len);
-XMLPUBFUN int XMLCALL
-	xmlParserInputBufferGrow		(xmlParserInputBufferPtr in,
-						 int len);
-XMLPUBFUN int XMLCALL
-	xmlParserInputBufferPush		(xmlParserInputBufferPtr in,
-						 int len,
-						 const char *buf);
-XMLPUBFUN void XMLCALL
-	xmlFreeParserInputBuffer		(xmlParserInputBufferPtr in);
-XMLPUBFUN char * XMLCALL
-	xmlParserGetDirectory			(const char *filename);
-
-XMLPUBFUN int XMLCALL
-	xmlRegisterInputCallbacks		(xmlInputMatchCallback matchFunc,
-						 xmlInputOpenCallback openFunc,
-						 xmlInputReadCallback readFunc,
-						 xmlInputCloseCallback closeFunc);
-
-xmlParserInputBufferPtr
-	__xmlParserInputBufferCreateFilename(const char *URI,
-										xmlCharEncoding enc);
-
-#ifdef LIBXML_OUTPUT_ENABLED
-/*
- * Interfaces for output
- */
-XMLPUBFUN void XMLCALL
-	xmlCleanupOutputCallbacks		(void);
-XMLPUBFUN void XMLCALL
-	xmlRegisterDefaultOutputCallbacks(void);
-XMLPUBFUN xmlOutputBufferPtr XMLCALL
-	xmlAllocOutputBuffer		(xmlCharEncodingHandlerPtr encoder);
-
-XMLPUBFUN xmlOutputBufferPtr XMLCALL
-	xmlOutputBufferCreateFilename	(const char *URI,
-					 xmlCharEncodingHandlerPtr encoder,
-					 int compression);
-
-XMLPUBFUN xmlOutputBufferPtr XMLCALL
-	xmlOutputBufferCreateFile	(FILE *file,
-					 xmlCharEncodingHandlerPtr encoder);
-
-XMLPUBFUN xmlOutputBufferPtr XMLCALL
-	xmlOutputBufferCreateBuffer	(xmlBufferPtr buffer,
-					 xmlCharEncodingHandlerPtr encoder);
-
-XMLPUBFUN xmlOutputBufferPtr XMLCALL
-	xmlOutputBufferCreateFd		(int fd,
-					 xmlCharEncodingHandlerPtr encoder);
-
-XMLPUBFUN xmlOutputBufferPtr XMLCALL
-	xmlOutputBufferCreateIO		(xmlOutputWriteCallback   iowrite,
-					 xmlOutputCloseCallback  ioclose,
-					 void *ioctx,
-					 xmlCharEncodingHandlerPtr encoder);
-
-/* Couple of APIs to get the output without digging into the buffers */
-XMLPUBFUN const xmlChar * XMLCALL
-        xmlOutputBufferGetContent       (xmlOutputBufferPtr out);
-XMLPUBFUN size_t XMLCALL
-        xmlOutputBufferGetSize          (xmlOutputBufferPtr out);
-
-XMLPUBFUN int XMLCALL
-	xmlOutputBufferWrite		(xmlOutputBufferPtr out,
-					 int len,
-					 const char *buf);
-XMLPUBFUN int XMLCALL
-	xmlOutputBufferWriteString	(xmlOutputBufferPtr out,
-					 const char *str);
-XMLPUBFUN int XMLCALL
-	xmlOutputBufferWriteEscape	(xmlOutputBufferPtr out,
-					 const xmlChar *str,
-					 xmlCharEncodingOutputFunc escaping);
-
-XMLPUBFUN int XMLCALL
-	xmlOutputBufferFlush		(xmlOutputBufferPtr out);
-XMLPUBFUN int XMLCALL
-	xmlOutputBufferClose		(xmlOutputBufferPtr out);
-
-XMLPUBFUN int XMLCALL
-	xmlRegisterOutputCallbacks	(xmlOutputMatchCallback matchFunc,
-					 xmlOutputOpenCallback openFunc,
-					 xmlOutputWriteCallback writeFunc,
-					 xmlOutputCloseCallback closeFunc);
-
-xmlOutputBufferPtr
-	__xmlOutputBufferCreateFilename(const char *URI,
-                              xmlCharEncodingHandlerPtr encoder,
-                              int compression);
-
-#ifdef LIBXML_HTTP_ENABLED
-/*  This function only exists if HTTP support built into the library  */
-XMLPUBFUN void XMLCALL
-	xmlRegisterHTTPPostCallbacks	(void );
-#endif /* LIBXML_HTTP_ENABLED */
-
-#endif /* LIBXML_OUTPUT_ENABLED */
-
-XMLPUBFUN xmlParserInputPtr XMLCALL
-	xmlCheckHTTPInput		(xmlParserCtxtPtr ctxt,
-					 xmlParserInputPtr ret);
-
-/*
- * A predefined entity loader disabling network accesses
- */
-XMLPUBFUN xmlParserInputPtr XMLCALL
-	xmlNoNetExternalEntityLoader	(const char *URL,
-					 const char *ID,
-					 xmlParserCtxtPtr ctxt);
-
-/*
- * xmlNormalizeWindowsPath is obsolete, don't use it.
- * Check xmlCanonicPath in uri.h for a better alternative.
- */
-XMLPUBFUN xmlChar * XMLCALL
-	xmlNormalizeWindowsPath		(const xmlChar *path);
-
-XMLPUBFUN int XMLCALL
-	xmlCheckFilename		(const char *path);
-/**
- * Default 'file://' protocol callbacks
- */
-XMLPUBFUN int XMLCALL
-	xmlFileMatch			(const char *filename);
-XMLPUBFUN void * XMLCALL
-	xmlFileOpen			(const char *filename);
-XMLPUBFUN int XMLCALL
-	xmlFileRead			(void * context,
-					 char * buffer,
-					 int len);
-XMLPUBFUN int XMLCALL
-	xmlFileClose			(void * context);
-
-/**
- * Default 'http://' protocol callbacks
- */
-#ifdef LIBXML_HTTP_ENABLED
-XMLPUBFUN int XMLCALL
-	xmlIOHTTPMatch			(const char *filename);
-XMLPUBFUN void * XMLCALL
-	xmlIOHTTPOpen			(const char *filename);
-#ifdef LIBXML_OUTPUT_ENABLED
-XMLPUBFUN void * XMLCALL
-	xmlIOHTTPOpenW			(const char * post_uri,
-					 int   compression );
-#endif /* LIBXML_OUTPUT_ENABLED */
-XMLPUBFUN int XMLCALL
-	xmlIOHTTPRead			(void * context,
-					 char * buffer,
-					 int len);
-XMLPUBFUN int XMLCALL
-	xmlIOHTTPClose			(void * context);
-#endif /* LIBXML_HTTP_ENABLED */
-
-/**
- * Default 'ftp://' protocol callbacks
- */
-#ifdef LIBXML_FTP_ENABLED
-XMLPUBFUN int XMLCALL
-	xmlIOFTPMatch			(const char *filename);
-XMLPUBFUN void * XMLCALL
-	xmlIOFTPOpen			(const char *filename);
-XMLPUBFUN int XMLCALL
-	xmlIOFTPRead			(void * context,
-					 char * buffer,
-					 int len);
-XMLPUBFUN int XMLCALL
-	xmlIOFTPClose			(void * context);
-#endif /* LIBXML_FTP_ENABLED */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __XML_IO_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/xmlautomata.h

@@ -1,146 +0,0 @@
-/*
- * Summary: API to build regexp automata
- * Description: the API to build regexp automata
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#ifndef __XML_AUTOMATA_H__
-#define __XML_AUTOMATA_H__
-
-#include <libxml/xmlversion.h>
-#include <libxml/tree.h>
-
-#ifdef LIBXML_REGEXP_ENABLED
-#ifdef LIBXML_AUTOMATA_ENABLED
-#include <libxml/xmlregexp.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * xmlAutomataPtr:
- *
- * A libxml automata description, It can be compiled into a regexp
- */
-typedef struct _xmlAutomata xmlAutomata;
-typedef xmlAutomata *xmlAutomataPtr;
-
-/**
- * xmlAutomataStatePtr:
- *
- * A state int the automata description,
- */
-typedef struct _xmlAutomataState xmlAutomataState;
-typedef xmlAutomataState *xmlAutomataStatePtr;
-
-/*
- * Building API
- */
-XMLPUBFUN xmlAutomataPtr XMLCALL
-		    xmlNewAutomata		(void);
-XMLPUBFUN void XMLCALL
-		    xmlFreeAutomata		(xmlAutomataPtr am);
-
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-		    xmlAutomataGetInitState	(xmlAutomataPtr am);
-XMLPUBFUN int XMLCALL
-		    xmlAutomataSetFinalState	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr state);
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-		    xmlAutomataNewState		(xmlAutomataPtr am);
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-		    xmlAutomataNewTransition	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
-						 const xmlChar *token,
-						 void *data);
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-		    xmlAutomataNewTransition2	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
-						 const xmlChar *token,
-						 const xmlChar *token2,
-						 void *data);
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-                    xmlAutomataNewNegTrans	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
-						 const xmlChar *token,
-						 const xmlChar *token2,
-						 void *data);
-
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-		    xmlAutomataNewCountTrans	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
-						 const xmlChar *token,
-						 int min,
-						 int max,
-						 void *data);
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-		    xmlAutomataNewCountTrans2	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
-						 const xmlChar *token,
-						 const xmlChar *token2,
-						 int min,
-						 int max,
-						 void *data);
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-		    xmlAutomataNewOnceTrans	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
-						 const xmlChar *token,
-						 int min,
-						 int max,
-						 void *data);
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-		    xmlAutomataNewOnceTrans2	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
-						 const xmlChar *token,
-						 const xmlChar *token2,
-						 int min,
-						 int max,
-						 void *data);
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-		    xmlAutomataNewAllTrans	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
-						 int lax);
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-		    xmlAutomataNewEpsilon	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to);
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-		    xmlAutomataNewCountedTrans	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
-						 int counter);
-XMLPUBFUN xmlAutomataStatePtr XMLCALL
-		    xmlAutomataNewCounterTrans	(xmlAutomataPtr am,
-						 xmlAutomataStatePtr from,
-						 xmlAutomataStatePtr to,
-						 int counter);
-XMLPUBFUN int XMLCALL
-		    xmlAutomataNewCounter	(xmlAutomataPtr am,
-						 int min,
-						 int max);
-
-XMLPUBFUN xmlRegexpPtr XMLCALL
-		    xmlAutomataCompile		(xmlAutomataPtr am);
-XMLPUBFUN int XMLCALL
-		    xmlAutomataIsDeterminist	(xmlAutomataPtr am);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LIBXML_AUTOMATA_ENABLED */
-#endif /* LIBXML_REGEXP_ENABLED */
-
-#endif /* __XML_AUTOMATA_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/xmlerror.h

@@ -1,944 +0,0 @@
-/*
- * Summary: error handling
- * Description: the API used to report errors
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#include <libxml/parser.h>
-
-#ifndef __XML_ERROR_H__
-#define __XML_ERROR_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * xmlErrorLevel:
- *
- * Indicates the level of an error
- */
-typedef enum {
-    XML_ERR_NONE = 0,
-    XML_ERR_WARNING = 1,	/* A simple warning */
-    XML_ERR_ERROR = 2,		/* A recoverable error */
-    XML_ERR_FATAL = 3		/* A fatal error */
-} xmlErrorLevel;
-
-/**
- * xmlErrorDomain:
- *
- * Indicates where an error may have come from
- */
-typedef enum {
-    XML_FROM_NONE = 0,
-    XML_FROM_PARSER,	/* The XML parser */
-    XML_FROM_TREE,	/* The tree module */
-    XML_FROM_NAMESPACE,	/* The XML Namespace module */
-    XML_FROM_DTD,	/* The XML DTD validation with parser context*/
-    XML_FROM_HTML,	/* The HTML parser */
-    XML_FROM_MEMORY,	/* The memory allocator */
-    XML_FROM_OUTPUT,	/* The serialization code */
-    XML_FROM_IO,	/* The Input/Output stack */
-    XML_FROM_FTP,	/* The FTP module */
-    XML_FROM_HTTP,	/* The HTTP module */
-    XML_FROM_XINCLUDE,	/* The XInclude processing */
-    XML_FROM_XPATH,	/* The XPath module */
-    XML_FROM_XPOINTER,	/* The XPointer module */
-    XML_FROM_REGEXP,	/* The regular expressions module */
-    XML_FROM_DATATYPE,	/* The W3C XML Schemas Datatype module */
-    XML_FROM_SCHEMASP,	/* The W3C XML Schemas parser module */
-    XML_FROM_SCHEMASV,	/* The W3C XML Schemas validation module */
-    XML_FROM_RELAXNGP,	/* The Relax-NG parser module */
-    XML_FROM_RELAXNGV,	/* The Relax-NG validator module */
-    XML_FROM_CATALOG,	/* The Catalog module */
-    XML_FROM_C14N,	/* The Canonicalization module */
-    XML_FROM_XSLT,	/* The XSLT engine from libxslt */
-    XML_FROM_VALID,	/* The XML DTD validation with valid context */
-    XML_FROM_CHECK,	/* The error checking module */
-    XML_FROM_WRITER,	/* The xmlwriter module */
-    XML_FROM_MODULE,	/* The dynamically loaded module module*/
-    XML_FROM_I18N,	/* The module handling character conversion */
-    XML_FROM_SCHEMATRONV,/* The Schematron validator module */
-    XML_FROM_BUFFER,    /* The buffers module */
-    XML_FROM_URI        /* The URI module */
-} xmlErrorDomain;
-
-/**
- * xmlError:
- *
- * An XML Error instance.
- */
-
-typedef struct _xmlError xmlError;
-typedef xmlError *xmlErrorPtr;
-struct _xmlError {
-    int		domain;	/* What part of the library raised this error */
-    int		code;	/* The error code, e.g. an xmlParserError */
-    char       *message;/* human-readable informative error message */
-    xmlErrorLevel level;/* how consequent is the error */
-    char       *file;	/* the filename */
-    int		line;	/* the line number if available */
-    char       *str1;	/* extra string information */
-    char       *str2;	/* extra string information */
-    char       *str3;	/* extra string information */
-    int		int1;	/* extra number information */
-    int		int2;	/* column number of the error or 0 if N/A (todo: rename this field when we would break ABI) */
-    void       *ctxt;   /* the parser context if available */
-    void       *node;   /* the node in the tree */
-};
-
-/**
- * xmlParserError:
- *
- * This is an error that the XML (or HTML) parser can generate
- */
-typedef enum {
-    XML_ERR_OK = 0,
-    XML_ERR_INTERNAL_ERROR, /* 1 */
-    XML_ERR_NO_MEMORY, /* 2 */
-    XML_ERR_DOCUMENT_START, /* 3 */
-    XML_ERR_DOCUMENT_EMPTY, /* 4 */
-    XML_ERR_DOCUMENT_END, /* 5 */
-    XML_ERR_INVALID_HEX_CHARREF, /* 6 */
-    XML_ERR_INVALID_DEC_CHARREF, /* 7 */
-    XML_ERR_INVALID_CHARREF, /* 8 */
-    XML_ERR_INVALID_CHAR, /* 9 */
-    XML_ERR_CHARREF_AT_EOF, /* 10 */
-    XML_ERR_CHARREF_IN_PROLOG, /* 11 */
-    XML_ERR_CHARREF_IN_EPILOG, /* 12 */
-    XML_ERR_CHARREF_IN_DTD, /* 13 */
-    XML_ERR_ENTITYREF_AT_EOF, /* 14 */
-    XML_ERR_ENTITYREF_IN_PROLOG, /* 15 */
-    XML_ERR_ENTITYREF_IN_EPILOG, /* 16 */
-    XML_ERR_ENTITYREF_IN_DTD, /* 17 */
-    XML_ERR_PEREF_AT_EOF, /* 18 */
-    XML_ERR_PEREF_IN_PROLOG, /* 19 */
-    XML_ERR_PEREF_IN_EPILOG, /* 20 */
-    XML_ERR_PEREF_IN_INT_SUBSET, /* 21 */
-    XML_ERR_ENTITYREF_NO_NAME, /* 22 */
-    XML_ERR_ENTITYREF_SEMICOL_MISSING, /* 23 */
-    XML_ERR_PEREF_NO_NAME, /* 24 */
-    XML_ERR_PEREF_SEMICOL_MISSING, /* 25 */
-    XML_ERR_UNDECLARED_ENTITY, /* 26 */
-    XML_WAR_UNDECLARED_ENTITY, /* 27 */
-    XML_ERR_UNPARSED_ENTITY, /* 28 */
-    XML_ERR_ENTITY_IS_EXTERNAL, /* 29 */
-    XML_ERR_ENTITY_IS_PARAMETER, /* 30 */
-    XML_ERR_UNKNOWN_ENCODING, /* 31 */
-    XML_ERR_UNSUPPORTED_ENCODING, /* 32 */
-    XML_ERR_STRING_NOT_STARTED, /* 33 */
-    XML_ERR_STRING_NOT_CLOSED, /* 34 */
-    XML_ERR_NS_DECL_ERROR, /* 35 */
-    XML_ERR_ENTITY_NOT_STARTED, /* 36 */
-    XML_ERR_ENTITY_NOT_FINISHED, /* 37 */
-    XML_ERR_LT_IN_ATTRIBUTE, /* 38 */
-    XML_ERR_ATTRIBUTE_NOT_STARTED, /* 39 */
-    XML_ERR_ATTRIBUTE_NOT_FINISHED, /* 40 */
-    XML_ERR_ATTRIBUTE_WITHOUT_VALUE, /* 41 */
-    XML_ERR_ATTRIBUTE_REDEFINED, /* 42 */
-    XML_ERR_LITERAL_NOT_STARTED, /* 43 */
-    XML_ERR_LITERAL_NOT_FINISHED, /* 44 */
-    XML_ERR_COMMENT_NOT_FINISHED, /* 45 */
-    XML_ERR_PI_NOT_STARTED, /* 46 */
-    XML_ERR_PI_NOT_FINISHED, /* 47 */
-    XML_ERR_NOTATION_NOT_STARTED, /* 48 */
-    XML_ERR_NOTATION_NOT_FINISHED, /* 49 */
-    XML_ERR_ATTLIST_NOT_STARTED, /* 50 */
-    XML_ERR_ATTLIST_NOT_FINISHED, /* 51 */
-    XML_ERR_MIXED_NOT_STARTED, /* 52 */
-    XML_ERR_MIXED_NOT_FINISHED, /* 53 */
-    XML_ERR_ELEMCONTENT_NOT_STARTED, /* 54 */
-    XML_ERR_ELEMCONTENT_NOT_FINISHED, /* 55 */
-    XML_ERR_XMLDECL_NOT_STARTED, /* 56 */
-    XML_ERR_XMLDECL_NOT_FINISHED, /* 57 */
-    XML_ERR_CONDSEC_NOT_STARTED, /* 58 */
-    XML_ERR_CONDSEC_NOT_FINISHED, /* 59 */
-    XML_ERR_EXT_SUBSET_NOT_FINISHED, /* 60 */
-    XML_ERR_DOCTYPE_NOT_FINISHED, /* 61 */
-    XML_ERR_MISPLACED_CDATA_END, /* 62 */
-    XML_ERR_CDATA_NOT_FINISHED, /* 63 */
-    XML_ERR_RESERVED_XML_NAME, /* 64 */
-    XML_ERR_SPACE_REQUIRED, /* 65 */
-    XML_ERR_SEPARATOR_REQUIRED, /* 66 */
-    XML_ERR_NMTOKEN_REQUIRED, /* 67 */
-    XML_ERR_NAME_REQUIRED, /* 68 */
-    XML_ERR_PCDATA_REQUIRED, /* 69 */
-    XML_ERR_URI_REQUIRED, /* 70 */
-    XML_ERR_PUBID_REQUIRED, /* 71 */
-    XML_ERR_LT_REQUIRED, /* 72 */
-    XML_ERR_GT_REQUIRED, /* 73 */
-    XML_ERR_LTSLASH_REQUIRED, /* 74 */
-    XML_ERR_EQUAL_REQUIRED, /* 75 */
-    XML_ERR_TAG_NAME_MISMATCH, /* 76 */
-    XML_ERR_TAG_NOT_FINISHED, /* 77 */
-    XML_ERR_STANDALONE_VALUE, /* 78 */
-    XML_ERR_ENCODING_NAME, /* 79 */
-    XML_ERR_HYPHEN_IN_COMMENT, /* 80 */
-    XML_ERR_INVALID_ENCODING, /* 81 */
-    XML_ERR_EXT_ENTITY_STANDALONE, /* 82 */
-    XML_ERR_CONDSEC_INVALID, /* 83 */
-    XML_ERR_VALUE_REQUIRED, /* 84 */
-    XML_ERR_NOT_WELL_BALANCED, /* 85 */
-    XML_ERR_EXTRA_CONTENT, /* 86 */
-    XML_ERR_ENTITY_CHAR_ERROR, /* 87 */
-    XML_ERR_ENTITY_PE_INTERNAL, /* 88 */
-    XML_ERR_ENTITY_LOOP, /* 89 */
-    XML_ERR_ENTITY_BOUNDARY, /* 90 */
-    XML_ERR_INVALID_URI, /* 91 */
-    XML_ERR_URI_FRAGMENT, /* 92 */
-    XML_WAR_CATALOG_PI, /* 93 */
-    XML_ERR_NO_DTD, /* 94 */
-    XML_ERR_CONDSEC_INVALID_KEYWORD, /* 95 */
-    XML_ERR_VERSION_MISSING, /* 96 */
-    XML_WAR_UNKNOWN_VERSION, /* 97 */
-    XML_WAR_LANG_VALUE, /* 98 */
-    XML_WAR_NS_URI, /* 99 */
-    XML_WAR_NS_URI_RELATIVE, /* 100 */
-    XML_ERR_MISSING_ENCODING, /* 101 */
-    XML_WAR_SPACE_VALUE, /* 102 */
-    XML_ERR_NOT_STANDALONE, /* 103 */
-    XML_ERR_ENTITY_PROCESSING, /* 104 */
-    XML_ERR_NOTATION_PROCESSING, /* 105 */
-    XML_WAR_NS_COLUMN, /* 106 */
-    XML_WAR_ENTITY_REDEFINED, /* 107 */
-    XML_ERR_UNKNOWN_VERSION, /* 108 */
-    XML_ERR_VERSION_MISMATCH, /* 109 */
-    XML_ERR_NAME_TOO_LONG, /* 110 */
-    XML_NS_ERR_XML_NAMESPACE = 200,
-    XML_NS_ERR_UNDEFINED_NAMESPACE, /* 201 */
-    XML_NS_ERR_QNAME, /* 202 */
-    XML_NS_ERR_ATTRIBUTE_REDEFINED, /* 203 */
-    XML_NS_ERR_EMPTY, /* 204 */
-    XML_NS_ERR_COLON, /* 205 */
-    XML_DTD_ATTRIBUTE_DEFAULT = 500,
-    XML_DTD_ATTRIBUTE_REDEFINED, /* 501 */
-    XML_DTD_ATTRIBUTE_VALUE, /* 502 */
-    XML_DTD_CONTENT_ERROR, /* 503 */
-    XML_DTD_CONTENT_MODEL, /* 504 */
-    XML_DTD_CONTENT_NOT_DETERMINIST, /* 505 */
-    XML_DTD_DIFFERENT_PREFIX, /* 506 */
-    XML_DTD_ELEM_DEFAULT_NAMESPACE, /* 507 */
-    XML_DTD_ELEM_NAMESPACE, /* 508 */
-    XML_DTD_ELEM_REDEFINED, /* 509 */
-    XML_DTD_EMPTY_NOTATION, /* 510 */
-    XML_DTD_ENTITY_TYPE, /* 511 */
-    XML_DTD_ID_FIXED, /* 512 */
-    XML_DTD_ID_REDEFINED, /* 513 */
-    XML_DTD_ID_SUBSET, /* 514 */
-    XML_DTD_INVALID_CHILD, /* 515 */
-    XML_DTD_INVALID_DEFAULT, /* 516 */
-    XML_DTD_LOAD_ERROR, /* 517 */
-    XML_DTD_MISSING_ATTRIBUTE, /* 518 */
-    XML_DTD_MIXED_CORRUPT, /* 519 */
-    XML_DTD_MULTIPLE_ID, /* 520 */
-    XML_DTD_NO_DOC, /* 521 */
-    XML_DTD_NO_DTD, /* 522 */
-    XML_DTD_NO_ELEM_NAME, /* 523 */
-    XML_DTD_NO_PREFIX, /* 524 */
-    XML_DTD_NO_ROOT, /* 525 */
-    XML_DTD_NOTATION_REDEFINED, /* 526 */
-    XML_DTD_NOTATION_VALUE, /* 527 */
-    XML_DTD_NOT_EMPTY, /* 528 */
-    XML_DTD_NOT_PCDATA, /* 529 */
-    XML_DTD_NOT_STANDALONE, /* 530 */
-    XML_DTD_ROOT_NAME, /* 531 */
-    XML_DTD_STANDALONE_WHITE_SPACE, /* 532 */
-    XML_DTD_UNKNOWN_ATTRIBUTE, /* 533 */
-    XML_DTD_UNKNOWN_ELEM, /* 534 */
-    XML_DTD_UNKNOWN_ENTITY, /* 535 */
-    XML_DTD_UNKNOWN_ID, /* 536 */
-    XML_DTD_UNKNOWN_NOTATION, /* 537 */
-    XML_DTD_STANDALONE_DEFAULTED, /* 538 */
-    XML_DTD_XMLID_VALUE, /* 539 */
-    XML_DTD_XMLID_TYPE, /* 540 */
-    XML_DTD_DUP_TOKEN, /* 541 */
-    XML_HTML_STRUCURE_ERROR = 800,
-    XML_HTML_UNKNOWN_TAG, /* 801 */
-    XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000,
-    XML_RNGP_ATTR_CONFLICT, /* 1001 */
-    XML_RNGP_ATTRIBUTE_CHILDREN, /* 1002 */
-    XML_RNGP_ATTRIBUTE_CONTENT, /* 1003 */
-    XML_RNGP_ATTRIBUTE_EMPTY, /* 1004 */
-    XML_RNGP_ATTRIBUTE_NOOP, /* 1005 */
-    XML_RNGP_CHOICE_CONTENT, /* 1006 */
-    XML_RNGP_CHOICE_EMPTY, /* 1007 */
-    XML_RNGP_CREATE_FAILURE, /* 1008 */
-    XML_RNGP_DATA_CONTENT, /* 1009 */
-    XML_RNGP_DEF_CHOICE_AND_INTERLEAVE, /* 1010 */
-    XML_RNGP_DEFINE_CREATE_FAILED, /* 1011 */
-    XML_RNGP_DEFINE_EMPTY, /* 1012 */
-    XML_RNGP_DEFINE_MISSING, /* 1013 */
-    XML_RNGP_DEFINE_NAME_MISSING, /* 1014 */
-    XML_RNGP_ELEM_CONTENT_EMPTY, /* 1015 */
-    XML_RNGP_ELEM_CONTENT_ERROR, /* 1016 */
-    XML_RNGP_ELEMENT_EMPTY, /* 1017 */
-    XML_RNGP_ELEMENT_CONTENT, /* 1018 */
-    XML_RNGP_ELEMENT_NAME, /* 1019 */
-    XML_RNGP_ELEMENT_NO_CONTENT, /* 1020 */
-    XML_RNGP_ELEM_TEXT_CONFLICT, /* 1021 */
-    XML_RNGP_EMPTY, /* 1022 */
-    XML_RNGP_EMPTY_CONSTRUCT, /* 1023 */
-    XML_RNGP_EMPTY_CONTENT, /* 1024 */
-    XML_RNGP_EMPTY_NOT_EMPTY, /* 1025 */
-    XML_RNGP_ERROR_TYPE_LIB, /* 1026 */
-    XML_RNGP_EXCEPT_EMPTY, /* 1027 */
-    XML_RNGP_EXCEPT_MISSING, /* 1028 */
-    XML_RNGP_EXCEPT_MULTIPLE, /* 1029 */
-    XML_RNGP_EXCEPT_NO_CONTENT, /* 1030 */
-    XML_RNGP_EXTERNALREF_EMTPY, /* 1031 */
-    XML_RNGP_EXTERNAL_REF_FAILURE, /* 1032 */
-    XML_RNGP_EXTERNALREF_RECURSE, /* 1033 */
-    XML_RNGP_FORBIDDEN_ATTRIBUTE, /* 1034 */
-    XML_RNGP_FOREIGN_ELEMENT, /* 1035 */
-    XML_RNGP_GRAMMAR_CONTENT, /* 1036 */
-    XML_RNGP_GRAMMAR_EMPTY, /* 1037 */
-    XML_RNGP_GRAMMAR_MISSING, /* 1038 */
-    XML_RNGP_GRAMMAR_NO_START, /* 1039 */
-    XML_RNGP_GROUP_ATTR_CONFLICT, /* 1040 */
-    XML_RNGP_HREF_ERROR, /* 1041 */
-    XML_RNGP_INCLUDE_EMPTY, /* 1042 */
-    XML_RNGP_INCLUDE_FAILURE, /* 1043 */
-    XML_RNGP_INCLUDE_RECURSE, /* 1044 */
-    XML_RNGP_INTERLEAVE_ADD, /* 1045 */
-    XML_RNGP_INTERLEAVE_CREATE_FAILED, /* 1046 */
-    XML_RNGP_INTERLEAVE_EMPTY, /* 1047 */
-    XML_RNGP_INTERLEAVE_NO_CONTENT, /* 1048 */
-    XML_RNGP_INVALID_DEFINE_NAME, /* 1049 */
-    XML_RNGP_INVALID_URI, /* 1050 */
-    XML_RNGP_INVALID_VALUE, /* 1051 */
-    XML_RNGP_MISSING_HREF, /* 1052 */
-    XML_RNGP_NAME_MISSING, /* 1053 */
-    XML_RNGP_NEED_COMBINE, /* 1054 */
-    XML_RNGP_NOTALLOWED_NOT_EMPTY, /* 1055 */
-    XML_RNGP_NSNAME_ATTR_ANCESTOR, /* 1056 */
-    XML_RNGP_NSNAME_NO_NS, /* 1057 */
-    XML_RNGP_PARAM_FORBIDDEN, /* 1058 */
-    XML_RNGP_PARAM_NAME_MISSING, /* 1059 */
-    XML_RNGP_PARENTREF_CREATE_FAILED, /* 1060 */
-    XML_RNGP_PARENTREF_NAME_INVALID, /* 1061 */
-    XML_RNGP_PARENTREF_NO_NAME, /* 1062 */
-    XML_RNGP_PARENTREF_NO_PARENT, /* 1063 */
-    XML_RNGP_PARENTREF_NOT_EMPTY, /* 1064 */
-    XML_RNGP_PARSE_ERROR, /* 1065 */
-    XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME, /* 1066 */
-    XML_RNGP_PAT_ATTR_ATTR, /* 1067 */
-    XML_RNGP_PAT_ATTR_ELEM, /* 1068 */
-    XML_RNGP_PAT_DATA_EXCEPT_ATTR, /* 1069 */
-    XML_RNGP_PAT_DATA_EXCEPT_ELEM, /* 1070 */
-    XML_RNGP_PAT_DATA_EXCEPT_EMPTY, /* 1071 */
-    XML_RNGP_PAT_DATA_EXCEPT_GROUP, /* 1072 */
-    XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE, /* 1073 */
-    XML_RNGP_PAT_DATA_EXCEPT_LIST, /* 1074 */
-    XML_RNGP_PAT_DATA_EXCEPT_ONEMORE, /* 1075 */
-    XML_RNGP_PAT_DATA_EXCEPT_REF, /* 1076 */
-    XML_RNGP_PAT_DATA_EXCEPT_TEXT, /* 1077 */
-    XML_RNGP_PAT_LIST_ATTR, /* 1078 */
-    XML_RNGP_PAT_LIST_ELEM, /* 1079 */
-    XML_RNGP_PAT_LIST_INTERLEAVE, /* 1080 */
-    XML_RNGP_PAT_LIST_LIST, /* 1081 */
-    XML_RNGP_PAT_LIST_REF, /* 1082 */
-    XML_RNGP_PAT_LIST_TEXT, /* 1083 */
-    XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME, /* 1084 */
-    XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME, /* 1085 */
-    XML_RNGP_PAT_ONEMORE_GROUP_ATTR, /* 1086 */
-    XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR, /* 1087 */
-    XML_RNGP_PAT_START_ATTR, /* 1088 */
-    XML_RNGP_PAT_START_DATA, /* 1089 */
-    XML_RNGP_PAT_START_EMPTY, /* 1090 */
-    XML_RNGP_PAT_START_GROUP, /* 1091 */
-    XML_RNGP_PAT_START_INTERLEAVE, /* 1092 */
-    XML_RNGP_PAT_START_LIST, /* 1093 */
-    XML_RNGP_PAT_START_ONEMORE, /* 1094 */
-    XML_RNGP_PAT_START_TEXT, /* 1095 */
-    XML_RNGP_PAT_START_VALUE, /* 1096 */
-    XML_RNGP_PREFIX_UNDEFINED, /* 1097 */
-    XML_RNGP_REF_CREATE_FAILED, /* 1098 */
-    XML_RNGP_REF_CYCLE, /* 1099 */
-    XML_RNGP_REF_NAME_INVALID, /* 1100 */
-    XML_RNGP_REF_NO_DEF, /* 1101 */
-    XML_RNGP_REF_NO_NAME, /* 1102 */
-    XML_RNGP_REF_NOT_EMPTY, /* 1103 */
-    XML_RNGP_START_CHOICE_AND_INTERLEAVE, /* 1104 */
-    XML_RNGP_START_CONTENT, /* 1105 */
-    XML_RNGP_START_EMPTY, /* 1106 */
-    XML_RNGP_START_MISSING, /* 1107 */
-    XML_RNGP_TEXT_EXPECTED, /* 1108 */
-    XML_RNGP_TEXT_HAS_CHILD, /* 1109 */
-    XML_RNGP_TYPE_MISSING, /* 1110 */
-    XML_RNGP_TYPE_NOT_FOUND, /* 1111 */
-    XML_RNGP_TYPE_VALUE, /* 1112 */
-    XML_RNGP_UNKNOWN_ATTRIBUTE, /* 1113 */
-    XML_RNGP_UNKNOWN_COMBINE, /* 1114 */
-    XML_RNGP_UNKNOWN_CONSTRUCT, /* 1115 */
-    XML_RNGP_UNKNOWN_TYPE_LIB, /* 1116 */
-    XML_RNGP_URI_FRAGMENT, /* 1117 */
-    XML_RNGP_URI_NOT_ABSOLUTE, /* 1118 */
-    XML_RNGP_VALUE_EMPTY, /* 1119 */
-    XML_RNGP_VALUE_NO_CONTENT, /* 1120 */
-    XML_RNGP_XMLNS_NAME, /* 1121 */
-    XML_RNGP_XML_NS, /* 1122 */
-    XML_XPATH_EXPRESSION_OK = 1200,
-    XML_XPATH_NUMBER_ERROR, /* 1201 */
-    XML_XPATH_UNFINISHED_LITERAL_ERROR, /* 1202 */
-    XML_XPATH_START_LITERAL_ERROR, /* 1203 */
-    XML_XPATH_VARIABLE_REF_ERROR, /* 1204 */
-    XML_XPATH_UNDEF_VARIABLE_ERROR, /* 1205 */
-    XML_XPATH_INVALID_PREDICATE_ERROR, /* 1206 */
-    XML_XPATH_EXPR_ERROR, /* 1207 */
-    XML_XPATH_UNCLOSED_ERROR, /* 1208 */
-    XML_XPATH_UNKNOWN_FUNC_ERROR, /* 1209 */
-    XML_XPATH_INVALID_OPERAND, /* 1210 */
-    XML_XPATH_INVALID_TYPE, /* 1211 */
-    XML_XPATH_INVALID_ARITY, /* 1212 */
-    XML_XPATH_INVALID_CTXT_SIZE, /* 1213 */
-    XML_XPATH_INVALID_CTXT_POSITION, /* 1214 */
-    XML_XPATH_MEMORY_ERROR, /* 1215 */
-    XML_XPTR_SYNTAX_ERROR, /* 1216 */
-    XML_XPTR_RESOURCE_ERROR, /* 1217 */
-    XML_XPTR_SUB_RESOURCE_ERROR, /* 1218 */
-    XML_XPATH_UNDEF_PREFIX_ERROR, /* 1219 */
-    XML_XPATH_ENCODING_ERROR, /* 1220 */
-    XML_XPATH_INVALID_CHAR_ERROR, /* 1221 */
-    XML_TREE_INVALID_HEX = 1300,
-    XML_TREE_INVALID_DEC, /* 1301 */
-    XML_TREE_UNTERMINATED_ENTITY, /* 1302 */
-    XML_TREE_NOT_UTF8, /* 1303 */
-    XML_SAVE_NOT_UTF8 = 1400,
-    XML_SAVE_CHAR_INVALID, /* 1401 */
-    XML_SAVE_NO_DOCTYPE, /* 1402 */
-    XML_SAVE_UNKNOWN_ENCODING, /* 1403 */
-    XML_REGEXP_COMPILE_ERROR = 1450,
-    XML_IO_UNKNOWN = 1500,
-    XML_IO_EACCES, /* 1501 */
-    XML_IO_EAGAIN, /* 1502 */
-    XML_IO_EBADF, /* 1503 */
-    XML_IO_EBADMSG, /* 1504 */
-    XML_IO_EBUSY, /* 1505 */
-    XML_IO_ECANCELED, /* 1506 */
-    XML_IO_ECHILD, /* 1507 */
-    XML_IO_EDEADLK, /* 1508 */
-    XML_IO_EDOM, /* 1509 */
-    XML_IO_EEXIST, /* 1510 */
-    XML_IO_EFAULT, /* 1511 */
-    XML_IO_EFBIG, /* 1512 */
-    XML_IO_EINPROGRESS, /* 1513 */
-    XML_IO_EINTR, /* 1514 */
-    XML_IO_EINVAL, /* 1515 */
-    XML_IO_EIO, /* 1516 */
-    XML_IO_EISDIR, /* 1517 */
-    XML_IO_EMFILE, /* 1518 */
-    XML_IO_EMLINK, /* 1519 */
-    XML_IO_EMSGSIZE, /* 1520 */
-    XML_IO_ENAMETOOLONG, /* 1521 */
-    XML_IO_ENFILE, /* 1522 */
-    XML_IO_ENODEV, /* 1523 */
-    XML_IO_ENOENT, /* 1524 */
-    XML_IO_ENOEXEC, /* 1525 */
-    XML_IO_ENOLCK, /* 1526 */
-    XML_IO_ENOMEM, /* 1527 */
-    XML_IO_ENOSPC, /* 1528 */
-    XML_IO_ENOSYS, /* 1529 */
-    XML_IO_ENOTDIR, /* 1530 */
-    XML_IO_ENOTEMPTY, /* 1531 */
-    XML_IO_ENOTSUP, /* 1532 */
-    XML_IO_ENOTTY, /* 1533 */
-    XML_IO_ENXIO, /* 1534 */
-    XML_IO_EPERM, /* 1535 */
-    XML_IO_EPIPE, /* 1536 */
-    XML_IO_ERANGE, /* 1537 */
-    XML_IO_EROFS, /* 1538 */
-    XML_IO_ESPIPE, /* 1539 */
-    XML_IO_ESRCH, /* 1540 */
-    XML_IO_ETIMEDOUT, /* 1541 */
-    XML_IO_EXDEV, /* 1542 */
-    XML_IO_NETWORK_ATTEMPT, /* 1543 */
-    XML_IO_ENCODER, /* 1544 */
-    XML_IO_FLUSH, /* 1545 */
-    XML_IO_WRITE, /* 1546 */
-    XML_IO_NO_INPUT, /* 1547 */
-    XML_IO_BUFFER_FULL, /* 1548 */
-    XML_IO_LOAD_ERROR, /* 1549 */
-    XML_IO_ENOTSOCK, /* 1550 */
-    XML_IO_EISCONN, /* 1551 */
-    XML_IO_ECONNREFUSED, /* 1552 */
-    XML_IO_ENETUNREACH, /* 1553 */
-    XML_IO_EADDRINUSE, /* 1554 */
-    XML_IO_EALREADY, /* 1555 */
-    XML_IO_EAFNOSUPPORT, /* 1556 */
-    XML_XINCLUDE_RECURSION=1600,
-    XML_XINCLUDE_PARSE_VALUE, /* 1601 */
-    XML_XINCLUDE_ENTITY_DEF_MISMATCH, /* 1602 */
-    XML_XINCLUDE_NO_HREF, /* 1603 */
-    XML_XINCLUDE_NO_FALLBACK, /* 1604 */
-    XML_XINCLUDE_HREF_URI, /* 1605 */
-    XML_XINCLUDE_TEXT_FRAGMENT, /* 1606 */
-    XML_XINCLUDE_TEXT_DOCUMENT, /* 1607 */
-    XML_XINCLUDE_INVALID_CHAR, /* 1608 */
-    XML_XINCLUDE_BUILD_FAILED, /* 1609 */
-    XML_XINCLUDE_UNKNOWN_ENCODING, /* 1610 */
-    XML_XINCLUDE_MULTIPLE_ROOT, /* 1611 */
-    XML_XINCLUDE_XPTR_FAILED, /* 1612 */
-    XML_XINCLUDE_XPTR_RESULT, /* 1613 */
-    XML_XINCLUDE_INCLUDE_IN_INCLUDE, /* 1614 */
-    XML_XINCLUDE_FALLBACKS_IN_INCLUDE, /* 1615 */
-    XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE, /* 1616 */
-    XML_XINCLUDE_DEPRECATED_NS, /* 1617 */
-    XML_XINCLUDE_FRAGMENT_ID, /* 1618 */
-    XML_CATALOG_MISSING_ATTR = 1650,
-    XML_CATALOG_ENTRY_BROKEN, /* 1651 */
-    XML_CATALOG_PREFER_VALUE, /* 1652 */
-    XML_CATALOG_NOT_CATALOG, /* 1653 */
-    XML_CATALOG_RECURSION, /* 1654 */
-    XML_SCHEMAP_PREFIX_UNDEFINED = 1700,
-    XML_SCHEMAP_ATTRFORMDEFAULT_VALUE, /* 1701 */
-    XML_SCHEMAP_ATTRGRP_NONAME_NOREF, /* 1702 */
-    XML_SCHEMAP_ATTR_NONAME_NOREF, /* 1703 */
-    XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF, /* 1704 */
-    XML_SCHEMAP_ELEMFORMDEFAULT_VALUE, /* 1705 */
-    XML_SCHEMAP_ELEM_NONAME_NOREF, /* 1706 */
-    XML_SCHEMAP_EXTENSION_NO_BASE, /* 1707 */
-    XML_SCHEMAP_FACET_NO_VALUE, /* 1708 */
-    XML_SCHEMAP_FAILED_BUILD_IMPORT, /* 1709 */
-    XML_SCHEMAP_GROUP_NONAME_NOREF, /* 1710 */
-    XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI, /* 1711 */
-    XML_SCHEMAP_IMPORT_REDEFINE_NSNAME, /* 1712 */
-    XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI, /* 1713 */
-    XML_SCHEMAP_INVALID_BOOLEAN, /* 1714 */
-    XML_SCHEMAP_INVALID_ENUM, /* 1715 */
-    XML_SCHEMAP_INVALID_FACET, /* 1716 */
-    XML_SCHEMAP_INVALID_FACET_VALUE, /* 1717 */
-    XML_SCHEMAP_INVALID_MAXOCCURS, /* 1718 */
-    XML_SCHEMAP_INVALID_MINOCCURS, /* 1719 */
-    XML_SCHEMAP_INVALID_REF_AND_SUBTYPE, /* 1720 */
-    XML_SCHEMAP_INVALID_WHITE_SPACE, /* 1721 */
-    XML_SCHEMAP_NOATTR_NOREF, /* 1722 */
-    XML_SCHEMAP_NOTATION_NO_NAME, /* 1723 */
-    XML_SCHEMAP_NOTYPE_NOREF, /* 1724 */
-    XML_SCHEMAP_REF_AND_SUBTYPE, /* 1725 */
-    XML_SCHEMAP_RESTRICTION_NONAME_NOREF, /* 1726 */
-    XML_SCHEMAP_SIMPLETYPE_NONAME, /* 1727 */
-    XML_SCHEMAP_TYPE_AND_SUBTYPE, /* 1728 */
-    XML_SCHEMAP_UNKNOWN_ALL_CHILD, /* 1729 */
-    XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD, /* 1730 */
-    XML_SCHEMAP_UNKNOWN_ATTR_CHILD, /* 1731 */
-    XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD, /* 1732 */
-    XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP, /* 1733 */
-    XML_SCHEMAP_UNKNOWN_BASE_TYPE, /* 1734 */
-    XML_SCHEMAP_UNKNOWN_CHOICE_CHILD, /* 1735 */
-    XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD, /* 1736 */
-    XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD, /* 1737 */
-    XML_SCHEMAP_UNKNOWN_ELEM_CHILD, /* 1738 */
-    XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD, /* 1739 */
-    XML_SCHEMAP_UNKNOWN_FACET_CHILD, /* 1740 */
-    XML_SCHEMAP_UNKNOWN_FACET_TYPE, /* 1741 */
-    XML_SCHEMAP_UNKNOWN_GROUP_CHILD, /* 1742 */
-    XML_SCHEMAP_UNKNOWN_IMPORT_CHILD, /* 1743 */
-    XML_SCHEMAP_UNKNOWN_LIST_CHILD, /* 1744 */
-    XML_SCHEMAP_UNKNOWN_NOTATION_CHILD, /* 1745 */
-    XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD, /* 1746 */
-    XML_SCHEMAP_UNKNOWN_REF, /* 1747 */
-    XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD, /* 1748 */
-    XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD, /* 1749 */
-    XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD, /* 1750 */
-    XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD, /* 1751 */
-    XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD, /* 1752 */
-    XML_SCHEMAP_UNKNOWN_TYPE, /* 1753 */
-    XML_SCHEMAP_UNKNOWN_UNION_CHILD, /* 1754 */
-    XML_SCHEMAP_ELEM_DEFAULT_FIXED, /* 1755 */
-    XML_SCHEMAP_REGEXP_INVALID, /* 1756 */
-    XML_SCHEMAP_FAILED_LOAD, /* 1757 */
-    XML_SCHEMAP_NOTHING_TO_PARSE, /* 1758 */
-    XML_SCHEMAP_NOROOT, /* 1759 */
-    XML_SCHEMAP_REDEFINED_GROUP, /* 1760 */
-    XML_SCHEMAP_REDEFINED_TYPE, /* 1761 */
-    XML_SCHEMAP_REDEFINED_ELEMENT, /* 1762 */
-    XML_SCHEMAP_REDEFINED_ATTRGROUP, /* 1763 */
-    XML_SCHEMAP_REDEFINED_ATTR, /* 1764 */
-    XML_SCHEMAP_REDEFINED_NOTATION, /* 1765 */
-    XML_SCHEMAP_FAILED_PARSE, /* 1766 */
-    XML_SCHEMAP_UNKNOWN_PREFIX, /* 1767 */
-    XML_SCHEMAP_DEF_AND_PREFIX, /* 1768 */
-    XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD, /* 1769 */
-    XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI, /* 1770 */
-    XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI, /* 1771 */
-    XML_SCHEMAP_NOT_SCHEMA, /* 1772 */
-    XML_SCHEMAP_UNKNOWN_MEMBER_TYPE, /* 1773 */
-    XML_SCHEMAP_INVALID_ATTR_USE, /* 1774 */
-    XML_SCHEMAP_RECURSIVE, /* 1775 */
-    XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE, /* 1776 */
-    XML_SCHEMAP_INVALID_ATTR_COMBINATION, /* 1777 */
-    XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION, /* 1778 */
-    XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD, /* 1779 */
-    XML_SCHEMAP_INVALID_ATTR_NAME, /* 1780 */
-    XML_SCHEMAP_REF_AND_CONTENT, /* 1781 */
-    XML_SCHEMAP_CT_PROPS_CORRECT_1, /* 1782 */
-    XML_SCHEMAP_CT_PROPS_CORRECT_2, /* 1783 */
-    XML_SCHEMAP_CT_PROPS_CORRECT_3, /* 1784 */
-    XML_SCHEMAP_CT_PROPS_CORRECT_4, /* 1785 */
-    XML_SCHEMAP_CT_PROPS_CORRECT_5, /* 1786 */
-    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1, /* 1787 */
-    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1, /* 1788 */
-    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2, /* 1789 */
-    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2, /* 1790 */
-    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3, /* 1791 */
-    XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER, /* 1792 */
-    XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE, /* 1793 */
-    XML_SCHEMAP_UNION_NOT_EXPRESSIBLE, /* 1794 */
-    XML_SCHEMAP_SRC_IMPORT_3_1, /* 1795 */
-    XML_SCHEMAP_SRC_IMPORT_3_2, /* 1796 */
-    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1, /* 1797 */
-    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2, /* 1798 */
-    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3, /* 1799 */
-    XML_SCHEMAP_COS_CT_EXTENDS_1_3, /* 1800 */
-    XML_SCHEMAV_NOROOT = 1801,
-    XML_SCHEMAV_UNDECLAREDELEM, /* 1802 */
-    XML_SCHEMAV_NOTTOPLEVEL, /* 1803 */
-    XML_SCHEMAV_MISSING, /* 1804 */
-    XML_SCHEMAV_WRONGELEM, /* 1805 */
-    XML_SCHEMAV_NOTYPE, /* 1806 */
-    XML_SCHEMAV_NOROLLBACK, /* 1807 */
-    XML_SCHEMAV_ISABSTRACT, /* 1808 */
-    XML_SCHEMAV_NOTEMPTY, /* 1809 */
-    XML_SCHEMAV_ELEMCONT, /* 1810 */
-    XML_SCHEMAV_HAVEDEFAULT, /* 1811 */
-    XML_SCHEMAV_NOTNILLABLE, /* 1812 */
-    XML_SCHEMAV_EXTRACONTENT, /* 1813 */
-    XML_SCHEMAV_INVALIDATTR, /* 1814 */
-    XML_SCHEMAV_INVALIDELEM, /* 1815 */
-    XML_SCHEMAV_NOTDETERMINIST, /* 1816 */
-    XML_SCHEMAV_CONSTRUCT, /* 1817 */
-    XML_SCHEMAV_INTERNAL, /* 1818 */
-    XML_SCHEMAV_NOTSIMPLE, /* 1819 */
-    XML_SCHEMAV_ATTRUNKNOWN, /* 1820 */
-    XML_SCHEMAV_ATTRINVALID, /* 1821 */
-    XML_SCHEMAV_VALUE, /* 1822 */
-    XML_SCHEMAV_FACET, /* 1823 */
-    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1, /* 1824 */
-    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2, /* 1825 */
-    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3, /* 1826 */
-    XML_SCHEMAV_CVC_TYPE_3_1_1, /* 1827 */
-    XML_SCHEMAV_CVC_TYPE_3_1_2, /* 1828 */
-    XML_SCHEMAV_CVC_FACET_VALID, /* 1829 */
-    XML_SCHEMAV_CVC_LENGTH_VALID, /* 1830 */
-    XML_SCHEMAV_CVC_MINLENGTH_VALID, /* 1831 */
-    XML_SCHEMAV_CVC_MAXLENGTH_VALID, /* 1832 */
-    XML_SCHEMAV_CVC_MININCLUSIVE_VALID, /* 1833 */
-    XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID, /* 1834 */
-    XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID, /* 1835 */
-    XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID, /* 1836 */
-    XML_SCHEMAV_CVC_TOTALDIGITS_VALID, /* 1837 */
-    XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID, /* 1838 */
-    XML_SCHEMAV_CVC_PATTERN_VALID, /* 1839 */
-    XML_SCHEMAV_CVC_ENUMERATION_VALID, /* 1840 */
-    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1, /* 1841 */
-    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2, /* 1842 */
-    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3, /* 1843 */
-    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4, /* 1844 */
-    XML_SCHEMAV_CVC_ELT_1, /* 1845 */
-    XML_SCHEMAV_CVC_ELT_2, /* 1846 */
-    XML_SCHEMAV_CVC_ELT_3_1, /* 1847 */
-    XML_SCHEMAV_CVC_ELT_3_2_1, /* 1848 */
-    XML_SCHEMAV_CVC_ELT_3_2_2, /* 1849 */
-    XML_SCHEMAV_CVC_ELT_4_1, /* 1850 */
-    XML_SCHEMAV_CVC_ELT_4_2, /* 1851 */
-    XML_SCHEMAV_CVC_ELT_4_3, /* 1852 */
-    XML_SCHEMAV_CVC_ELT_5_1_1, /* 1853 */
-    XML_SCHEMAV_CVC_ELT_5_1_2, /* 1854 */
-    XML_SCHEMAV_CVC_ELT_5_2_1, /* 1855 */
-    XML_SCHEMAV_CVC_ELT_5_2_2_1, /* 1856 */
-    XML_SCHEMAV_CVC_ELT_5_2_2_2_1, /* 1857 */
-    XML_SCHEMAV_CVC_ELT_5_2_2_2_2, /* 1858 */
-    XML_SCHEMAV_CVC_ELT_6, /* 1859 */
-    XML_SCHEMAV_CVC_ELT_7, /* 1860 */
-    XML_SCHEMAV_CVC_ATTRIBUTE_1, /* 1861 */
-    XML_SCHEMAV_CVC_ATTRIBUTE_2, /* 1862 */
-    XML_SCHEMAV_CVC_ATTRIBUTE_3, /* 1863 */
-    XML_SCHEMAV_CVC_ATTRIBUTE_4, /* 1864 */
-    XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1, /* 1865 */
-    XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1, /* 1866 */
-    XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2, /* 1867 */
-    XML_SCHEMAV_CVC_COMPLEX_TYPE_4, /* 1868 */
-    XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1, /* 1869 */
-    XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2, /* 1870 */
-    XML_SCHEMAV_ELEMENT_CONTENT, /* 1871 */
-    XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING, /* 1872 */
-    XML_SCHEMAV_CVC_COMPLEX_TYPE_1, /* 1873 */
-    XML_SCHEMAV_CVC_AU, /* 1874 */
-    XML_SCHEMAV_CVC_TYPE_1, /* 1875 */
-    XML_SCHEMAV_CVC_TYPE_2, /* 1876 */
-    XML_SCHEMAV_CVC_IDC, /* 1877 */
-    XML_SCHEMAV_CVC_WILDCARD, /* 1878 */
-    XML_SCHEMAV_MISC, /* 1879 */
-    XML_XPTR_UNKNOWN_SCHEME = 1900,
-    XML_XPTR_CHILDSEQ_START, /* 1901 */
-    XML_XPTR_EVAL_FAILED, /* 1902 */
-    XML_XPTR_EXTRA_OBJECTS, /* 1903 */
-    XML_C14N_CREATE_CTXT = 1950,
-    XML_C14N_REQUIRES_UTF8, /* 1951 */
-    XML_C14N_CREATE_STACK, /* 1952 */
-    XML_C14N_INVALID_NODE, /* 1953 */
-    XML_C14N_UNKNOW_NODE, /* 1954 */
-    XML_C14N_RELATIVE_NAMESPACE, /* 1955 */
-    XML_FTP_PASV_ANSWER = 2000,
-    XML_FTP_EPSV_ANSWER, /* 2001 */
-    XML_FTP_ACCNT, /* 2002 */
-    XML_FTP_URL_SYNTAX, /* 2003 */
-    XML_HTTP_URL_SYNTAX = 2020,
-    XML_HTTP_USE_IP, /* 2021 */
-    XML_HTTP_UNKNOWN_HOST, /* 2022 */
-    XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000,
-    XML_SCHEMAP_SRC_SIMPLE_TYPE_2, /* 3001 */
-    XML_SCHEMAP_SRC_SIMPLE_TYPE_3, /* 3002 */
-    XML_SCHEMAP_SRC_SIMPLE_TYPE_4, /* 3003 */
-    XML_SCHEMAP_SRC_RESOLVE, /* 3004 */
-    XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE, /* 3005 */
-    XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE, /* 3006 */
-    XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES, /* 3007 */
-    XML_SCHEMAP_ST_PROPS_CORRECT_1, /* 3008 */
-    XML_SCHEMAP_ST_PROPS_CORRECT_2, /* 3009 */
-    XML_SCHEMAP_ST_PROPS_CORRECT_3, /* 3010 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_1_1, /* 3011 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_1_2, /* 3012 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1, /* 3013 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2, /* 3014 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_2_1, /* 3015 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1, /* 3016 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2, /* 3017 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1, /* 3018 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2, /* 3019 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3, /* 3020 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4, /* 3021 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5, /* 3022 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_3_1, /* 3023 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1, /* 3024 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2, /* 3025 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2, /* 3026 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1, /* 3027 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3, /* 3028 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4, /* 3029 */
-    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5, /* 3030 */
-    XML_SCHEMAP_COS_ST_DERIVED_OK_2_1, /* 3031 */
-    XML_SCHEMAP_COS_ST_DERIVED_OK_2_2, /* 3032 */
-    XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED, /* 3033 */
-    XML_SCHEMAP_S4S_ELEM_MISSING, /* 3034 */
-    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, /* 3035 */
-    XML_SCHEMAP_S4S_ATTR_MISSING, /* 3036 */
-    XML_SCHEMAP_S4S_ATTR_INVALID_VALUE, /* 3037 */
-    XML_SCHEMAP_SRC_ELEMENT_1, /* 3038 */
-    XML_SCHEMAP_SRC_ELEMENT_2_1, /* 3039 */
-    XML_SCHEMAP_SRC_ELEMENT_2_2, /* 3040 */
-    XML_SCHEMAP_SRC_ELEMENT_3, /* 3041 */
-    XML_SCHEMAP_P_PROPS_CORRECT_1, /* 3042 */
-    XML_SCHEMAP_P_PROPS_CORRECT_2_1, /* 3043 */
-    XML_SCHEMAP_P_PROPS_CORRECT_2_2, /* 3044 */
-    XML_SCHEMAP_E_PROPS_CORRECT_2, /* 3045 */
-    XML_SCHEMAP_E_PROPS_CORRECT_3, /* 3046 */
-    XML_SCHEMAP_E_PROPS_CORRECT_4, /* 3047 */
-    XML_SCHEMAP_E_PROPS_CORRECT_5, /* 3048 */
-    XML_SCHEMAP_E_PROPS_CORRECT_6, /* 3049 */
-    XML_SCHEMAP_SRC_INCLUDE, /* 3050 */
-    XML_SCHEMAP_SRC_ATTRIBUTE_1, /* 3051 */
-    XML_SCHEMAP_SRC_ATTRIBUTE_2, /* 3052 */
-    XML_SCHEMAP_SRC_ATTRIBUTE_3_1, /* 3053 */
-    XML_SCHEMAP_SRC_ATTRIBUTE_3_2, /* 3054 */
-    XML_SCHEMAP_SRC_ATTRIBUTE_4, /* 3055 */
-    XML_SCHEMAP_NO_XMLNS, /* 3056 */
-    XML_SCHEMAP_NO_XSI, /* 3057 */
-    XML_SCHEMAP_COS_VALID_DEFAULT_1, /* 3058 */
-    XML_SCHEMAP_COS_VALID_DEFAULT_2_1, /* 3059 */
-    XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1, /* 3060 */
-    XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2, /* 3061 */
-    XML_SCHEMAP_CVC_SIMPLE_TYPE, /* 3062 */
-    XML_SCHEMAP_COS_CT_EXTENDS_1_1, /* 3063 */
-    XML_SCHEMAP_SRC_IMPORT_1_1, /* 3064 */
-    XML_SCHEMAP_SRC_IMPORT_1_2, /* 3065 */
-    XML_SCHEMAP_SRC_IMPORT_2, /* 3066 */
-    XML_SCHEMAP_SRC_IMPORT_2_1, /* 3067 */
-    XML_SCHEMAP_SRC_IMPORT_2_2, /* 3068 */
-    XML_SCHEMAP_INTERNAL, /* 3069 non-W3C */
-    XML_SCHEMAP_NOT_DETERMINISTIC, /* 3070 non-W3C */
-    XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1, /* 3071 */
-    XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2, /* 3072 */
-    XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3, /* 3073 */
-    XML_SCHEMAP_MG_PROPS_CORRECT_1, /* 3074 */
-    XML_SCHEMAP_MG_PROPS_CORRECT_2, /* 3075 */
-    XML_SCHEMAP_SRC_CT_1, /* 3076 */
-    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3, /* 3077 */
-    XML_SCHEMAP_AU_PROPS_CORRECT_2, /* 3078 */
-    XML_SCHEMAP_A_PROPS_CORRECT_2, /* 3079 */
-    XML_SCHEMAP_C_PROPS_CORRECT, /* 3080 */
-    XML_SCHEMAP_SRC_REDEFINE, /* 3081 */
-    XML_SCHEMAP_SRC_IMPORT, /* 3082 */
-    XML_SCHEMAP_WARN_SKIP_SCHEMA, /* 3083 */
-    XML_SCHEMAP_WARN_UNLOCATED_SCHEMA, /* 3084 */
-    XML_SCHEMAP_WARN_ATTR_REDECL_PROH, /* 3085 */
-    XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH, /* 3085 */
-    XML_SCHEMAP_AG_PROPS_CORRECT, /* 3086 */
-    XML_SCHEMAP_COS_CT_EXTENDS_1_2, /* 3087 */
-    XML_SCHEMAP_AU_PROPS_CORRECT, /* 3088 */
-    XML_SCHEMAP_A_PROPS_CORRECT_3, /* 3089 */
-    XML_SCHEMAP_COS_ALL_LIMITED, /* 3090 */
-    XML_SCHEMATRONV_ASSERT = 4000, /* 4000 */
-    XML_SCHEMATRONV_REPORT,
-    XML_MODULE_OPEN = 4900, /* 4900 */
-    XML_MODULE_CLOSE, /* 4901 */
-    XML_CHECK_FOUND_ELEMENT = 5000,
-    XML_CHECK_FOUND_ATTRIBUTE, /* 5001 */
-    XML_CHECK_FOUND_TEXT, /* 5002 */
-    XML_CHECK_FOUND_CDATA, /* 5003 */
-    XML_CHECK_FOUND_ENTITYREF, /* 5004 */
-    XML_CHECK_FOUND_ENTITY, /* 5005 */
-    XML_CHECK_FOUND_PI, /* 5006 */
-    XML_CHECK_FOUND_COMMENT, /* 5007 */
-    XML_CHECK_FOUND_DOCTYPE, /* 5008 */
-    XML_CHECK_FOUND_FRAGMENT, /* 5009 */
-    XML_CHECK_FOUND_NOTATION, /* 5010 */
-    XML_CHECK_UNKNOWN_NODE, /* 5011 */
-    XML_CHECK_ENTITY_TYPE, /* 5012 */
-    XML_CHECK_NO_PARENT, /* 5013 */
-    XML_CHECK_NO_DOC, /* 5014 */
-    XML_CHECK_NO_NAME, /* 5015 */
-    XML_CHECK_NO_ELEM, /* 5016 */
-    XML_CHECK_WRONG_DOC, /* 5017 */
-    XML_CHECK_NO_PREV, /* 5018 */
-    XML_CHECK_WRONG_PREV, /* 5019 */
-    XML_CHECK_NO_NEXT, /* 5020 */
-    XML_CHECK_WRONG_NEXT, /* 5021 */
-    XML_CHECK_NOT_DTD, /* 5022 */
-    XML_CHECK_NOT_ATTR, /* 5023 */
-    XML_CHECK_NOT_ATTR_DECL, /* 5024 */
-    XML_CHECK_NOT_ELEM_DECL, /* 5025 */
-    XML_CHECK_NOT_ENTITY_DECL, /* 5026 */
-    XML_CHECK_NOT_NS_DECL, /* 5027 */
-    XML_CHECK_NO_HREF, /* 5028 */
-    XML_CHECK_WRONG_PARENT,/* 5029 */
-    XML_CHECK_NS_SCOPE, /* 5030 */
-    XML_CHECK_NS_ANCESTOR, /* 5031 */
-    XML_CHECK_NOT_UTF8, /* 5032 */
-    XML_CHECK_NO_DICT, /* 5033 */
-    XML_CHECK_NOT_NCNAME, /* 5034 */
-    XML_CHECK_OUTSIDE_DICT, /* 5035 */
-    XML_CHECK_WRONG_NAME, /* 5036 */
-    XML_CHECK_NAME_NOT_NULL, /* 5037 */
-    XML_I18N_NO_NAME = 6000,
-    XML_I18N_NO_HANDLER, /* 6001 */
-    XML_I18N_EXCESS_HANDLER, /* 6002 */
-    XML_I18N_CONV_FAILED, /* 6003 */
-    XML_I18N_NO_OUTPUT, /* 6004 */
-    XML_BUF_OVERFLOW = 7000
-} xmlParserErrors;
-
-/**
- * xmlGenericErrorFunc:
- * @ctx:  a parsing context
- * @msg:  the message
- * @...:  the extra arguments of the varags to format the message
- *
- * Signature of the function to use when there is an error and
- * no parsing or validity context available .
- */
-typedef void (XMLCDECL *xmlGenericErrorFunc) (void *ctx,
-				 const char *msg,
-				 ...) LIBXML_ATTR_FORMAT(2,3);
-/**
- * xmlStructuredErrorFunc:
- * @userData:  user provided data for the error callback
- * @error:  the error being raised.
- *
- * Signature of the function to use when there is an error and
- * the module handles the new error reporting mechanism.
- */
-typedef void (XMLCALL *xmlStructuredErrorFunc) (void *userData, xmlErrorPtr error);
-
-/*
- * Use the following function to reset the two global variables
- * xmlGenericError and xmlGenericErrorContext.
- */
-XMLPUBFUN void XMLCALL
-    xmlSetGenericErrorFunc	(void *ctx,
-				 xmlGenericErrorFunc handler);
-XMLPUBFUN void XMLCALL
-    initGenericErrorDefaultFunc	(xmlGenericErrorFunc *handler);
-
-XMLPUBFUN void XMLCALL
-    xmlSetStructuredErrorFunc	(void *ctx,
-				 xmlStructuredErrorFunc handler);
-/*
- * Default message routines used by SAX and Valid context for error
- * and warning reporting.
- */
-XMLPUBFUN void XMLCDECL
-    xmlParserError		(void *ctx,
-				 const char *msg,
-				 ...) LIBXML_ATTR_FORMAT(2,3);
-XMLPUBFUN void XMLCDECL
-    xmlParserWarning		(void *ctx,
-				 const char *msg,
-				 ...) LIBXML_ATTR_FORMAT(2,3);
-XMLPUBFUN void XMLCDECL
-    xmlParserValidityError	(void *ctx,
-				 const char *msg,
-				 ...) LIBXML_ATTR_FORMAT(2,3);
-XMLPUBFUN void XMLCDECL
-    xmlParserValidityWarning	(void *ctx,
-				 const char *msg,
-				 ...) LIBXML_ATTR_FORMAT(2,3);
-XMLPUBFUN void XMLCALL
-    xmlParserPrintFileInfo	(xmlParserInputPtr input);
-XMLPUBFUN void XMLCALL
-    xmlParserPrintFileContext	(xmlParserInputPtr input);
-
-/*
- * Extended error information routines
- */
-XMLPUBFUN xmlErrorPtr XMLCALL
-    xmlGetLastError		(void);
-XMLPUBFUN void XMLCALL
-    xmlResetLastError		(void);
-XMLPUBFUN xmlErrorPtr XMLCALL
-    xmlCtxtGetLastError		(void *ctx);
-XMLPUBFUN void XMLCALL
-    xmlCtxtResetLastError	(void *ctx);
-XMLPUBFUN void XMLCALL
-    xmlResetError		(xmlErrorPtr err);
-XMLPUBFUN int XMLCALL
-    xmlCopyError		(xmlErrorPtr from,
-				 xmlErrorPtr to);
-
-#ifdef IN_LIBXML
-/*
- * Internal callback reporting routine
- */
-XMLPUBFUN void XMLCALL
-    __xmlRaiseError		(xmlStructuredErrorFunc schannel,
-				 xmlGenericErrorFunc channel,
-				 void *data,
-                                 void *ctx,
-				 void *node,
-				 int domain,
-				 int code,
-				 xmlErrorLevel level,
-				 const char *file,
-				 int line,
-				 const char *str1,
-				 const char *str2,
-				 const char *str3,
-				 int int1,
-				 int col,
-				 const char *msg,
-				 ...) LIBXML_ATTR_FORMAT(16,17);
-XMLPUBFUN void XMLCALL
-    __xmlSimpleError		(int domain,
-				 int code,
-				 xmlNodePtr node,
-				 const char *msg,
-				 const char *extra);
-#endif
-#ifdef __cplusplus
-}
-#endif
-#endif /* __XML_ERROR_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/xmlexports.h

@@ -1,162 +0,0 @@
-/*
- * Summary: macros for marking symbols as exportable/importable.
- * Description: macros for marking symbols as exportable/importable.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Igor Zlatovic <igor@zlatkovic.com>
- */
-
-#ifndef __XML_EXPORTS_H__
-#define __XML_EXPORTS_H__
-
-/**
- * XMLPUBFUN, XMLPUBVAR, XMLCALL
- *
- * Macros which declare an exportable function, an exportable variable and
- * the calling convention used for functions.
- *
- * Please use an extra block for every platform/compiler combination when
- * modifying this, rather than overlong #ifdef lines. This helps
- * readability as well as the fact that different compilers on the same
- * platform might need different definitions.
- */
-
-/**
- * XMLPUBFUN:
- *
- * Macros which declare an exportable function
- */
-#define XMLPUBFUN
-/**
- * XMLPUBVAR:
- *
- * Macros which declare an exportable variable
- */
-#define XMLPUBVAR extern
-/**
- * XMLCALL:
- *
- * Macros which declare the called convention for exported functions
- */
-#define XMLCALL
-/**
- * XMLCDECL:
- *
- * Macro which declares the calling convention for exported functions that
- * use '...'.
- */
-#define XMLCDECL
-
-/** DOC_DISABLE */
-
-/* Windows platform with MS compiler */
-#if defined(_WIN32) && defined(_MSC_VER)
-  #undef XMLPUBFUN
-  #undef XMLPUBVAR
-  #undef XMLCALL
-  #undef XMLCDECL
-  #if defined(IN_LIBXML) && !defined(LIBXML_STATIC)
-    #define XMLPUBFUN __declspec(dllexport)
-    #define XMLPUBVAR __declspec(dllexport)
-  #else
-    #define XMLPUBFUN
-    #if !defined(LIBXML_STATIC)
-      #define XMLPUBVAR __declspec(dllimport) extern
-    #else
-      #define XMLPUBVAR extern
-    #endif
-  #endif
-  #if defined(LIBXML_FASTCALL)
-    #define XMLCALL __fastcall
-  #else
-    #define XMLCALL __cdecl
-  #endif
-  #define XMLCDECL __cdecl
-  #if !defined _REENTRANT
-    #define _REENTRANT
-  #endif
-#endif
-
-/* Windows platform with Borland compiler */
-#if defined(_WIN32) && defined(__BORLANDC__)
-  #undef XMLPUBFUN
-  #undef XMLPUBVAR
-  #undef XMLCALL
-  #undef XMLCDECL
-  #if defined(IN_LIBXML) && !defined(LIBXML_STATIC)
-    #define XMLPUBFUN __declspec(dllexport)
-    #define XMLPUBVAR __declspec(dllexport) extern
-  #else
-    #define XMLPUBFUN
-    #if !defined(LIBXML_STATIC)
-      #define XMLPUBVAR __declspec(dllimport) extern
-    #else
-      #define XMLPUBVAR extern
-    #endif
-  #endif
-  #define XMLCALL __cdecl
-  #define XMLCDECL __cdecl
-  #if !defined _REENTRANT
-    #define _REENTRANT
-  #endif
-#endif
-
-/* Windows platform with GNU compiler (Mingw) */
-#if defined(_WIN32) && defined(__MINGW32__)
-  #undef XMLPUBFUN
-  #undef XMLPUBVAR
-  #undef XMLCALL
-  #undef XMLCDECL
-  /*
-   * if defined(IN_LIBXML) this raises problems on mingw with msys
-   * _imp__xmlFree listed as missing. Try to workaround the problem
-   * by also making that declaration when compiling client code.
-   */
-  #if defined(IN_LIBXML) && !defined(LIBXML_STATIC)
-    #define XMLPUBFUN __declspec(dllexport)
-    #define XMLPUBVAR __declspec(dllexport) extern
-  #else
-    #define XMLPUBFUN
-    #if !defined(LIBXML_STATIC)
-      #define XMLPUBVAR __declspec(dllimport) extern
-    #else
-      #define XMLPUBVAR extern
-    #endif
-  #endif
-  #define XMLCALL __cdecl
-  #define XMLCDECL __cdecl
-  #if !defined _REENTRANT
-    #define _REENTRANT
-  #endif
-#endif
-
-/* Cygwin platform, GNU compiler */
-#if defined(_WIN32) && defined(__CYGWIN__)
-  #undef XMLPUBFUN
-  #undef XMLPUBVAR
-  #undef XMLCALL
-  #undef XMLCDECL
-  #if defined(IN_LIBXML) && !defined(LIBXML_STATIC)
-    #define XMLPUBFUN __declspec(dllexport)
-    #define XMLPUBVAR __declspec(dllexport)
-  #else
-    #define XMLPUBFUN
-    #if !defined(LIBXML_STATIC)
-      #define XMLPUBVAR __declspec(dllimport) extern
-    #else
-      #define XMLPUBVAR
-    #endif
-  #endif
-  #define XMLCALL __cdecl
-  #define XMLCDECL __cdecl
-#endif
-
-/* Compatibility */
-#if !defined(LIBXML_DLL_IMPORT)
-#define LIBXML_DLL_IMPORT XMLPUBVAR
-#endif
-
-#endif /* __XML_EXPORTS_H__ */
-
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/xmlmemory.h

@@ -1,224 +0,0 @@
-/*
- * Summary: interface for the memory allocator
- * Description: provides interfaces for the memory allocator,
- *              including debugging capabilities.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-
-#ifndef __DEBUG_MEMORY_ALLOC__
-#define __DEBUG_MEMORY_ALLOC__
-
-#include <stdio.h>
-#include <libxml/xmlversion.h>
-
-/**
- * DEBUG_MEMORY:
- *
- * DEBUG_MEMORY replaces the allocator with a collect and debug
- * shell to the libc allocator.
- * DEBUG_MEMORY should only be activated when debugging
- * libxml i.e. if libxml has been configured with --with-debug-mem too.
- */
-/* #define DEBUG_MEMORY_FREED */
-/* #define DEBUG_MEMORY_LOCATION */
-
-#ifdef DEBUG
-#ifndef DEBUG_MEMORY
-#define DEBUG_MEMORY
-#endif
-#endif
-
-/**
- * DEBUG_MEMORY_LOCATION:
- *
- * DEBUG_MEMORY_LOCATION should be activated only when debugging
- * libxml i.e. if libxml has been configured with --with-debug-mem too.
- */
-#ifdef DEBUG_MEMORY_LOCATION
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * The XML memory wrapper support 4 basic overloadable functions.
- */
-/**
- * xmlFreeFunc:
- * @mem: an already allocated block of memory
- *
- * Signature for a free() implementation.
- */
-typedef void (XMLCALL *xmlFreeFunc)(void *mem);
-/**
- * xmlMallocFunc:
- * @size:  the size requested in bytes
- *
- * Signature for a malloc() implementation.
- *
- * Returns a pointer to the newly allocated block or NULL in case of error.
- */
-typedef void *(LIBXML_ATTR_ALLOC_SIZE(1) XMLCALL *xmlMallocFunc)(size_t size);
-
-/**
- * xmlReallocFunc:
- * @mem: an already allocated block of memory
- * @size:  the new size requested in bytes
- *
- * Signature for a realloc() implementation.
- *
- * Returns a pointer to the newly reallocated block or NULL in case of error.
- */
-typedef void *(XMLCALL *xmlReallocFunc)(void *mem, size_t size);
-
-/**
- * xmlStrdupFunc:
- * @str: a zero terminated string
- *
- * Signature for an strdup() implementation.
- *
- * Returns the copy of the string or NULL in case of error.
- */
-typedef char *(XMLCALL *xmlStrdupFunc)(const char *str);
-
-/*
- * The 4 interfaces used for all memory handling within libxml.
-LIBXML_DLL_IMPORT xmlFreeFunc xmlFree;
-LIBXML_DLL_IMPORT xmlMallocFunc xmlMalloc;
-LIBXML_DLL_IMPORT xmlMallocFunc xmlMallocAtomic;
-LIBXML_DLL_IMPORT xmlReallocFunc xmlRealloc;
-LIBXML_DLL_IMPORT xmlStrdupFunc xmlMemStrdup;
- */
-
-/*
- * The way to overload the existing functions.
- * The xmlGc function have an extra entry for atomic block
- * allocations useful for garbage collected memory allocators
- */
-XMLPUBFUN int XMLCALL
-	xmlMemSetup	(xmlFreeFunc freeFunc,
-			 xmlMallocFunc mallocFunc,
-			 xmlReallocFunc reallocFunc,
-			 xmlStrdupFunc strdupFunc);
-XMLPUBFUN int XMLCALL
-	xmlMemGet	(xmlFreeFunc *freeFunc,
-			 xmlMallocFunc *mallocFunc,
-			 xmlReallocFunc *reallocFunc,
-			 xmlStrdupFunc *strdupFunc);
-XMLPUBFUN int XMLCALL
-	xmlGcMemSetup	(xmlFreeFunc freeFunc,
-			 xmlMallocFunc mallocFunc,
-			 xmlMallocFunc mallocAtomicFunc,
-			 xmlReallocFunc reallocFunc,
-			 xmlStrdupFunc strdupFunc);
-XMLPUBFUN int XMLCALL
-	xmlGcMemGet	(xmlFreeFunc *freeFunc,
-			 xmlMallocFunc *mallocFunc,
-			 xmlMallocFunc *mallocAtomicFunc,
-			 xmlReallocFunc *reallocFunc,
-			 xmlStrdupFunc *strdupFunc);
-
-/*
- * Initialization of the memory layer.
- */
-XMLPUBFUN int XMLCALL
-	xmlInitMemory	(void);
-
-/*
- * Cleanup of the memory layer.
- */
-XMLPUBFUN void XMLCALL
-                xmlCleanupMemory        (void);
-/*
- * These are specific to the XML debug memory wrapper.
- */
-XMLPUBFUN int XMLCALL
-	xmlMemUsed	(void);
-XMLPUBFUN int XMLCALL
-	xmlMemBlocks	(void);
-XMLPUBFUN void XMLCALL
-	xmlMemDisplay	(FILE *fp);
-XMLPUBFUN void XMLCALL
-	xmlMemDisplayLast(FILE *fp, long nbBytes);
-XMLPUBFUN void XMLCALL
-	xmlMemShow	(FILE *fp, int nr);
-XMLPUBFUN void XMLCALL
-	xmlMemoryDump	(void);
-XMLPUBFUN void * XMLCALL
-	xmlMemMalloc	(size_t size) LIBXML_ATTR_ALLOC_SIZE(1);
-XMLPUBFUN void * XMLCALL
-	xmlMemRealloc	(void *ptr,size_t size);
-XMLPUBFUN void XMLCALL
-	xmlMemFree	(void *ptr);
-XMLPUBFUN char * XMLCALL
-	xmlMemoryStrdup	(const char *str);
-XMLPUBFUN void * XMLCALL
-	xmlMallocLoc	(size_t size, const char *file, int line) LIBXML_ATTR_ALLOC_SIZE(1);
-XMLPUBFUN void * XMLCALL
-	xmlReallocLoc	(void *ptr, size_t size, const char *file, int line);
-XMLPUBFUN void * XMLCALL
-	xmlMallocAtomicLoc (size_t size, const char *file, int line) LIBXML_ATTR_ALLOC_SIZE(1);
-XMLPUBFUN char * XMLCALL
-	xmlMemStrdupLoc	(const char *str, const char *file, int line);
-
-
-#ifdef DEBUG_MEMORY_LOCATION
-/**
- * xmlMalloc:
- * @size:  number of bytes to allocate
- *
- * Wrapper for the malloc() function used in the XML library.
- *
- * Returns the pointer to the allocated area or NULL in case of error.
- */
-#define xmlMalloc(size) xmlMallocLoc((size), __FILE__, __LINE__)
-/**
- * xmlMallocAtomic:
- * @size:  number of bytes to allocate
- *
- * Wrapper for the malloc() function used in the XML library for allocation
- * of block not containing pointers to other areas.
- *
- * Returns the pointer to the allocated area or NULL in case of error.
- */
-#define xmlMallocAtomic(size) xmlMallocAtomicLoc((size), __FILE__, __LINE__)
-/**
- * xmlRealloc:
- * @ptr:  pointer to the existing allocated area
- * @size:  number of bytes to allocate
- *
- * Wrapper for the realloc() function used in the XML library.
- *
- * Returns the pointer to the allocated area or NULL in case of error.
- */
-#define xmlRealloc(ptr, size) xmlReallocLoc((ptr), (size), __FILE__, __LINE__)
-/**
- * xmlMemStrdup:
- * @str:  pointer to the existing string
- *
- * Wrapper for the strdup() function, xmlStrdup() is usually preferred.
- *
- * Returns the pointer to the allocated area or NULL in case of error.
- */
-#define xmlMemStrdup(str) xmlMemStrdupLoc((str), __FILE__, __LINE__)
-
-#endif /* DEBUG_MEMORY_LOCATION */
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#ifndef __XML_GLOBALS_H
-#ifndef __XML_THREADS_H__
-#include <libxml/threads.h>
-#include <libxml/globals.h>
-#endif
-#endif
-
-#endif  /* __DEBUG_MEMORY_ALLOC__ */
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/xmlreader.h

@@ -1,424 +0,0 @@
-/*
- * Summary: the XMLReader implementation
- * Description: API of the XML streaming API based on C# interfaces.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#ifndef __XML_XMLREADER_H__
-#define __XML_XMLREADER_H__
-
-#include <libxml/xmlversion.h>
-#include <libxml/tree.h>
-#include <libxml/xmlIO.h>
-#ifdef LIBXML_SCHEMAS_ENABLED
-#include <libxml/relaxng.h>
-#include <libxml/xmlschemas.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * xmlParserSeverities:
- *
- * How severe an error callback is when the per-reader error callback API
- * is used.
- */
-typedef enum {
-    XML_PARSER_SEVERITY_VALIDITY_WARNING = 1,
-    XML_PARSER_SEVERITY_VALIDITY_ERROR = 2,
-    XML_PARSER_SEVERITY_WARNING = 3,
-    XML_PARSER_SEVERITY_ERROR = 4
-} xmlParserSeverities;
-
-#ifdef LIBXML_READER_ENABLED
-
-/**
- * xmlTextReaderMode:
- *
- * Internal state values for the reader.
- */
-typedef enum {
-    XML_TEXTREADER_MODE_INITIAL = 0,
-    XML_TEXTREADER_MODE_INTERACTIVE = 1,
-    XML_TEXTREADER_MODE_ERROR = 2,
-    XML_TEXTREADER_MODE_EOF =3,
-    XML_TEXTREADER_MODE_CLOSED = 4,
-    XML_TEXTREADER_MODE_READING = 5
-} xmlTextReaderMode;
-
-/**
- * xmlParserProperties:
- *
- * Some common options to use with xmlTextReaderSetParserProp, but it
- * is better to use xmlParserOption and the xmlReaderNewxxx and
- * xmlReaderForxxx APIs now.
- */
-typedef enum {
-    XML_PARSER_LOADDTD = 1,
-    XML_PARSER_DEFAULTATTRS = 2,
-    XML_PARSER_VALIDATE = 3,
-    XML_PARSER_SUBST_ENTITIES = 4
-} xmlParserProperties;
-
-/**
- * xmlReaderTypes:
- *
- * Predefined constants for the different types of nodes.
- */
-typedef enum {
-    XML_READER_TYPE_NONE = 0,
-    XML_READER_TYPE_ELEMENT = 1,
-    XML_READER_TYPE_ATTRIBUTE = 2,
-    XML_READER_TYPE_TEXT = 3,
-    XML_READER_TYPE_CDATA = 4,
-    XML_READER_TYPE_ENTITY_REFERENCE = 5,
-    XML_READER_TYPE_ENTITY = 6,
-    XML_READER_TYPE_PROCESSING_INSTRUCTION = 7,
-    XML_READER_TYPE_COMMENT = 8,
-    XML_READER_TYPE_DOCUMENT = 9,
-    XML_READER_TYPE_DOCUMENT_TYPE = 10,
-    XML_READER_TYPE_DOCUMENT_FRAGMENT = 11,
-    XML_READER_TYPE_NOTATION = 12,
-    XML_READER_TYPE_WHITESPACE = 13,
-    XML_READER_TYPE_SIGNIFICANT_WHITESPACE = 14,
-    XML_READER_TYPE_END_ELEMENT = 15,
-    XML_READER_TYPE_END_ENTITY = 16,
-    XML_READER_TYPE_XML_DECLARATION = 17
-} xmlReaderTypes;
-
-/**
- * xmlTextReader:
- *
- * Structure for an xmlReader context.
- */
-typedef struct _xmlTextReader xmlTextReader;
-
-/**
- * xmlTextReaderPtr:
- *
- * Pointer to an xmlReader context.
- */
-typedef xmlTextReader *xmlTextReaderPtr;
-
-/*
- * Constructors & Destructor
- */
-XMLPUBFUN xmlTextReaderPtr XMLCALL
-			xmlNewTextReader	(xmlParserInputBufferPtr input,
-	                                         const char *URI);
-XMLPUBFUN xmlTextReaderPtr XMLCALL
-			xmlNewTextReaderFilename(const char *URI);
-
-XMLPUBFUN void XMLCALL
-			xmlFreeTextReader	(xmlTextReaderPtr reader);
-
-XMLPUBFUN int XMLCALL
-            xmlTextReaderSetup(xmlTextReaderPtr reader,
-                   xmlParserInputBufferPtr input, const char *URL,
-                   const char *encoding, int options);
-
-/*
- * Iterators
- */
-XMLPUBFUN int XMLCALL
-			xmlTextReaderRead	(xmlTextReaderPtr reader);
-
-#ifdef LIBXML_WRITER_ENABLED
-XMLPUBFUN xmlChar * XMLCALL
-			xmlTextReaderReadInnerXml	(xmlTextReaderPtr reader);
-
-XMLPUBFUN xmlChar * XMLCALL
-			xmlTextReaderReadOuterXml	(xmlTextReaderPtr reader);
-#endif
-
-XMLPUBFUN xmlChar * XMLCALL
-			xmlTextReaderReadString		(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-			xmlTextReaderReadAttributeValue	(xmlTextReaderPtr reader);
-
-/*
- * Attributes of the node
- */
-XMLPUBFUN int XMLCALL
-			xmlTextReaderAttributeCount(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-			xmlTextReaderDepth	(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-			xmlTextReaderHasAttributes(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-			xmlTextReaderHasValue(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-			xmlTextReaderIsDefault	(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-			xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-			xmlTextReaderNodeType	(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-			xmlTextReaderQuoteChar	(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-			xmlTextReaderReadState	(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-                        xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader);
-
-XMLPUBFUN const xmlChar * XMLCALL
-		    xmlTextReaderConstBaseUri	(xmlTextReaderPtr reader);
-XMLPUBFUN const xmlChar * XMLCALL
-		    xmlTextReaderConstLocalName	(xmlTextReaderPtr reader);
-XMLPUBFUN const xmlChar * XMLCALL
-		    xmlTextReaderConstName	(xmlTextReaderPtr reader);
-XMLPUBFUN const xmlChar * XMLCALL
-		    xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader);
-XMLPUBFUN const xmlChar * XMLCALL
-		    xmlTextReaderConstPrefix	(xmlTextReaderPtr reader);
-XMLPUBFUN const xmlChar * XMLCALL
-		    xmlTextReaderConstXmlLang	(xmlTextReaderPtr reader);
-XMLPUBFUN const xmlChar * XMLCALL
-		    xmlTextReaderConstString	(xmlTextReaderPtr reader,
-						 const xmlChar *str);
-XMLPUBFUN const xmlChar * XMLCALL
-		    xmlTextReaderConstValue	(xmlTextReaderPtr reader);
-
-/*
- * use the Const version of the routine for
- * better performance and simpler code
- */
-XMLPUBFUN xmlChar * XMLCALL
-			xmlTextReaderBaseUri	(xmlTextReaderPtr reader);
-XMLPUBFUN xmlChar * XMLCALL
-			xmlTextReaderLocalName	(xmlTextReaderPtr reader);
-XMLPUBFUN xmlChar * XMLCALL
-			xmlTextReaderName	(xmlTextReaderPtr reader);
-XMLPUBFUN xmlChar * XMLCALL
-			xmlTextReaderNamespaceUri(xmlTextReaderPtr reader);
-XMLPUBFUN xmlChar * XMLCALL
-			xmlTextReaderPrefix	(xmlTextReaderPtr reader);
-XMLPUBFUN xmlChar * XMLCALL
-			xmlTextReaderXmlLang	(xmlTextReaderPtr reader);
-XMLPUBFUN xmlChar * XMLCALL
-			xmlTextReaderValue	(xmlTextReaderPtr reader);
-
-/*
- * Methods of the XmlTextReader
- */
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderClose		(xmlTextReaderPtr reader);
-XMLPUBFUN xmlChar * XMLCALL
-		    xmlTextReaderGetAttributeNo	(xmlTextReaderPtr reader,
-						 int no);
-XMLPUBFUN xmlChar * XMLCALL
-		    xmlTextReaderGetAttribute	(xmlTextReaderPtr reader,
-						 const xmlChar *name);
-XMLPUBFUN xmlChar * XMLCALL
-		    xmlTextReaderGetAttributeNs	(xmlTextReaderPtr reader,
-						 const xmlChar *localName,
-						 const xmlChar *namespaceURI);
-XMLPUBFUN xmlParserInputBufferPtr XMLCALL
-		    xmlTextReaderGetRemainder	(xmlTextReaderPtr reader);
-XMLPUBFUN xmlChar * XMLCALL
-		    xmlTextReaderLookupNamespace(xmlTextReaderPtr reader,
-						 const xmlChar *prefix);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader,
-						 int no);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader,
-						 const xmlChar *name);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader,
-						 const xmlChar *localName,
-						 const xmlChar *namespaceURI);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderMoveToElement	(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderNormalization	(xmlTextReaderPtr reader);
-XMLPUBFUN const xmlChar * XMLCALL
-		    xmlTextReaderConstEncoding  (xmlTextReaderPtr reader);
-
-/*
- * Extensions
- */
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderSetParserProp	(xmlTextReaderPtr reader,
-						 int prop,
-						 int value);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderGetParserProp	(xmlTextReaderPtr reader,
-						 int prop);
-XMLPUBFUN xmlNodePtr XMLCALL
-		    xmlTextReaderCurrentNode	(xmlTextReaderPtr reader);
-
-XMLPUBFUN int XMLCALL
-            xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader);
-
-XMLPUBFUN int XMLCALL
-            xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader);
-
-XMLPUBFUN xmlNodePtr XMLCALL
-		    xmlTextReaderPreserve	(xmlTextReaderPtr reader);
-#ifdef LIBXML_PATTERN_ENABLED
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderPreservePattern(xmlTextReaderPtr reader,
-						 const xmlChar *pattern,
-						 const xmlChar **namespaces);
-#endif /* LIBXML_PATTERN_ENABLED */
-XMLPUBFUN xmlDocPtr XMLCALL
-		    xmlTextReaderCurrentDoc	(xmlTextReaderPtr reader);
-XMLPUBFUN xmlNodePtr XMLCALL
-		    xmlTextReaderExpand		(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderNext		(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderNextSibling	(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderIsValid	(xmlTextReaderPtr reader);
-#ifdef LIBXML_SCHEMAS_ENABLED
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader,
-						 const char *rng);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader,
-						 xmlRelaxNGPtr schema);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderSchemaValidate	(xmlTextReaderPtr reader,
-						 const char *xsd);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader,
-						 xmlSchemaValidCtxtPtr ctxt,
-						 int options);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderSetSchema	(xmlTextReaderPtr reader,
-						 xmlSchemaPtr schema);
-#endif
-XMLPUBFUN const xmlChar * XMLCALL
-		    xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderStandalone     (xmlTextReaderPtr reader);
-
-
-/*
- * Index lookup
- */
-XMLPUBFUN long XMLCALL
-		xmlTextReaderByteConsumed	(xmlTextReaderPtr reader);
-
-/*
- * New more complete APIs for simpler creation and reuse of readers
- */
-XMLPUBFUN xmlTextReaderPtr XMLCALL
-		xmlReaderWalker		(xmlDocPtr doc);
-XMLPUBFUN xmlTextReaderPtr XMLCALL
-		xmlReaderForDoc		(const xmlChar * cur,
-					 const char *URL,
-					 const char *encoding,
-					 int options);
-XMLPUBFUN xmlTextReaderPtr XMLCALL
-		xmlReaderForFile	(const char *filename,
-					 const char *encoding,
-					 int options);
-XMLPUBFUN xmlTextReaderPtr XMLCALL
-		xmlReaderForMemory	(const char *buffer,
-					 int size,
-					 const char *URL,
-					 const char *encoding,
-					 int options);
-XMLPUBFUN xmlTextReaderPtr XMLCALL
-		xmlReaderForFd		(int fd,
-					 const char *URL,
-					 const char *encoding,
-					 int options);
-XMLPUBFUN xmlTextReaderPtr XMLCALL
-		xmlReaderForIO		(xmlInputReadCallback ioread,
-					 xmlInputCloseCallback ioclose,
-					 void *ioctx,
-					 const char *URL,
-					 const char *encoding,
-					 int options);
-
-XMLPUBFUN int XMLCALL
-		xmlReaderNewWalker	(xmlTextReaderPtr reader,
-					 xmlDocPtr doc);
-XMLPUBFUN int XMLCALL
-		xmlReaderNewDoc		(xmlTextReaderPtr reader,
-					 const xmlChar * cur,
-					 const char *URL,
-					 const char *encoding,
-					 int options);
-XMLPUBFUN int XMLCALL
-		xmlReaderNewFile	(xmlTextReaderPtr reader,
-					 const char *filename,
-					 const char *encoding,
-					 int options);
-XMLPUBFUN int XMLCALL
-		xmlReaderNewMemory	(xmlTextReaderPtr reader,
-					 const char *buffer,
-					 int size,
-					 const char *URL,
-					 const char *encoding,
-					 int options);
-XMLPUBFUN int XMLCALL
-		xmlReaderNewFd		(xmlTextReaderPtr reader,
-					 int fd,
-					 const char *URL,
-					 const char *encoding,
-					 int options);
-XMLPUBFUN int XMLCALL
-		xmlReaderNewIO		(xmlTextReaderPtr reader,
-					 xmlInputReadCallback ioread,
-					 xmlInputCloseCallback ioclose,
-					 void *ioctx,
-					 const char *URL,
-					 const char *encoding,
-					 int options);
-/*
- * Error handling extensions
- */
-typedef void *  xmlTextReaderLocatorPtr;
-
-/**
- * xmlTextReaderErrorFunc:
- * @arg: the user argument
- * @msg: the message
- * @severity: the severity of the error
- * @locator: a locator indicating where the error occured
- *
- * Signature of an error callback from a reader parser
- */
-typedef void   (XMLCALL *xmlTextReaderErrorFunc)(void *arg,
-						 const char *msg,
-						 xmlParserSeverities severity,
-						 xmlTextReaderLocatorPtr locator);
-XMLPUBFUN int XMLCALL
-		    xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator);
-/*int             xmlTextReaderLocatorLinePosition(xmlTextReaderLocatorPtr locator);*/
-XMLPUBFUN xmlChar * XMLCALL
-		    xmlTextReaderLocatorBaseURI (xmlTextReaderLocatorPtr locator);
-XMLPUBFUN void XMLCALL
-		    xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader,
-						 xmlTextReaderErrorFunc f,
-						 void *arg);
-XMLPUBFUN void XMLCALL
-		    xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader,
-							   xmlStructuredErrorFunc f,
-							   void *arg);
-XMLPUBFUN void XMLCALL
-		    xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader,
-						 xmlTextReaderErrorFunc *f,
-						 void **arg);
-
-#endif /* LIBXML_READER_ENABLED */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __XML_XMLREADER_H__ */
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/xmlregexp.h

@@ -1,222 +0,0 @@
-/*
- * Summary: regular expressions handling
- * Description: basic API for libxml regular expressions handling used
- *              for XML Schemas and validation.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#ifndef __XML_REGEXP_H__
-#define __XML_REGEXP_H__
-
-#include <libxml/xmlversion.h>
-
-#ifdef LIBXML_REGEXP_ENABLED
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * xmlRegexpPtr:
- *
- * A libxml regular expression, they can actually be far more complex
- * thank the POSIX regex expressions.
- */
-typedef struct _xmlRegexp xmlRegexp;
-typedef xmlRegexp *xmlRegexpPtr;
-
-/**
- * xmlRegExecCtxtPtr:
- *
- * A libxml progressive regular expression evaluation context
- */
-typedef struct _xmlRegExecCtxt xmlRegExecCtxt;
-typedef xmlRegExecCtxt *xmlRegExecCtxtPtr;
-
-#ifdef __cplusplus
-}
-#endif
-#include <libxml/tree.h>
-#include <libxml/dict.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * The POSIX like API
- */
-XMLPUBFUN xmlRegexpPtr XMLCALL
-		    xmlRegexpCompile	(const xmlChar *regexp);
-XMLPUBFUN void XMLCALL			 xmlRegFreeRegexp(xmlRegexpPtr regexp);
-XMLPUBFUN int XMLCALL
-		    xmlRegexpExec	(xmlRegexpPtr comp,
-					 const xmlChar *value);
-XMLPUBFUN void XMLCALL
-		    xmlRegexpPrint	(FILE *output,
-					 xmlRegexpPtr regexp);
-XMLPUBFUN int XMLCALL
-		    xmlRegexpIsDeterminist(xmlRegexpPtr comp);
-
-/**
- * xmlRegExecCallbacks:
- * @exec: the regular expression context
- * @token: the current token string
- * @transdata: transition data
- * @inputdata: input data
- *
- * Callback function when doing a transition in the automata
- */
-typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxtPtr exec,
-	                             const xmlChar *token,
-				     void *transdata,
-				     void *inputdata);
-
-/*
- * The progressive API
- */
-XMLPUBFUN xmlRegExecCtxtPtr XMLCALL
-		    xmlRegNewExecCtxt	(xmlRegexpPtr comp,
-					 xmlRegExecCallbacks callback,
-					 void *data);
-XMLPUBFUN void XMLCALL
-		    xmlRegFreeExecCtxt	(xmlRegExecCtxtPtr exec);
-XMLPUBFUN int XMLCALL
-		    xmlRegExecPushString(xmlRegExecCtxtPtr exec,
-					 const xmlChar *value,
-					 void *data);
-XMLPUBFUN int XMLCALL
-		    xmlRegExecPushString2(xmlRegExecCtxtPtr exec,
-					 const xmlChar *value,
-					 const xmlChar *value2,
-					 void *data);
-
-XMLPUBFUN int XMLCALL
-		    xmlRegExecNextValues(xmlRegExecCtxtPtr exec,
-					 int *nbval,
-					 int *nbneg,
-					 xmlChar **values,
-					 int *terminal);
-XMLPUBFUN int XMLCALL
-		    xmlRegExecErrInfo	(xmlRegExecCtxtPtr exec,
-					 const xmlChar **string,
-					 int *nbval,
-					 int *nbneg,
-					 xmlChar **values,
-					 int *terminal);
-#ifdef LIBXML_EXPR_ENABLED
-/*
- * Formal regular expression handling
- * Its goal is to do some formal work on content models
- */
-
-/* expressions are used within a context */
-typedef struct _xmlExpCtxt xmlExpCtxt;
-typedef xmlExpCtxt *xmlExpCtxtPtr;
-
-XMLPUBFUN void XMLCALL
-			xmlExpFreeCtxt	(xmlExpCtxtPtr ctxt);
-XMLPUBFUN xmlExpCtxtPtr XMLCALL
-			xmlExpNewCtxt	(int maxNodes,
-					 xmlDictPtr dict);
-
-XMLPUBFUN int XMLCALL
-			xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL
-			xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt);
-
-/* Expressions are trees but the tree is opaque */
-typedef struct _xmlExpNode xmlExpNode;
-typedef xmlExpNode *xmlExpNodePtr;
-
-typedef enum {
-    XML_EXP_EMPTY = 0,
-    XML_EXP_FORBID = 1,
-    XML_EXP_ATOM = 2,
-    XML_EXP_SEQ = 3,
-    XML_EXP_OR = 4,
-    XML_EXP_COUNT = 5
-} xmlExpNodeType;
-
-/*
- * 2 core expressions shared by all for the empty language set
- * and for the set with just the empty token
- */
-XMLPUBVAR xmlExpNodePtr forbiddenExp;
-XMLPUBVAR xmlExpNodePtr emptyExp;
-
-/*
- * Expressions are reference counted internally
- */
-XMLPUBFUN void XMLCALL
-			xmlExpFree	(xmlExpCtxtPtr ctxt,
-					 xmlExpNodePtr expr);
-XMLPUBFUN void XMLCALL
-			xmlExpRef	(xmlExpNodePtr expr);
-
-/*
- * constructors can be either manual or from a string
- */
-XMLPUBFUN xmlExpNodePtr XMLCALL
-			xmlExpParse	(xmlExpCtxtPtr ctxt,
-					 const char *expr);
-XMLPUBFUN xmlExpNodePtr XMLCALL
-			xmlExpNewAtom	(xmlExpCtxtPtr ctxt,
-					 const xmlChar *name,
-					 int len);
-XMLPUBFUN xmlExpNodePtr XMLCALL
-			xmlExpNewOr	(xmlExpCtxtPtr ctxt,
-					 xmlExpNodePtr left,
-					 xmlExpNodePtr right);
-XMLPUBFUN xmlExpNodePtr XMLCALL
-			xmlExpNewSeq	(xmlExpCtxtPtr ctxt,
-					 xmlExpNodePtr left,
-					 xmlExpNodePtr right);
-XMLPUBFUN xmlExpNodePtr XMLCALL
-			xmlExpNewRange	(xmlExpCtxtPtr ctxt,
-					 xmlExpNodePtr subset,
-					 int min,
-					 int max);
-/*
- * The really interesting APIs
- */
-XMLPUBFUN int XMLCALL
-			xmlExpIsNillable(xmlExpNodePtr expr);
-XMLPUBFUN int XMLCALL
-			xmlExpMaxToken	(xmlExpNodePtr expr);
-XMLPUBFUN int XMLCALL
-			xmlExpGetLanguage(xmlExpCtxtPtr ctxt,
-					 xmlExpNodePtr expr,
-					 const xmlChar**langList,
-					 int len);
-XMLPUBFUN int XMLCALL
-			xmlExpGetStart	(xmlExpCtxtPtr ctxt,
-					 xmlExpNodePtr expr,
-					 const xmlChar**tokList,
-					 int len);
-XMLPUBFUN xmlExpNodePtr XMLCALL
-			xmlExpStringDerive(xmlExpCtxtPtr ctxt,
-					 xmlExpNodePtr expr,
-					 const xmlChar *str,
-					 int len);
-XMLPUBFUN xmlExpNodePtr XMLCALL
-			xmlExpExpDerive	(xmlExpCtxtPtr ctxt,
-					 xmlExpNodePtr expr,
-					 xmlExpNodePtr sub);
-XMLPUBFUN int XMLCALL
-			xmlExpSubsume	(xmlExpCtxtPtr ctxt,
-					 xmlExpNodePtr expr,
-					 xmlExpNodePtr sub);
-XMLPUBFUN void XMLCALL
-			xmlExpDump	(xmlBufferPtr buf,
-					 xmlExpNodePtr expr);
-#endif /* LIBXML_EXPR_ENABLED */
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LIBXML_REGEXP_ENABLED */
-
-#endif /*__XML_REGEXP_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/xmlschemas.h

@@ -1,246 +0,0 @@
-/*
- * Summary: incomplete XML Schemas structure implementation
- * Description: interface to the XML Schemas handling and schema validity
- *              checking, it is incomplete right now.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-
-#ifndef __XML_SCHEMA_H__
-#define __XML_SCHEMA_H__
-
-#include <libxml/xmlversion.h>
-
-#ifdef LIBXML_SCHEMAS_ENABLED
-
-#include <libxml/tree.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * This error codes are obsolete; not used any more.
- */
-typedef enum {
-    XML_SCHEMAS_ERR_OK		= 0,
-    XML_SCHEMAS_ERR_NOROOT	= 1,
-    XML_SCHEMAS_ERR_UNDECLAREDELEM,
-    XML_SCHEMAS_ERR_NOTTOPLEVEL,
-    XML_SCHEMAS_ERR_MISSING,
-    XML_SCHEMAS_ERR_WRONGELEM,
-    XML_SCHEMAS_ERR_NOTYPE,
-    XML_SCHEMAS_ERR_NOROLLBACK,
-    XML_SCHEMAS_ERR_ISABSTRACT,
-    XML_SCHEMAS_ERR_NOTEMPTY,
-    XML_SCHEMAS_ERR_ELEMCONT,
-    XML_SCHEMAS_ERR_HAVEDEFAULT,
-    XML_SCHEMAS_ERR_NOTNILLABLE,
-    XML_SCHEMAS_ERR_EXTRACONTENT,
-    XML_SCHEMAS_ERR_INVALIDATTR,
-    XML_SCHEMAS_ERR_INVALIDELEM,
-    XML_SCHEMAS_ERR_NOTDETERMINIST,
-    XML_SCHEMAS_ERR_CONSTRUCT,
-    XML_SCHEMAS_ERR_INTERNAL,
-    XML_SCHEMAS_ERR_NOTSIMPLE,
-    XML_SCHEMAS_ERR_ATTRUNKNOWN,
-    XML_SCHEMAS_ERR_ATTRINVALID,
-    XML_SCHEMAS_ERR_VALUE,
-    XML_SCHEMAS_ERR_FACET,
-    XML_SCHEMAS_ERR_,
-    XML_SCHEMAS_ERR_XXX
-} xmlSchemaValidError;
-
-/*
-* ATTENTION: Change xmlSchemaSetValidOptions's check
-* for invalid values, if adding to the validation
-* options below.
-*/
-/**
- * xmlSchemaValidOption:
- *
- * This is the set of XML Schema validation options.
- */
-typedef enum {
-    XML_SCHEMA_VAL_VC_I_CREATE			= 1<<0
-	/* Default/fixed: create an attribute node
-	* or an element's text node on the instance.
-	*/
-} xmlSchemaValidOption;
-
-/*
-    XML_SCHEMA_VAL_XSI_ASSEMBLE			= 1<<1,
-	* assemble schemata using
-	* xsi:schemaLocation and
-	* xsi:noNamespaceSchemaLocation
-*/
-
-/**
- * The schemas related types are kept internal
- */
-typedef struct _xmlSchema xmlSchema;
-typedef xmlSchema *xmlSchemaPtr;
-
-/**
- * xmlSchemaValidityErrorFunc:
- * @ctx: the validation context
- * @msg: the message
- * @...: extra arguments
- *
- * Signature of an error callback from an XSD validation
- */
-typedef void (XMLCDECL *xmlSchemaValidityErrorFunc)
-                 (void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
-
-/**
- * xmlSchemaValidityWarningFunc:
- * @ctx: the validation context
- * @msg: the message
- * @...: extra arguments
- *
- * Signature of a warning callback from an XSD validation
- */
-typedef void (XMLCDECL *xmlSchemaValidityWarningFunc)
-                 (void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3);
-
-/**
- * A schemas validation context
- */
-typedef struct _xmlSchemaParserCtxt xmlSchemaParserCtxt;
-typedef xmlSchemaParserCtxt *xmlSchemaParserCtxtPtr;
-
-typedef struct _xmlSchemaValidCtxt xmlSchemaValidCtxt;
-typedef xmlSchemaValidCtxt *xmlSchemaValidCtxtPtr;
-
-/**
- * xmlSchemaValidityLocatorFunc:
- * @ctx: user provided context
- * @file: returned file information
- * @line: returned line information
- *
- * A schemas validation locator, a callback called by the validator.
- * This is used when file or node informations are not available
- * to find out what file and line number are affected
- *
- * Returns: 0 in case of success and -1 in case of error
- */
-
-typedef int (XMLCDECL *xmlSchemaValidityLocatorFunc) (void *ctx,
-                           const char **file, unsigned long *line);
-
-/*
- * Interfaces for parsing.
- */
-XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL
-	    xmlSchemaNewParserCtxt	(const char *URL);
-XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL
-	    xmlSchemaNewMemParserCtxt	(const char *buffer,
-					 int size);
-XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL
-	    xmlSchemaNewDocParserCtxt	(xmlDocPtr doc);
-XMLPUBFUN void XMLCALL
-	    xmlSchemaFreeParserCtxt	(xmlSchemaParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL
-	    xmlSchemaSetParserErrors	(xmlSchemaParserCtxtPtr ctxt,
-					 xmlSchemaValidityErrorFunc err,
-					 xmlSchemaValidityWarningFunc warn,
-					 void *ctx);
-XMLPUBFUN void XMLCALL
-	    xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxtPtr ctxt,
-					 xmlStructuredErrorFunc serror,
-					 void *ctx);
-XMLPUBFUN int XMLCALL
-		xmlSchemaGetParserErrors(xmlSchemaParserCtxtPtr ctxt,
-					xmlSchemaValidityErrorFunc * err,
-					xmlSchemaValidityWarningFunc * warn,
-					void **ctx);
-XMLPUBFUN int XMLCALL
-		xmlSchemaIsValid	(xmlSchemaValidCtxtPtr ctxt);
-
-XMLPUBFUN xmlSchemaPtr XMLCALL
-	    xmlSchemaParse		(xmlSchemaParserCtxtPtr ctxt);
-XMLPUBFUN void XMLCALL
-	    xmlSchemaFree		(xmlSchemaPtr schema);
-#ifdef LIBXML_OUTPUT_ENABLED
-XMLPUBFUN void XMLCALL
-	    xmlSchemaDump		(FILE *output,
-					 xmlSchemaPtr schema);
-#endif /* LIBXML_OUTPUT_ENABLED */
-/*
- * Interfaces for validating
- */
-XMLPUBFUN void XMLCALL
-	    xmlSchemaSetValidErrors	(xmlSchemaValidCtxtPtr ctxt,
-					 xmlSchemaValidityErrorFunc err,
-					 xmlSchemaValidityWarningFunc warn,
-					 void *ctx);
-XMLPUBFUN void XMLCALL
-	    xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxtPtr ctxt,
-					 xmlStructuredErrorFunc serror,
-					 void *ctx);
-XMLPUBFUN int XMLCALL
-	    xmlSchemaGetValidErrors	(xmlSchemaValidCtxtPtr ctxt,
-					 xmlSchemaValidityErrorFunc *err,
-					 xmlSchemaValidityWarningFunc *warn,
-					 void **ctx);
-XMLPUBFUN int XMLCALL
-	    xmlSchemaSetValidOptions	(xmlSchemaValidCtxtPtr ctxt,
-					 int options);
-XMLPUBFUN void XMLCALL
-            xmlSchemaValidateSetFilename(xmlSchemaValidCtxtPtr vctxt,
-	                                 const char *filename);
-XMLPUBFUN int XMLCALL
-	    xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxtPtr ctxt);
-
-XMLPUBFUN xmlSchemaValidCtxtPtr XMLCALL
-	    xmlSchemaNewValidCtxt	(xmlSchemaPtr schema);
-XMLPUBFUN void XMLCALL
-	    xmlSchemaFreeValidCtxt	(xmlSchemaValidCtxtPtr ctxt);
-XMLPUBFUN int XMLCALL
-	    xmlSchemaValidateDoc	(xmlSchemaValidCtxtPtr ctxt,
-					 xmlDocPtr instance);
-XMLPUBFUN int XMLCALL
-            xmlSchemaValidateOneElement (xmlSchemaValidCtxtPtr ctxt,
-			                 xmlNodePtr elem);
-XMLPUBFUN int XMLCALL
-	    xmlSchemaValidateStream	(xmlSchemaValidCtxtPtr ctxt,
-					 xmlParserInputBufferPtr input,
-					 xmlCharEncoding enc,
-					 xmlSAXHandlerPtr sax,
-					 void *user_data);
-XMLPUBFUN int XMLCALL
-	    xmlSchemaValidateFile	(xmlSchemaValidCtxtPtr ctxt,
-					 const char * filename,
-					 int options);
-
-XMLPUBFUN xmlParserCtxtPtr XMLCALL
-	    xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxtPtr ctxt);
-
-/*
- * Interface to insert Schemas SAX validation in a SAX stream
- */
-typedef struct _xmlSchemaSAXPlug xmlSchemaSAXPlugStruct;
-typedef xmlSchemaSAXPlugStruct *xmlSchemaSAXPlugPtr;
-
-XMLPUBFUN xmlSchemaSAXPlugPtr XMLCALL
-            xmlSchemaSAXPlug		(xmlSchemaValidCtxtPtr ctxt,
-					 xmlSAXHandlerPtr *sax,
-					 void **user_data);
-XMLPUBFUN int XMLCALL
-            xmlSchemaSAXUnplug		(xmlSchemaSAXPlugPtr plug);
-
-
-XMLPUBFUN void XMLCALL
-            xmlSchemaValidateSetLocator	(xmlSchemaValidCtxtPtr vctxt,
-					 xmlSchemaValidityLocatorFunc f,
-					 void *ctxt);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LIBXML_SCHEMAS_ENABLED */
-#endif /* __XML_SCHEMA_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/xmlstring.h

@@ -1,140 +0,0 @@
-/*
- * Summary: set of routines to process strings
- * Description: type and interfaces needed for the internal string handling
- *              of the library, especially UTF8 processing.
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#ifndef __XML_STRING_H__
-#define __XML_STRING_H__
-
-#include <stdarg.h>
-#include <libxml/xmlversion.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * xmlChar:
- *
- * This is a basic byte in an UTF-8 encoded string.
- * It's unsigned allowing to pinpoint case where char * are assigned
- * to xmlChar * (possibly making serialization back impossible).
- */
-typedef unsigned char xmlChar;
-
-/**
- * BAD_CAST:
- *
- * Macro to cast a string to an xmlChar * when one know its safe.
- */
-#define BAD_CAST (xmlChar *)
-
-/*
- * xmlChar handling
- */
-XMLPUBFUN xmlChar * XMLCALL
-                xmlStrdup                (const xmlChar *cur);
-XMLPUBFUN xmlChar * XMLCALL
-                xmlStrndup               (const xmlChar *cur,
-                                         int len);
-XMLPUBFUN xmlChar * XMLCALL
-                xmlCharStrndup           (const char *cur,
-                                         int len);
-XMLPUBFUN xmlChar * XMLCALL
-                xmlCharStrdup            (const char *cur);
-XMLPUBFUN xmlChar * XMLCALL
-                xmlStrsub                (const xmlChar *str,
-                                         int start,
-                                         int len);
-XMLPUBFUN const xmlChar * XMLCALL
-                xmlStrchr                (const xmlChar *str,
-                                         xmlChar val);
-XMLPUBFUN const xmlChar * XMLCALL
-                xmlStrstr                (const xmlChar *str,
-                                         const xmlChar *val);
-XMLPUBFUN const xmlChar * XMLCALL
-                xmlStrcasestr            (const xmlChar *str,
-                                         const xmlChar *val);
-XMLPUBFUN int XMLCALL
-                xmlStrcmp                (const xmlChar *str1,
-                                         const xmlChar *str2);
-XMLPUBFUN int XMLCALL
-                xmlStrncmp               (const xmlChar *str1,
-                                         const xmlChar *str2,
-                                         int len);
-XMLPUBFUN int XMLCALL
-                xmlStrcasecmp            (const xmlChar *str1,
-                                         const xmlChar *str2);
-XMLPUBFUN int XMLCALL
-                xmlStrncasecmp           (const xmlChar *str1,
-                                         const xmlChar *str2,
-                                         int len);
-XMLPUBFUN int XMLCALL
-                xmlStrEqual              (const xmlChar *str1,
-                                         const xmlChar *str2);
-XMLPUBFUN int XMLCALL
-                xmlStrQEqual             (const xmlChar *pref,
-                                         const xmlChar *name,
-                                         const xmlChar *str);
-XMLPUBFUN int XMLCALL
-                xmlStrlen                (const xmlChar *str);
-XMLPUBFUN xmlChar * XMLCALL
-                xmlStrcat                (xmlChar *cur,
-                                         const xmlChar *add);
-XMLPUBFUN xmlChar * XMLCALL
-                xmlStrncat               (xmlChar *cur,
-                                         const xmlChar *add,
-                                         int len);
-XMLPUBFUN xmlChar * XMLCALL
-                xmlStrncatNew            (const xmlChar *str1,
-                                         const xmlChar *str2,
-                                         int len);
-XMLPUBFUN int XMLCALL
-                xmlStrPrintf             (xmlChar *buf,
-                                         int len,
-                                         const xmlChar *msg,
-                                         ...);
-XMLPUBFUN int XMLCALL
-                xmlStrVPrintf                (xmlChar *buf,
-                                         int len,
-                                         const xmlChar *msg,
-                                         va_list ap);
-
-XMLPUBFUN int XMLCALL
-        xmlGetUTF8Char                   (const unsigned char *utf,
-                                         int *len);
-XMLPUBFUN int XMLCALL
-        xmlCheckUTF8                     (const unsigned char *utf);
-XMLPUBFUN int XMLCALL
-        xmlUTF8Strsize                   (const xmlChar *utf,
-                                         int len);
-XMLPUBFUN xmlChar * XMLCALL
-        xmlUTF8Strndup                   (const xmlChar *utf,
-                                         int len);
-XMLPUBFUN const xmlChar * XMLCALL
-        xmlUTF8Strpos                    (const xmlChar *utf,
-                                         int pos);
-XMLPUBFUN int XMLCALL
-        xmlUTF8Strloc                    (const xmlChar *utf,
-                                         const xmlChar *utfchar);
-XMLPUBFUN xmlChar * XMLCALL
-        xmlUTF8Strsub                    (const xmlChar *utf,
-                                         int start,
-                                         int len);
-XMLPUBFUN int XMLCALL
-        xmlUTF8Strlen                    (const xmlChar *utf);
-XMLPUBFUN int XMLCALL
-        xmlUTF8Size                      (const xmlChar *utf);
-XMLPUBFUN int XMLCALL
-        xmlUTF8Charcmp                   (const xmlChar *utf1,
-                                         const xmlChar *utf2);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* __XML_STRING_H__ */

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/libxml/xmlversion.h

@@ -1,480 +0,0 @@
-/*
- * Summary: compile-time version informations
- * Description: compile-time version informations for the XML library
- *
- * Copy: See Copyright for the status of this software.
- *
- * Author: Daniel Veillard
- */
-
-#ifndef __XML_VERSION_H__
-#define __XML_VERSION_H__
-
-#include <libxml/xmlexports.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * use those to be sure nothing nasty will happen if
- * your library and includes mismatch
- */
-#ifndef LIBXML2_COMPILING_MSCCDEF
-XMLPUBFUN void XMLCALL xmlCheckVersion(int version);
-#endif /* LIBXML2_COMPILING_MSCCDEF */
-
-/**
- * LIBXML_DOTTED_VERSION:
- *
- * the version string like "1.2.3"
- */
-#define LIBXML_DOTTED_VERSION "2.9.0"
-
-/**
- * LIBXML_VERSION:
- *
- * the version number: 1.2.3 value is 10203
- */
-#define LIBXML_VERSION 20900
-
-/**
- * LIBXML_VERSION_STRING:
- *
- * the version number string, 1.2.3 value is "10203"
- */
-#define LIBXML_VERSION_STRING "20900"
-
-/**
- * LIBXML_VERSION_EXTRA:
- *
- * extra version information, used to show a CVS compilation
- */
-#define LIBXML_VERSION_EXTRA ""
-
-/**
- * LIBXML_TEST_VERSION:
- *
- * Macro to check that the libxml version in use is compatible with
- * the version the software has been compiled against
- */
-#define LIBXML_TEST_VERSION xmlCheckVersion(20900);
-
-#ifndef VMS
-#if 0
-/**
- * WITH_TRIO:
- *
- * defined if the trio support need to be configured in
- */
-#define WITH_TRIO
-#else
-/**
- * WITHOUT_TRIO:
- *
- * defined if the trio support should not be configured in
- */
-#define WITHOUT_TRIO
-#endif
-#else /* VMS */
-/**
- * WITH_TRIO:
- *
- * defined if the trio support need to be configured in
- */
-#define WITH_TRIO 1
-#endif /* VMS */
-
-/**
- * LIBXML_THREAD_ENABLED:
- *
- * Whether the thread support is configured in
- */
-#if 1
-#if defined(_REENTRANT) || defined(__MT__) || \
-    (defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE - 0 >= 199506L))
-#define LIBXML_THREAD_ENABLED
-#endif
-#endif
-
-/**
- * LIBXML_TREE_ENABLED:
- *
- * Whether the DOM like tree manipulation API support is configured in
- */
-#if 1
-#define LIBXML_TREE_ENABLED
-#endif
-
-/**
- * LIBXML_OUTPUT_ENABLED:
- *
- * Whether the serialization/saving support is configured in
- */
-#if 1
-#define LIBXML_OUTPUT_ENABLED
-#endif
-
-/**
- * LIBXML_PUSH_ENABLED:
- *
- * Whether the push parsing interfaces are configured in
- */
-#if 1
-#define LIBXML_PUSH_ENABLED
-#endif
-
-/**
- * LIBXML_READER_ENABLED:
- *
- * Whether the xmlReader parsing interface is configured in
- */
-#if 1
-#define LIBXML_READER_ENABLED
-#endif
-
-/**
- * LIBXML_PATTERN_ENABLED:
- *
- * Whether the xmlPattern node selection interface is configured in
- */
-#if 1
-#define LIBXML_PATTERN_ENABLED
-#endif
-
-/**
- * LIBXML_WRITER_ENABLED:
- *
- * Whether the xmlWriter saving interface is configured in
- */
-#if 1
-#define LIBXML_WRITER_ENABLED
-#endif
-
-/**
- * LIBXML_SAX1_ENABLED:
- *
- * Whether the older SAX1 interface is configured in
- */
-#if 1
-#define LIBXML_SAX1_ENABLED
-#endif
-
-/**
- * LIBXML_FTP_ENABLED:
- *
- * Whether the FTP support is configured in
- */
-#if 1
-#define LIBXML_FTP_ENABLED
-#endif
-
-/**
- * LIBXML_HTTP_ENABLED:
- *
- * Whether the HTTP support is configured in
- */
-#if 1
-#define LIBXML_HTTP_ENABLED
-#endif
-
-/**
- * LIBXML_VALID_ENABLED:
- *
- * Whether the DTD validation support is configured in
- */
-#if 1
-#define LIBXML_VALID_ENABLED
-#endif
-
-/**
- * LIBXML_HTML_ENABLED:
- *
- * Whether the HTML support is configured in
- */
-#if 1
-#define LIBXML_HTML_ENABLED
-#endif
-
-/**
- * LIBXML_LEGACY_ENABLED:
- *
- * Whether the deprecated APIs are compiled in for compatibility
- */
-#if 1
-#define LIBXML_LEGACY_ENABLED
-#endif
-
-/**
- * LIBXML_C14N_ENABLED:
- *
- * Whether the Canonicalization support is configured in
- */
-#if 1
-#define LIBXML_C14N_ENABLED
-#endif
-
-/**
- * LIBXML_CATALOG_ENABLED:
- *
- * Whether the Catalog support is configured in
- */
-#if 1
-#define LIBXML_CATALOG_ENABLED
-#endif
-
-/**
- * LIBXML_DOCB_ENABLED:
- *
- * Whether the SGML Docbook support is configured in
- */
-#if 1
-#define LIBXML_DOCB_ENABLED
-#endif
-
-/**
- * LIBXML_XPATH_ENABLED:
- *
- * Whether XPath is configured in
- */
-#if 1
-#define LIBXML_XPATH_ENABLED
-#endif
-
-/**
- * LIBXML_XPTR_ENABLED:
- *
- * Whether XPointer is configured in
- */
-#if 1
-#define LIBXML_XPTR_ENABLED
-#endif
-
-/**
- * LIBXML_XINCLUDE_ENABLED:
- *
- * Whether XInclude is configured in
- */
-#if 1
-#define LIBXML_XINCLUDE_ENABLED
-#endif
-
-/**
- * LIBXML_ICONV_ENABLED:
- *
- * Whether iconv support is available
- */
-#if 0
-#define LIBXML_ICONV_ENABLED
-#endif
-
-/**
- * LIBXML_ICU_ENABLED:
- *
- * Whether icu support is available
- */
-#if 0
-#define LIBXML_ICU_ENABLED
-#endif
-
-/**
- * LIBXML_ISO8859X_ENABLED:
- *
- * Whether ISO-8859-* support is made available in case iconv is not
- */
-#if 0
-#define LIBXML_ISO8859X_ENABLED
-#endif
-
-/**
- * LIBXML_DEBUG_ENABLED:
- *
- * Whether Debugging module is configured in
- */
-#if 1
-#define LIBXML_DEBUG_ENABLED
-#endif
-
-/**
- * DEBUG_MEMORY_LOCATION:
- *
- * Whether the memory debugging is configured in
- */
-#if 0
-#define DEBUG_MEMORY_LOCATION
-#endif
-
-/**
- * LIBXML_DEBUG_RUNTIME:
- *
- * Whether the runtime debugging is configured in
- */
-#if 0
-#define LIBXML_DEBUG_RUNTIME
-#endif
-
-/**
- * LIBXML_UNICODE_ENABLED:
- *
- * Whether the Unicode related interfaces are compiled in
- */
-#if 1
-#define LIBXML_UNICODE_ENABLED
-#endif
-
-/**
- * LIBXML_REGEXP_ENABLED:
- *
- * Whether the regular expressions interfaces are compiled in
- */
-#if 1
-#define LIBXML_REGEXP_ENABLED
-#endif
-
-/**
- * LIBXML_AUTOMATA_ENABLED:
- *
- * Whether the automata interfaces are compiled in
- */
-#if 1
-#define LIBXML_AUTOMATA_ENABLED
-#endif
-
-/**
- * LIBXML_EXPR_ENABLED:
- *
- * Whether the formal expressions interfaces are compiled in
- */
-#if 1
-#define LIBXML_EXPR_ENABLED
-#endif
-
-/**
- * LIBXML_SCHEMAS_ENABLED:
- *
- * Whether the Schemas validation interfaces are compiled in
- */
-#if 1
-#define LIBXML_SCHEMAS_ENABLED
-#endif
-
-/**
- * LIBXML_SCHEMATRON_ENABLED:
- *
- * Whether the Schematron validation interfaces are compiled in
- */
-#if 1
-#define LIBXML_SCHEMATRON_ENABLED
-#endif
-
-/**
- * LIBXML_MODULES_ENABLED:
- *
- * Whether the module interfaces are compiled in
- */
-#if 1
-#define LIBXML_MODULES_ENABLED
-/**
- * LIBXML_MODULE_EXTENSION:
- *
- * the string suffix used by dynamic modules (usually shared libraries)
- */
-#define LIBXML_MODULE_EXTENSION ".dll" 
-#endif
-
-/**
- * LIBXML_ZLIB_ENABLED:
- *
- * Whether the Zlib support is compiled in
- */
-#if 0
-#define LIBXML_ZLIB_ENABLED
-#endif
-
-/**
- * LIBXML_LZMA_ENABLED:
- *
- * Whether the Lzma support is compiled in
- */
-#if 0
-#define LIBXML_LZMA_ENABLED
-#endif
-
-#ifdef __GNUC__
-#ifdef HAVE_ANSIDECL_H
-#include <ansidecl.h>
-#endif
-
-/**
- * ATTRIBUTE_UNUSED:
- *
- * Macro used to signal to GCC unused function parameters
- */
-
-#ifndef ATTRIBUTE_UNUSED
-# if ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >= 7)))
-#  define ATTRIBUTE_UNUSED __attribute__((unused))
-# else
-#  define ATTRIBUTE_UNUSED
-# endif
-#endif
-
-/**
- * LIBXML_ATTR_ALLOC_SIZE:
- *
- * Macro used to indicate to GCC this is an allocator function
- */
-
-#ifndef LIBXML_ATTR_ALLOC_SIZE
-# if ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)))
-#  define LIBXML_ATTR_ALLOC_SIZE(x) __attribute__((alloc_size(x)))
-# else
-#  define LIBXML_ATTR_ALLOC_SIZE(x)
-# endif
-#else
-# define LIBXML_ATTR_ALLOC_SIZE(x)
-#endif
-
-/**
- * LIBXML_ATTR_FORMAT:
- *
- * Macro used to indicate to GCC the parameter are printf like
- */
-
-#ifndef LIBXML_ATTR_FORMAT
-# if ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)))
-#  define LIBXML_ATTR_FORMAT(fmt,args) __attribute__((__format__(__printf__,fmt,args)))
-# else
-#  define LIBXML_ATTR_FORMAT(fmt,args)
-# endif
-#else
-# define LIBXML_ATTR_FORMAT(fmt,args)
-#endif
-
-#else /* ! __GNUC__ */
-/**
- * ATTRIBUTE_UNUSED:
- *
- * Macro used to signal to GCC unused function parameters
- */
-#define ATTRIBUTE_UNUSED
-/**
- * LIBXML_ATTR_ALLOC_SIZE:
- *
- * Macro used to indicate to GCC this is an allocator function
- */
-#define LIBXML_ATTR_ALLOC_SIZE(x)
-/**
- * LIBXML_ATTR_FORMAT:
- *
- * Macro used to indicate to GCC the parameter are printf like
- */
-#define LIBXML_ATTR_FORMAT(fmt,args)
-#endif /* __GNUC__ */
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif
-
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/sim_support.c

@@ -1,534 +0,0 @@
-/* -------------------------------------------------------------------------
- * sim_support.c
- * Functions used by both FMU simulators fmu10sim_me and fmu10sim_cs
- * to parse command-line arguments, to unzip and load an fmu, 
- * to write CSV file, and more.
- * Copyright QTronic GmbH. All rights reserved.
- * -------------------------------------------------------------------------*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <stdarg.h>
-
-#ifdef FMI_COSIMULATION
-#include "fmi_cs.h"
-#else
-#include "fmi_me.h"
-#endif
-
-#include "xmlVersionParser.h"
-#include "sim_support.h"
-
-extern FMU fmu;
-
-int unzip(const char *zipPath, const char *outPath) {
-    int code;
-    char cwd[BUFSIZE];
-    char binPath[BUFSIZE];
-    int n = strlen(UNZIP_CMD) + strlen(outPath) + 3 +  strlen(zipPath) + 9;
-    char* cmd = (char*)calloc(sizeof(char), n);
-
-    // remember current directory
-    if (!GetCurrentDirectory(BUFSIZE, cwd)) {
-        printf ("error: Could not get current directory\n");
-        return 0; // error
-    }
-
-    // change to %FMUSDK_HOME%\bin to find 7z.dll and 7z.exe
-    if (!GetEnvironmentVariable("FMUSDK_HOME", binPath, BUFSIZE)) {
-        if (GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
-            printf ("error: Environment variable FMUSDK_HOME not defined\n");
-        }
-        else {
-            printf ("error: Could not get value of FMUSDK_HOME\n");
-        }
-        return 0; // error
-    }
-    strcat(binPath, "\\bin");
-    if (!SetCurrentDirectory(binPath)) {
-        printf ("error: could not change to directory '%s'\n", binPath);
-        return 0; // error
-    }
-
-    // run the unzip command
-    // remove "> NUL" to see the unzip protocol
-    sprintf(cmd, "%s\"%s\" \"%s\" > NUL", UNZIP_CMD, outPath, zipPath);
-    // printf("cmd='%s'\n", cmd);
-    code = system(cmd);
-    free(cmd);
-    if (code!=SEVEN_ZIP_NO_ERROR) {
-        printf("7z: ");
-        switch (code) {
-            case SEVEN_ZIP_WARNING:            printf("warning\n"); break;
-            case SEVEN_ZIP_ERROR:              printf("error\n"); break;
-            case SEVEN_ZIP_COMMAND_LINE_ERROR: printf("command line error\n"); break;
-            case SEVEN_ZIP_OUT_OF_MEMORY:      printf("out of memory\n"); break;
-            case SEVEN_ZIP_STOPPED_BY_USER:    printf("stopped by user\n"); break;
-            default: printf("unknown problem\n");
-        }
-    }
-
-    // restore current directory
-    SetCurrentDirectory(cwd);
-
-    return (code==SEVEN_ZIP_NO_ERROR || code==SEVEN_ZIP_WARNING) ? 1 : 0;
-}
-
-// fileName is an absolute path, e.g. C:\test\a.fmu
-// or relative to the current dir, e.g. ..\test\a.fmu
-// Does not check for existence of the file
-static char* getFmuPath(const char* fileName){
-    char pathName[MAX_PATH];
-    int n = GetFullPathName(fileName, MAX_PATH, pathName, NULL);
-    return n ? strdup(pathName) : NULL;
-}
-
-static char* getTmpPath() {
-    char tmpPath[BUFSIZE];
-    if(! GetTempPath(BUFSIZE, tmpPath)) {
-        printf ("error: Could not find temporary disk space\n");
-        return NULL;
-    }
-    strcat(tmpPath, "fmu\\");
-    return strdup(tmpPath);
-}
-
-char *getTempFmuLocation() {
-    char *tempPath = getTmpPath();
-    char *fmuLocation = (char *)calloc(sizeof(char), 8 + strlen(tempPath));
-    strcpy(fmuLocation, "file://");
-    strcat(fmuLocation, tempPath);
-    free(tempPath);
-    return fmuLocation;
-}
-
-static void* getAdr(int* s, FMU *fmu, const char* functionName){
-    char name[BUFSIZE];
-    void* fp;
-    sprintf(name, "%s_%s", getModelIdentifier(fmu->modelDescription), functionName);
-    fp = GetProcAddress(fmu->dllHandle, name);
-    if (!fp) {
-        printf ("warning: Function %s not found in dll\n", name);
-        *s = 0; // mark dll load as 'failed'
-    }
-    return fp;
-}
-
-// Load the given dll and set function pointers in fmu
-// Return 0 to indicate failure
-static int loadDll(const char* dllPath, FMU *fmu) {
-    int x = 1, s = 1;
-    HANDLE h = LoadLibrary(dllPath);
-    if (!h) {
-        printf("error: Could not load %s\n", dllPath);
-        return 0; // failure
-    }
-    fmu->dllHandle = h;
-
-#ifdef FMI_COSIMULATION   
-    fmu->getTypesPlatform        = (fGetTypesPlatform)   getAdr(&s, fmu, "fmiGetTypesPlatform");
-    if (s==0) { 
-        s = 1; // work around bug for FMUs exported using Dymola 2012 and SimulationX 3.x
-        fmu->getTypesPlatform    = (fGetTypesPlatform)   getAdr(&s, fmu, "fmiGetModelTypesPlatform");
-        if (s==1) printf("  using fmiGetModelTypesPlatform instead\n", dllPath);
-    }
-    fmu->instantiateSlave        = (fInstantiateSlave)   getAdr(&s, fmu, "fmiInstantiateSlave");
-    fmu->initializeSlave         = (fInitializeSlave)    getAdr(&s, fmu, "fmiInitializeSlave");
-    fmu->terminateSlave          = (fTerminateSlave)     getAdr(&s, fmu, "fmiTerminateSlave");
-    fmu->resetSlave              = (fResetSlave)         getAdr(&s, fmu, "fmiResetSlave");
-    fmu->freeSlaveInstance       = (fFreeSlaveInstance)  getAdr(&s, fmu, "fmiFreeSlaveInstance");
-    fmu->setRealInputDerivatives = (fSetRealInputDerivatives) getAdr(&s, fmu, "fmiSetRealInputDerivatives");
-    fmu->getRealOutputDerivatives = (fGetRealOutputDerivatives) getAdr(&s, fmu, "fmiGetRealOutputDerivatives");
-    fmu->cancelStep              = (fCancelStep)         getAdr(&s, fmu, "fmiCancelStep");
-    fmu->doStep                  = (fDoStep)             getAdr(&s, fmu, "fmiDoStep");
-    // SimulationX 3.4 and 3.5 do not yet export getStatus and getXStatus: do not count this as failure here
-    fmu->getStatus               = (fGetStatus)          getAdr(&x, fmu, "fmiGetStatus");
-    fmu->getRealStatus           = (fGetRealStatus)      getAdr(&x, fmu, "fmiGetRealStatus");
-    fmu->getIntegerStatus        = (fGetIntegerStatus)   getAdr(&x, fmu, "fmiGetIntegerStatus");
-    fmu->getBooleanStatus        = (fGetBooleanStatus)   getAdr(&x, fmu, "fmiGetBooleanStatus");
-    fmu->getStringStatus         = (fGetStringStatus)    getAdr(&x, fmu, "fmiGetStringStatus");
-
-#else // FMI for Model Exchange 1.0
-    fmu->getModelTypesPlatform   = (fGetModelTypesPlatform) getAdr(&s, fmu, "fmiGetModelTypesPlatform");
-    fmu->instantiateModel        = (fInstantiateModel)   getAdr(&s, fmu, "fmiInstantiateModel");
-    fmu->freeModelInstance       = (fFreeModelInstance)  getAdr(&s, fmu, "fmiFreeModelInstance");
-    fmu->setTime                 = (fSetTime)            getAdr(&s, fmu, "fmiSetTime");
-    fmu->setContinuousStates     = (fSetContinuousStates)getAdr(&s, fmu, "fmiSetContinuousStates");
-    fmu->completedIntegratorStep = (fCompletedIntegratorStep)getAdr(&s, fmu, "fmiCompletedIntegratorStep");
-    fmu->initialize              = (fInitialize)         getAdr(&s, fmu, "fmiInitialize");
-    fmu->getDerivatives          = (fGetDerivatives)     getAdr(&s, fmu, "fmiGetDerivatives");
-    fmu->getEventIndicators      = (fGetEventIndicators) getAdr(&s, fmu, "fmiGetEventIndicators");
-    fmu->eventUpdate             = (fEventUpdate)        getAdr(&s, fmu, "fmiEventUpdate");
-    fmu->getContinuousStates     = (fGetContinuousStates)getAdr(&s, fmu, "fmiGetContinuousStates");
-    fmu->getNominalContinuousStates = (fGetNominalContinuousStates)getAdr(&s, fmu, "fmiGetNominalContinuousStates");
-    fmu->getStateValueReferences = (fGetStateValueReferences)getAdr(&s, fmu, "fmiGetStateValueReferences");
-    fmu->terminate               = (fTerminate)          getAdr(&s, fmu, "fmiTerminate");
-#endif 
-    fmu->getVersion              = (fGetVersion)         getAdr(&s, fmu, "fmiGetVersion");
-    fmu->setDebugLogging         = (fSetDebugLogging)    getAdr(&s, fmu, "fmiSetDebugLogging");
-    fmu->setReal                 = (fSetReal)            getAdr(&s, fmu, "fmiSetReal");
-    fmu->setInteger              = (fSetInteger)         getAdr(&s, fmu, "fmiSetInteger");
-    fmu->setBoolean              = (fSetBoolean)         getAdr(&s, fmu, "fmiSetBoolean");
-    fmu->setString               = (fSetString)          getAdr(&s, fmu, "fmiSetString");
-    fmu->getReal                 = (fGetReal)            getAdr(&s, fmu, "fmiGetReal");
-    fmu->getInteger              = (fGetInteger)         getAdr(&s, fmu, "fmiGetInteger");
-    fmu->getBoolean              = (fGetBoolean)         getAdr(&s, fmu, "fmiGetBoolean");
-    fmu->getString               = (fGetString)          getAdr(&s, fmu, "fmiGetString");
-    return s; 
-}
-
-static void printModelDescription(ModelDescription* md){
-    Element* e = (Element*)md;  
-    int i;
-    printf("%s\n", elmNames[e->type]);
-    for (i=0; i<e->n; i+=2) 
-        printf("  %s=%s\n", e->attributes[i], e->attributes[i+1]);
-#ifdef FMI_COSIMULATION   
-    if (!md->cosimulation) {
-        printf("error: No Implementation element found in model description. This FMU is not for Co-Simulation.\n");
-        exit(EXIT_FAILURE);
-    }
-    e = md->cosimulation->capabilities;
-    printf("%s\n", elmNames[e->type]);
-    for (i=0; i<e->n; i+=2) 
-        printf("  %s=%s\n", e->attributes[i], e->attributes[i+1]);
-#endif // FMI_COSIMULATION  
-}
-
-void loadFMU(const char* fmuFileName) {
-    char* fmuPath;
-    char* tmpPath;
-    char* xmlPath;
-    char* dllPath;
-    
-    // get absolute path to FMU, NULL if not found
-    fmuPath = getFmuPath(fmuFileName);
-    if (!fmuPath) exit(EXIT_FAILURE);
-
-    // unzip the FMU to the tmpPath directory
-    tmpPath = getTmpPath();
-    if (!unzip(fmuPath, tmpPath)) exit(EXIT_FAILURE);
-
-    // parse tmpPath\modelDescription.xml
-    xmlPath = calloc(sizeof(char), strlen(tmpPath) + strlen(XML_FILE) + 1);
-    sprintf(xmlPath, "%s%s", tmpPath, XML_FILE);
-
-    // parse tmpPath\modelDescription.xml
-    xmlPath = calloc(sizeof(char), strlen(tmpPath) + strlen(XML_FILE) + 1);
-    sprintf(xmlPath, "%s%s", tmpPath, XML_FILE);
-    // check FMI version of the FMU to match current simulator version
-    if (!checkFmiVersion(xmlPath)) {
-        free(xmlPath);
-        free(fmuPath);
-        free(tmpPath);
-        exit(EXIT_FAILURE);
-    }
-
-    fmu.modelDescription = parse(xmlPath);
-    free(xmlPath);
-    if (!fmu.modelDescription) exit(EXIT_FAILURE);
-    printModelDescription(fmu.modelDescription);
-
-    // load the FMU dll
-    dllPath = calloc(sizeof(char), strlen(tmpPath) + strlen(DLL_DIR)
-            + strlen( getModelIdentifier(fmu.modelDescription)) +  strlen(".dll") + 1);
-    sprintf(dllPath,"%s%s%s.dll", tmpPath, DLL_DIR, getModelIdentifier(fmu.modelDescription));
-    if (!loadDll(dllPath, &fmu)) {
-        free(dllPath);
-        free(fmuPath);
-        free(tmpPath);
-        exit(EXIT_FAILURE);
-    }
-    free(dllPath);
-    free(fmuPath);
-    free(tmpPath);
-}
-
-BOOL checkFmiVersion(const char *xmlPath) {
-    char *xmlFmiVersion = extractVersion(xmlPath);
-    if (xmlFmiVersion == NULL) {
-        printf("The FMI version of the FMU could not be read: %s", xmlPath);
-        return FALSE;
-    } else if (strcmp(xmlFmiVersion, fmiVersion) == 0) {
-        free(xmlFmiVersion);
-        return TRUE;
-    }
-    printf("The FMU to simulate is FMI %s standard, but expected a FMI %s standard FMU", fmiVersion, xmlFmiVersion);
-    free(xmlFmiVersion);
-    return FALSE;
-}
-
-void deleteUnzippedFiles() {
-    char *fmuTempPath = getTmpPath();
-    char *cmd = (char *)calloc(15 + strlen(fmuTempPath), sizeof(char));
-    sprintf(cmd, "rmdir /S /Q %s", fmuTempPath);
-    system(cmd);
-    free(cmd);
-    free(fmuTempPath);
-}
-
-static void doubleToCommaString(char* buffer, double r){
-    char* comma;
-    sprintf(buffer, "%.16g", r);
-    comma = strchr(buffer, '.');
-    if (comma) *comma = ',';
-}
-
-// output time and all non-alias variables in CSV format
-// if separator is ',', columns are separated by ',' and '.' is used for floating-point numbers.
-// otherwise, the given separator (e.g. ';' or '\t') is to separate columns, and ',' is used
-// as decimal dot in floating-point numbers.
-void outputRow(FMU *fmu, fmiComponent c, double time, FILE* file, char separator, fmiBoolean header) {
-    int k;
-    fmiReal r;
-    fmiInteger i;
-    fmiBoolean b;
-    fmiString s;
-    fmiValueReference vr;
-    ScalarVariable** vars = fmu->modelDescription->modelVariables;
-    char buffer[32];
-
-    // print first column
-    if (header) 
-        fprintf(file, "time");
-    else {
-        if (separator==',')
-            fprintf(file, "%.16g", time);
-        else {
-            // separator is e.g. ';' or '\t'
-            doubleToCommaString(buffer, time);
-            fprintf(file, "%s", buffer);
-        }
-    }
-
-    // print all other columns(void *)
-    for (k=0; vars[k]; k++) {
-        ScalarVariable* sv = vars[k];
-        if (getAlias(sv)!=enu_noAlias) continue;
-        if (header) {
-            // output names only
-            if (separator==',') {
-                // treat array element, e.g. print a[1, 2] as a[1.2]
-                const char* s = getName(sv);
-                fprintf(file, "%c", separator);
-                while (*s) {
-                   if (*s!=' ') fprintf(file, "%c", *s==',' ? '.' : *s);
-                   s++;
-                }
-             }
-            else
-                fprintf(file, "%c%s", separator, getName(sv));
-        }
-        else {
-            // output values
-            vr = getValueReference(sv);
-            switch (sv->typeSpec->type){
-                case elm_Real:
-                    fmu->getReal(c, &vr, 1, &r);
-                    if (separator==',') 
-                        fprintf(file, ",%.16g", r);
-                    else {
-                        // separator is e.g. ';' or '\t'
-                        doubleToCommaString(buffer, r);
-                        fprintf(file, "%c%s", separator, buffer);
-                    }
-                    break;
-                case elm_Integer:
-                case elm_Enumeration:
-                    fmu->getInteger(c, &vr, 1, &i);
-                    fprintf(file, "%c%d", separator, i);
-                    break;
-                case elm_Boolean:
-                    fmu->getBoolean(c, &vr, 1, &b);
-                    fprintf(file, "%c%d", separator, b);
-                    break;
-                case elm_String:
-                    fmu->getString(c, &vr, 1, &s);
-                    fprintf(file, "%c%s", separator, s);
-                    break;
-                default: 
-                    fprintf(file, "%cNoValueForType=%d", separator,sv->typeSpec->type);
-            }
-        }
-    } // for
-
-    // terminate this row
-    fprintf(file, "\n");
-}
-
-static const char* fmiStatusToString(fmiStatus status){
-    switch (status){
-        case fmiOK:      return "ok";
-        case fmiWarning: return "warning";
-        case fmiDiscard: return "discard";
-        case fmiError:   return "error";
-        case fmiFatal:   return "fatal";
-#ifdef FMI_COSIMULATION
-        case fmiPending: return "fmiPending";
-#endif
-        default:         return "?";
-    }
-}
-
-// search a fmu for the given variable
-// return NULL if not found or vr = fmiUndefinedValueReference
-static ScalarVariable* getSV(FMU* fmu, char type, fmiValueReference vr) {
-    int i;
-    Elm tp;
-    ScalarVariable** vars = fmu->modelDescription->modelVariables;
-    if (vr==fmiUndefinedValueReference) return NULL;
-    switch (type) {
-        case 'r': tp = elm_Real;    break;
-        case 'i': tp = elm_Integer; break;
-        case 'b': tp = elm_Boolean; break;
-        case 's': tp = elm_String;  break;
-        default:  tp = elm_BAD_DEFINED; break;
-    }
-    for (i=0; vars[i]; i++) {
-        ScalarVariable* sv = vars[i];
-        if (vr==getValueReference(sv) && tp==sv->typeSpec->type)
-            return sv;
-    }
-    return NULL;
-}
-
-// replace e.g. #r1365# by variable name and ## by # in message
-// copies the result to buffer
-static void replaceRefsInMessage(const char* msg, char* buffer, int nBuffer, FMU* fmu){
-    int i=0; // position in msg
-    int k=0; // position in buffer
-    int n;
-    char c = msg[i];
-    while (c!='\0' && k < nBuffer) {
-        if (c!='#') {
-            buffer[k++]=c;
-            i++;
-            c = msg[i];
-        } else if (strlen(msg + i + 1) >= 3
-               && (strncmp(msg + i + 1, "IND", 3) == 0 || strncmp(msg + i + 1, "INF", 3) == 0)) {
-            // 1.#IND, 1.#INF
-            buffer[k++]=c;
-            i++;
-            c = msg[i];
-        } else {
-            char* end = strchr(msg+i+1, '#');
-            if (!end) {
-                printf("unmatched '#' in '%s'\n", msg);
-                buffer[k++]='#';
-                break;
-            }
-            n = end - (msg+i);
-            if (n==1) {
-                // ## detected, output #
-                buffer[k++]='#';
-                i += 2;
-                c = msg[i];
-            }
-            else {
-                char type = msg[i+1]; // one of ribs
-                fmiValueReference vr;
-                int nvr = sscanf(msg+i+2, "%u", &vr);
-                if (nvr==1) {
-                    // vr of type detected, e.g. #r12#
-                    ScalarVariable* sv = getSV(fmu, type, vr);
-                    const char* name = sv ? getName(sv) : "?";
-                    sprintf(buffer+k, "%s", name);
-                    k += strlen(name);
-                    i += (n+1);
-                    c = msg[i]; 
-                }
-                else {
-                    // could not parse the number
-                    printf("illegal value reference at position %d in '%s'\n", i+2, msg);
-                    buffer[k++]='#';
-                    break;
-                }
-            }
-        }
-    } // while
-    buffer[k] = '\0';
-}
-
-#define MAX_MSG_SIZE 1000
-void fmuLogger(fmiComponent c, fmiString instanceName, fmiStatus status,
-               fmiString category, fmiString message, ...) {
-    char msg[MAX_MSG_SIZE];
-    char* copy;
-    va_list argp;
-
-    // replace C format strings
-    va_start(argp, message);
-    vsprintf(msg, message, argp);
-    va_end(argp);
-
-    // replace e.g. ## and #r12#  
-    copy = strdup(msg);
-    replaceRefsInMessage(copy, msg, MAX_MSG_SIZE, &fmu);
-    free(copy);
-    
-    // print the final message
-    if (!instanceName) instanceName = "?";
-    if (!category) category = "?";
-    printf("%s %s (%s): %s\n", fmiStatusToString(status), instanceName, category, msg);
-}
-
-int error(const char* message){
-    printf("%s\n", message);
-    return 0;
-}
-
-void parseArguments(int argc, char *argv[], const char** fmuFileName, double* tEnd, double* h, int* loggingOn, char* csv_separator) {
-    // parse command line arguments
-    if (argc>1) {
-        *fmuFileName = argv[1];
-    }
-    else {
-        printf("error: no fmu file\n");
-        printHelp(argv[0]);
-        exit(EXIT_FAILURE);
-    }
-    if (argc>2) {
-        if (sscanf(argv[2],"%lf", tEnd) != 1) {
-            printf("error: The given end time (%s) is not a number\n", argv[2]);
-            exit(EXIT_FAILURE);
-        }
-    }
-    if (argc>3) {
-        if (sscanf(argv[3],"%lf", h) != 1) {
-            printf("error: The given stepsize (%s) is not a number\n", argv[3]);
-            exit(EXIT_FAILURE);
-        }
-    }
-    if (argc>4) {
-        if (sscanf(argv[4],"%d", loggingOn) != 1 || *loggingOn<0 || *loggingOn>1) {
-            printf("error: The given logging flag (%s) is not boolean\n", argv[4]);
-            exit(EXIT_FAILURE);
-        }
-    }
-    if (argc>5) {
-        if (strlen(argv[5]) != 1) {
-            printf("error: The given CSV separator char (%s) is not valid\n", argv[5]);
-            exit(EXIT_FAILURE);
-        }
-        switch (argv[5][0]) {
-            case 'c': *csv_separator = ','; break; // comma
-            case 's': *csv_separator = ';'; break; // semicolon
-            default:  *csv_separator = argv[5][0]; break; // any other char
-        }
-    }
-    if (argc>6) {
-        printf("warning: Ignoring %d additional arguments: %s ...\n", argc-6, argv[6]);
-        printHelp(argv[0]);
-    }
-}
-
-void printHelp(const char* fmusim) {
-    printf("command syntax: %s <model.fmu> <tEnd> <h> <loggingOn> <csv separator>\n", fmusim);
-    printf("   <model.fmu> .... path to FMU, relative to current dir or absolute, required\n");
-    printf("   <tEnd> ......... end  time of simulation, optional, defaults to 1.0 sec\n");
-    printf("   <h> ............ step size of simulation, optional, defaults to 0.1 sec\n");
-    printf("   <loggingOn> .... 1 to activate logging,   optional, defaults to 0\n");
-    printf("   <csv separator>. separator in csv file,   optional, c for ',', s for';', defaults to c\n");
-}

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/sim_support.h

@@ -1,37 +0,0 @@
-/* -------------------------------------------------------------------------
- * sim_support.h
- * Functions used by the FMU simulation fmusim_me and fmusim_cs.
- * Copyright QTronic GmbH. All rights reserved.
- * -------------------------------------------------------------------------*/
-
-// Used 7z options, version 4.57:
-// -x   Extracts files from an archive with their full paths in the current dir, or in an output dir if specified
-// -aoa Overwrite All existing files without prompt
-// -o   Specifies a destination directory where files are to be extracted
-#define UNZIP_CMD "7z x -aoa -o"
-#define XML_FILE  "modelDescription.xml"
-#define RESULT_FILE "result.csv"
-#define BUFSIZE 4096
-#ifdef _WIN64
-#define DLL_DIR   "binaries\\win64\\"
-#else
-#define DLL_DIR   "binaries\\win32\\"
-#endif
-// return codes of the 7z command line tool
-#define SEVEN_ZIP_NO_ERROR 0 // success
-#define SEVEN_ZIP_WARNING 1  // e.g., one or more files were locked during zip
-#define SEVEN_ZIP_ERROR 2
-#define SEVEN_ZIP_COMMAND_LINE_ERROR 7
-#define SEVEN_ZIP_OUT_OF_MEMORY 8
-#define SEVEN_ZIP_STOPPED_BY_USER 255
-
-void fmuLogger(fmiComponent c, fmiString instanceName, fmiStatus status, fmiString category, fmiString message, ...);
-int unzip(const char *zipPath, const char *outPath);
-void parseArguments(int argc, char *argv[], const char** fmuFileName, double* tEnd, double* h, int* loggingOn, char* csv_separator);
-void loadFMU(const char* fmuFileName);
-BOOL checkFmiVersion(const char *xmlPath);
-void deleteUnzippedFiles();
-void outputRow(FMU *fmu, fmiComponent c, double time, FILE* file, char separator, fmiBoolean header);
-int error(const char* message);
-void printHelp(const char* fmusim);
-char *getTempFmuLocation(); // caller has to free the result

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/stack.c

@@ -1,89 +0,0 @@
-/*
- * Copyright QTronic GmbH. All rights reserved.
- */
-
-/* -------------------------------------------------------------------------
- * stack.c
- * A stack of pointers.
- * Author: Jakob Mauss
- * -------------------------------------------------------------------------*/
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "stack.h"
-
-Stack* stackNew(int initialSize, int inc){
-    Stack* s = (Stack*)malloc(sizeof(Stack));
-    s->stack = NULL;
-    s->stackSize = 0;
-    s->stackPos = -1;
-    s->initialSize = initialSize;
-    s->inc = inc;
-    return s;
-}
-
-int stackIsEmpty(Stack* s) {
-    return s->stackPos == -1;
-}
-
-// add an element to stack and grow stack if required
-// returns 1 to indicate success and 0 for error
-int stackPush(Stack* s, void* e) {
-    s->stackPos++;
-    if (s->stackPos==s->stackSize){
-        s->stackSize += (s->stack ? s->inc: s->initialSize);
-        s->stack = (void**) realloc(s->stack, s->stackSize * sizeof(void*));
-        if (!s->stack) return 0; // error;
-    }
-    s->stack[s->stackPos] = e;
-    return 1; // success
-}
-
-// return top element (possibly NULL), if stack not empty
-// runtime error if stack is empty
-void* stackPeek(Stack* s){
-    assert(!stackIsEmpty(s));
-    return s->stack[s->stackPos];
-}
-
-// remove top element (possibly NULL) from stack and return it
-// runtime error if stack is empty
-void* stackPop(Stack* s){
-    assert(!stackIsEmpty(s));
-    return s->stack[s->stackPos--];
-}
-
-// return the last n elements as null terminated array,
-// or NULL if memory allocation fails
-void** stackLastPopedAsArray0(Stack* s, int n){
-    int i;
-    void** array = (void**)malloc((n + 1)*sizeof(void*));
-    if (! array) return NULL; // failure
-    for (i=0; i<n; i++) {
-        array[i] = s->stack[i+ s->stackPos + 1];
-    }
-    array[n]=NULL; // terminating NULL
-    return array;
-}
-
-// return stack as possibly empty array, or NULL if memory allocation fails
-// On successful return, the stack is empty.
-void** stackPopAllAsArray(Stack* s, int *size) {
-    int i;
-    void** array = (void**)malloc((s->stackPos + 1)*sizeof(void*));
-    if (! array) return NULL; // failure
-    *size = s->stackPos + 1;
-    for (i=0; i<*size; i++)
-        array[i] = s->stack[i];
-    s->stackPos = -1;
-    return array;
-}
-
-// release the given stack
-void stackFree(Stack* s){
-    if (s->stack) free(s->stack);
-    free(s);
-}
-
-

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/stack.h

@@ -1,37 +0,0 @@
-/*
- * Copyright QTronic GmbH. All rights reserved.
- */
-
-/* -------------------------------------------------------------------------
- * stack.c
- * A stack of pointers.
- * Author: Jakob Mauss, January 2010.
- * -------------------------------------------------------------------------*/
-
-#ifndef STACK_H
-#define STACK_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
-    void** stack;
-    int stackSize;    // allocated size of stack
-    int stackPos;     // array index of top element, -1 if stack is empty.
-    int initialSize;  // how many element to allocate initially
-    int inc;          // how many elements to allocate when stack gets full
-} Stack;
-
-Stack* stackNew(int initialSize, int inc);
-int stackIsEmpty(Stack* s);
-int stackPush(Stack* s, void* e);
-void* stackPeek(Stack* s);
-void* stackPop(Stack* s);
-void** stackPopAllAsArray(Stack* s, int *size);
-void** stackLastPopedAsArray0(Stack* s, int n);
-void stackFree(Stack* s);
-
-#ifdef __cplusplus
-} // closing brace for extern "C"
-#endif
-#endif // STACK_H

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/xmlVersionParser.c

@@ -1,82 +0,0 @@
-/*
- * Copyright QTronic GmbH. All rights reserved.
- */
-
-/* ---------------------------------------------------------------------------*
- * xmlVersionParser.c
- *
- * Author: Adrian Tirea
- * ---------------------------------------------------------------------------*/
-
-#ifdef STANDALONE_XML_PARSER
-#define logThis(n, ...) printf(__VA_ARGS__); printf("\n")
-#define checkStrdup(str) strdup(str)
-#include <windows.h>
-#else
-#include "GlobalIncludes.h"
-#include "logging.h"  // logThis
-#include "minutil.h"  // checkStrdup
-#endif  // STANDALONE_XML_PARSER
-
-#include <libxml/xmlreader.h>
-#include "xmlVersionParser.h"
-
-// Element and attribute that identify the fmiVersion.
-#define ELM_fmiModelDescription_NAME "fmiModelDescription"
-#define ATT_fmiVersion_NAME "fmiVersion"
-
-static BOOL readNextInXml(xmlTextReaderPtr xmlReader) {
-    int ret;
-    do {
-        ret = xmlTextReaderRead(xmlReader);
-    } while (ret == 1 && xmlTextReaderNodeType(xmlReader) == XML_READER_TYPE_COMMENT);
-
-    if (ret != 1) {
-        return FALSE;
-    }
-    return TRUE;
-}
-
-// The receiver must free the return.
-static char *extractFmiVersionAttribute(xmlTextReaderPtr xmlReader) {
-    char *value = (char *)xmlTextReaderGetAttribute(xmlReader, ATT_fmiVersion_NAME);
-    char *result = value ? (char *)checkStrdup(value) : NULL;
-    xmlFree(value);
-    return result;
-}
-
-// The receiver must free the return.
-static char *streamFile(const char *xmlPath) {
-    xmlTextReaderPtr xmlReader;
-    char *fmiVersion = NULL;
-    xmlReader = xmlReaderForFile(xmlPath, NULL, 0);
-    if (xmlReader != NULL) {
-        if (readNextInXml(xmlReader)) {
-            // I expect that first element is fmiModelDescription.
-            if (0 != strcmp((char *)xmlTextReaderConstLocalName(xmlReader), ELM_fmiModelDescription_NAME)) {
-                logThis(ERROR_ERROR, "Expected '%s' element. Found instead: '%s'",
-                    ELM_fmiModelDescription_NAME, xmlTextReaderConstLocalName(xmlReader));
-            } else {
-                fmiVersion = extractFmiVersionAttribute(xmlReader);
-            }
-        } else {
-            logThis(ERROR_ERROR, "Syntax error parsing xml file '%s'", xmlPath);
-        }
-        xmlFreeTextReader(xmlReader);
-    } else {
-        logThis(ERROR_ERROR, "Cannot open file '%s'", xmlPath);
-    }
-    return fmiVersion;
-}
-
-// Returns NULL to indicate failure
-// Otherwise, return the version of this FMU.
-// The receiver must free the returned string.
-char *extractVersion(const char *xmlDescriptionPath) {
-    char *fmiVersion;
-
-    xmlInitParser();
-    fmiVersion = streamFile(xmlDescriptionPath);
-    xmlCleanupParser();
-    return fmiVersion;
-}

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/xmlVersionParser.h

@@ -1,27 +0,0 @@
-/*
- * Copyright QTronic GmbH. All rights reserved.
- */
-
-/* ---------------------------------------------------------------------------*
- * xmlVersionParser.h
- * Parse a xml model description of a FMI 1.0 or FMI 2.0 model to extract its
- * fmi version.
- *
- * Author: Adrian Tirea
- * ---------------------------------------------------------------------------*/
-
-#ifndef xmlVersionParser_h
-#define xmlVersionParser_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#pragma comment(lib, "libxml2.lib")
-#pragma comment(lib, "wsock32.lib")
-
-char *extractVersion(const char *xmlDescriptionPath);
-
-#ifdef __cplusplus
-} // closing brace for extern "C"
-#endif
-#endif // xmlVersionParser_h

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/xml_parser.c

@@ -1,936 +0,0 @@
-/*
- * Copyright QTronic GmbH. All rights reserved.
- */
-
-/* -------------------------------------------------------------------------
- * xml_Parser.c
- * A parser for file modelVariables.xml of an FMU.
- * The parser creates an AST (abstract syntax tree) for a given XML file.
- * The root node of the AST is of type ModelDescription.
- * Validation already performed by this parser
- * - check for match of open/close elements (performed by Expat)
- * - check element, attribute and enum value names, all case sensitive
- * - check for each element that is has the expected parent element
- * - check for correct sequence of elements
- * - check for each attribute value that it is of the expected type
- * - check that all declaredType values reference an existing Type
- * Validation to be performed by this parser
- * - check that required attributes are present
- * - check that dependencies are only declared for outputs and
- *   refer only to inputs
- * Author: Jakob Mauss, January 2010.
- * -------------------------------------------------------------------------*/
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef STANDALONE_XML_PARSER
-#define logThis(n, ...) printf(__VA_ARGS__);printf("\n")
-#else
-#include "GlobalIncludes.h"
-#include "logging.h" // logThis
-#endif // STANDALONE_XML_PARSER
-
-#include "xml_parser.h"
-
-const char *elmNames[SIZEOF_ELM] = {
-    "fmiModelDescription","UnitDefinitions","BaseUnit","DisplayUnitDefinition","TypeDefinitions",
-    "Type","RealType","IntegerType","BooleanType","StringType","EnumerationType","Item",
-    "DefaultExperiment","VendorAnnotations","Tool","Annotation", "ModelVariables","ScalarVariable",
-    "DirectDependency", "Name", "Real","Integer","Boolean","String","Enumeration",
-    "Implementation","CoSimulation_StandAlone","CoSimulation_Tool","Model","File","Capabilities"
-};
-
-const char *attNames[SIZEOF_ATT] = {
-    "fmiVersion","displayUnit","gain","offset","unit","name","description","quantity", "relativeQuantity",
-    "min","max","nominal","declaredType","start","fixed","startTime","stopTime","tolerance","value",
-    "valueReference","variability","causality","alias", "modelName","modelIdentifier","guid","author",
-    "version","generationTool","generationDateAndTime","variableNamingConvention","numberOfContinuousStates",
-    "numberOfEventIndicators","input",
-    "canHandleVariableCommunicationStepSize","canHandleEvents","canRejectSteps","canInterpolateInputs",
-    "maxOutputDerivativeOrder","canRunAsynchronuously","canSignalEvents","canBeInstantiatedOnlyOncePerProcess",
-    "canNotUseMemoryManagementFunctions","file","entryPoint","manualStart","type"
-};
-
-const char *enuNames[SIZEOF_ENU] = {
-    "flat","structured","constant","parameter","discrete","continuous",
-    "input","output", "internal","none","noAlias","alias","negatedAlias"
-};
-
-#define XMLBUFSIZE 1024
-char text[XMLBUFSIZE];       // XML file is parsed in chunks of length XMLBUFZIZE
-XML_Parser parser = NULL;    // non-NULL during parsing
-Stack* stack = NULL;         // the parser stack
-char* data = NULL;           // buffer that holds element content, see handleData
-int skipData=0;              // 1 to ignore element content, 0 when recording content
-
-// -------------------------------------------------------------------------
-// Low-level functions for inspecting the model description 
-
-const char* getString(void* element, Att a){
-    Element* e = (Element*)element;
-    const char** attr = e->attributes;
-    int i;
-    for (i=0; i<e->n; i+=2)
-        if (attr[i]==attNames[a]) return attr[i+1];
-    return NULL;
-}
-
-double getDouble(void* element, Att a, ValueStatus* vs){
-    double d = 0;
-    const char* value = getString(element, a);
-    if (!value) { *vs=valueMissing; return d; }
-    *vs = (1==sscanf(value, "%lf", &d)) ? valueDefined : valueIllegal;
-    return d;
-}
-
-// getInt() is also used to retrieve Enumeration values from XML,
-// e.g. the start value for a variable of user-defined enumeration type.
-int getInt(void* element, Att a, ValueStatus* vs){
-    int n = 0;
-    const char* value = getString(element, a);
-    if (!value) { *vs=valueMissing; return n; }
-    *vs = (1==sscanf(value, "%d", &n)) ? valueDefined : valueIllegal;
-    return n;
-}
-
-unsigned int getUInt(void* element, Att a, ValueStatus* vs){
-    unsigned int u = -1;
-    const char* value = getString(element, a);
-    if (!value) { *vs=valueMissing; return u; }
-    *vs = (1==sscanf(value, "%u", &u)) ? valueDefined : valueIllegal;
-    return u;
-}
-
-char getBoolean(void* element, Att a, ValueStatus* vs){
-    const char* value = getString(element, a);
-    if (!value) { *vs=valueMissing; return 0; };
-    *vs = valueDefined;
-    if (!strcmp(value, "true")) return 1;
-    if (!strcmp(value, "false")) return 0;
-    *vs = valueIllegal;
-    return 0;
-}
-
-static Enu checkEnumValue(const char* enu);
-
-// Retrieve the value of the given built-in enum attribute.
-// If the value is missing, this is marked in the ValueStatus
-// and the corresponding default is returned.
-// Returns enu_BAD_DEFINED or a globally unique id for the value such that
-// enuNames[id] is the string representation of the enum value.
-Enu getEnumValue(void* element, Att a, ValueStatus* vs) {
-    const char* value = getString(element, a);
-    Enu id;
-    *vs = valueDefined;
-    if (!value) {
-        *vs = valueMissing;
-        switch (a) {
-            case att_variableNamingConvention: return enu_flat;
-            case att_variability: return enu_continuous;
-            case att_causality: return enu_internal;
-            case att_alias: return enu_noAlias;
-            default: return enu_BAD_DEFINED;
-        }
-    }
-    id = checkEnumValue(value);
-    if (id == enu_BAD_DEFINED) *vs = valueIllegal;
-    return id;
-}
-
-// -------------------------------------------------------------------------
-// Convenience methods for accessing the model description. 
-// Use is only safe after the ast has been successfully validated.
-
-const char* getModelIdentifier(ModelDescription* md) {
-    const char* modelId = getString(md, att_modelIdentifier);
-    assert(modelId); // this is a required attribute
-    return modelId;
-}
-
-int getNumberOfStates(ModelDescription* md) {
-    ValueStatus vs;
-    int n = getUInt(md, att_numberOfContinuousStates, &vs);
-    assert(vs==valueDefined); // this is a required attribute
-    return n;
-}
-
-int getNumberOfEventIndicators(ModelDescription* md) {
-    ValueStatus vs;
-    int n = getInt(md, att_numberOfEventIndicators, &vs);
-    assert(vs==valueDefined); // this is a required attribute
-    return n;
-}
-
-// name is a required attribute of ScalarVariable, Type, Item, Annotation, and Tool
-const char* getName(void* element) { 
-    const char* name = getString(element, att_name);
-    assert(name); // this is a required attribute
-    return name;
-}
-
-// returns one of: input, output, internal, none
-// if value is missing, the default internal is returned
-Enu getCausality(void* scalarVariable) {
-    ValueStatus vs;
-    return getEnumValue(scalarVariable, att_causality, &vs);
-}
-
-// returns one of constant, parameter, discrete, continuous
-// if value is missing, the default continuous is returned
-Enu getVariability(void* scalarVariable) {
-    ValueStatus vs;
-    return getEnumValue(scalarVariable, att_variability, &vs);
-}
-
-// returns one of noAlias, alias, negatedAlias
-// if value is missing, the default noAlias is returned
-Enu getAlias(void* scalarVariable) {
-    ValueStatus vs;
-    return getEnumValue(scalarVariable, att_alias, &vs);
-}
-
-// the vr is unique only for one of the 4 base data types r,i,b,s and
-// may also be fmiUndefinedValueReference = 4294967295 = 0xFFFFFFFF
-// here, i means integer or enumeration
-fmiValueReference getValueReference(void* scalarVariable) {
-    ValueStatus vs;
-    fmiValueReference vr = getUInt(scalarVariable, att_valueReference, &vs);
-    assert(((Element*)scalarVariable)->type == elm_ScalarVariable);
-    assert(vs==valueDefined); // this is a required attribute
-    return vr;
-}
-
-// the name is unique within a fmu
-ScalarVariable* getVariableByName(ModelDescription* md, const char* name) {
-    int i;
-    if (md->modelVariables) {
-        for (i=0; md->modelVariables[i]; i++){
-            ScalarVariable* sv = (ScalarVariable*)md->modelVariables[i];
-            if (!strcmp(getName(sv), name)) return sv;
-        }
-    }
-    return NULL;
-}
-
-// Enumeration and Integer have the same base type while
-// Real, String, Boolean define own base types.
-int sameBaseType(Elm t1, Elm t2){
-    return t1==t2 ||
-           t1==elm_Enumeration && t2==elm_Integer ||
-           t2==elm_Enumeration && t1==elm_Integer;
-}
-
-// returns NULL if variable not found or vr==fmiUndefinedValueReference
-// problem: vr/type in not a unique key, may return alias
-ScalarVariable* getVariable(ModelDescription* md, fmiValueReference vr, Elm type){
-    int i;
-    if (md->modelVariables && vr!=fmiUndefinedValueReference)
-    for (i=0; md->modelVariables[i]; i++){
-        ScalarVariable* sv = (ScalarVariable*)md->modelVariables[i];
-        if (sameBaseType(type, sv->typeSpec->type) && getValueReference(sv) == vr)
-            return sv;
-    }
-    return NULL;
-}
-
-// returns NULL if variable not found or vr==fmiUndefinedValueReference
-// problem: vr/type in not a unique key, return just the non alias variable
-ScalarVariable* getNonAliasVariable(ModelDescription* md, fmiValueReference vr, Elm type){
-    int i;
-    if (md->modelVariables && vr!=fmiUndefinedValueReference)
-    for (i=0; md->modelVariables[i]; i++){
-        ScalarVariable* sv = (ScalarVariable*)md->modelVariables[i];
-        if (sameBaseType(type, sv->typeSpec->type) && getValueReference(sv) == vr && getAlias(sv) == enu_noAlias)
-            return sv;
-    }
-    return NULL;
-}
-
-Type* getDeclaredType(ModelDescription* md, const char* declaredType){
-    int i;
-    if (declaredType && md->typeDefinitions)
-    for (i=0; md->typeDefinitions[i]; i++){
-        Type* tp = (Type*)md->typeDefinitions[i];
-        if (!strcmp(declaredType, getName(tp))) return tp;
-    }
-    return NULL;
-}
-
-// Get attribute value from variable or from declared type, or NULL.
-const char* getString2(ModelDescription* md, void* tp, Att a) {
-    Type* type;
-    const char* value = getString(tp, a);
-    if (value) return value; // found
-    // search declared type, if any
-    type = getDeclaredType(md, getString(tp, att_declaredType));
-    return type ? getString(type->typeSpec, a) : NULL;
-}
-
-// Get description from variable or from declared type, or NULL.
-const char * getDescription(ModelDescription* md, ScalarVariable* sv){
-    const char* value = getString(sv, att_description);
-    Type* type;
-    if (value) return value; // found
-    // search declared type, if any
-    type = getDeclaredType(md, getString(sv->typeSpec, att_declaredType));
-    return type ? getString(type, att_description) : NULL;
-}
-
-// Get attribute value from scalar variable given by vr and type,
-// incl. default value provided by declared type, if any.
-const char *getVariableAttributeString(ModelDescription* md, 
-        fmiValueReference vr, Elm type, Att a) {
-    const char* value;
-    Type* tp;
-    ScalarVariable* sv = getVariable(md, vr, type);
-    if (!sv) return NULL;
-    value = getString(sv->typeSpec, a);
-    if (value) return value; // found
-    // search declared type, if any
-    tp = getDeclaredType(md, getString(sv->typeSpec, att_declaredType));
-    return tp ? getString(tp->typeSpec, a) : NULL;
-}
-
-// Get attribute value from scalar variable given by vr and type,
-// incl. default value provided by declared type, if any.
-double getVariableAttributeDouble(ModelDescription* md, 
-        fmiValueReference vr, Elm type, Att a, ValueStatus* vs){
-    double d = 0;
-    const char* value = getVariableAttributeString(md, vr, type, a);
-    if (!value) { *vs = valueMissing; return d; }
-    *vs = (1==sscanf(value, "%lf", &d)) ? valueDefined : valueIllegal;
-    return d;
-}
-
-// Get nominal value from real variable or its declared type.
-// Return 1, if no nominal value is defined.
-double getNominal(ModelDescription* md, fmiValueReference vr){
-    ValueStatus vs;
-    double nominal = getVariableAttributeDouble(md, vr, elm_Real, att_nominal, &vs);
-    return vs==valueDefined ? nominal : 1.0;
-}
-
-// -------------------------------------------------------------------------
-// Various checks that log an error and stop the parser 
-
-// Returns 0 to indicate error
-static int checkPointer(const void* ptr){
-    if (! ptr) {
-        logThis(ERROR_FATAL, "Out of memory");
-        if (parser) XML_StopParser(parser, XML_FALSE);
-        return 0; // error
-    }
-    return 1; // success
-}
-
-static int checkName(const char* name, const char* kind, const char* array[], int n){
-    int i;
-    for (i=0; i<n; i++) {
-        if (!strcmp(name, array[i])) return i;
-    }
-    logThis(ERROR_FATAL, "Illegal %s %s", kind, name);
-    XML_StopParser(parser, XML_FALSE);
-    return -1;
-}
-
-// Returns elm_BAD_DEFINED to indicate error
-static Elm checkElement(const char* elm){
-    return (Elm)checkName(elm, "element", elmNames, SIZEOF_ELM);
-}
-
-// Returns att_BAD_DEFINED to indicate error
-static Att checkAttribute(const char* att){
-    return (Att)checkName(att, "attribute", attNames, SIZEOF_ATT);
-}
-
-// Returns enu_BAD_DEFINED to indicate error
-static Enu checkEnumValue(const char* enu){
-    return (Enu)checkName(enu, "enum value", enuNames, SIZEOF_ENU);
-}
-
-static void logFatalTypeError(const char* expected, Elm found) {
-    logThis(ERROR_FATAL, "Wrong element type, expected %s, found %s",
-            expected, elmNames[found]);
-    XML_StopParser(parser, XML_FALSE);
-}
-
-// Returns 0 to indicate error
-// Verify that Element elm is of the given type
-static int checkElementType(void* element, Elm e) {
-    Element* elm = (Element* )element;
-    if (elm->type == e) return 1; // success
-    logFatalTypeError(elmNames[e], elm->type);
-    return 0; // error
-}
-
-// Returns 0 to indicate error
-// Verify that the next stack element exists and is of the given type
-// If e==elm_BAD_DEFINED, the type check is omitted
-static int checkPeek(Elm e) {
-    if (stackIsEmpty(stack)) {
-        logThis(ERROR_FATAL, "Illegal document structure, expected %s",
-            e==elm_BAD_DEFINED ? "xml element" : elmNames[e]);
-        XML_StopParser(parser, XML_FALSE);
-        return 0; // error
-    }
-    return e==elm_BAD_DEFINED ? 1 : checkElementType(stackPeek(stack), e);
-}
-
-// Returns NULL to indicate error
-// Get the next stack element, it is of the given type.
-// If e==elm_BAD_DEFINED, the type check is omitted
-static void* checkPop(Elm e){
-    return checkPeek(e) ? stackPop(stack) : NULL;
-}
-
-// -------------------------------------------------------------------------
-// Helper
-
-AstNodeType getAstNodeType(Elm e){
-    switch (e) {
-    case elm_fmiModelDescription:
-        return astModelDescription;
-    case elm_Type:
-        return astType;
-    case elm_ScalarVariable:
-        return astScalarVariable;
-    case elm_CoSimulation_StandAlone:
-    case elm_CoSimulation_Tool:
-        return astCoSimulation;
-    case elm_BaseUnit:
-    case elm_EnumerationType:
-    case elm_Tool:
-    case elm_UnitDefinitions:
-    case elm_TypeDefinitions:
-    case elm_VendorAnnotations:
-    case elm_ModelVariables:
-    case elm_DirectDependency:
-    case elm_Model:
-        return astListElement;
-    default:
-        return astElement;
-    }
-}
-
-// Returns 0 to indicate error
-// Copies the attr array and all values.
-// Replaces all attribute names by constant literal strings.
-// Converts the null-terminated array into an array of known size n.
-int addAttributes(Element* el, const char** attr) {
-    int n;
-    Att a;
-    const char** att = NULL;
-    for (n=0; attr[n]; n+=2);
-    if (n>0) {
-        att = (const char **)calloc(n, sizeof(char*));
-        if (!checkPointer(att)) return 0;
-    }
-    for (n=0; attr[n]; n+=2) {
-        char* value = strdup(attr[n+1]);
-        if (!checkPointer(value)) {
-            free((void *)att);
-            return 0;
-        }
-        a = checkAttribute(attr[n]);
-        if (a == att_BAD_DEFINED) {
-            free(value);
-            free((void *)att);
-            return 0;  // illegal attribute error
-        }
-        att[n  ] = attNames[a]; // no heap memory
-        att[n+1] = value;       // heap memory
-    }
-    el->attributes = att; // NULL if n=0
-    el->n = n;
-    return 1; // success
-}
-
-// Returns NULL to indicate error
-Element* newElement(Elm type, int size, const char** attr) {
-    Element* e = (Element*)calloc(1, size);
-    if (!checkPointer(e)) return NULL;
-    e->type = type;
-    e->attributes = NULL;
-    e->n=0;
-    if (!addAttributes(e, attr)) {
-        free(e);
-        return NULL;
-    }
-    return e;
-}
-
-// -------------------------------------------------------------------------
-// callback functions called by the XML parser 
-
-// Create and push a new element node
-static void XMLCALL startElement(void *context, const char *elm, const char **attr) {
-    Elm el;
-    void* e;
-    int size;
-    //logThis(ERROR_INFO, "start %s", elm);
-    el = checkElement(elm);
-    if (el==elm_BAD_DEFINED) return; // error
-    skipData = (el != elm_Name); // skip element content for all elements but Name
-    switch(getAstNodeType(el)){
-        case astElement:          size = sizeof(Element); break;
-        case astListElement:      size = sizeof(ListElement); break;
-        case astType:             size = sizeof(Type); break;
-        case astScalarVariable:   size = sizeof(ScalarVariable); break;
-        case astCoSimulation:     size = sizeof(CoSimulation); break;
-        case astModelDescription: size = sizeof(ModelDescription); break;
-        default: assert(0);
-    }
-    e = newElement(el, size, attr);
-    if (checkPointer(e)) stackPush(stack, e);
-}
-
-// Pop all elements of the given type from stack and
-// add it to the ListElement that follows.
-// The ListElement remains on the stack.
-static void popList(Elm e) {
-    int n = 0;
-    Element** array;
-    Element* elm = (Element *)stackPop(stack);
-    while (elm->type == e) {
-        elm = (Element *)stackPop(stack);
-        n++;
-    }
-    stackPush(stack, elm); // push ListElement back to stack
-    array = (Element**)stackLastPopedAsArray0(stack, n); // NULL terminated list
-    if (getAstNodeType(elm->type)!=astListElement) {
-        free(array);
-        return; // failure
-    }
-    ((ListElement*)elm)->list = array;
-    return; // success only if list!=NULL
-}
-
-// Pop the children from the stack and
-// check for correct type and sequence of children
-static void XMLCALL endElement(void *context, const char *elm) {
-    Elm el;
-    //logThis(ERROR_INFO, "  end %s", elm);
-    el = checkElement(elm);
-    switch(el) {
-        case elm_fmiModelDescription:
-            {
-                 ModelDescription* md;
-                 ListElement** ud = NULL;     // NULL or list of BaseUnits
-                 Type**        td = NULL;     // NULL or list of Types
-                 Element*      de = NULL;     // NULL or DefaultExperiment
-                 ListElement** va = NULL;     // NULL or list of Tools
-                 ScalarVariable** mv = NULL;  // NULL or list of ScalarVariable
-                 CoSimulation *cs = NULL;     // NULL or CoSimulation
-                 ListElement* child;
-
-                 child = (ListElement *)checkPop(elm_BAD_DEFINED);
-                 if (child->type == elm_CoSimulation_StandAlone || child->type == elm_CoSimulation_Tool) {
-                     cs = (CoSimulation*)child;
-                     child = (ListElement *)checkPop(elm_BAD_DEFINED);
-                     if (!child) return;
-                 }
-                 if (child->type == elm_ModelVariables){
-                     mv = (ScalarVariable**)child->list;
-                     free(child);
-                     child = (ListElement *)checkPop(elm_BAD_DEFINED);
-                     if (!child) return;
-                 }
-                 if (child->type == elm_VendorAnnotations){
-                     va = (ListElement**)child->list;
-                     free(child);
-                     child = (ListElement *)checkPop(elm_BAD_DEFINED);
-                     if (!child) return;
-                 }
-                 if (child->type == elm_DefaultExperiment){
-                     de = (Element*)child;
-                     child = (ListElement *)checkPop(elm_BAD_DEFINED);
-                     if (!child) return;
-                 }
-                 if (child->type == elm_TypeDefinitions){
-                     td = (Type**)child->list;
-                     free(child);
-                     child = (ListElement *)checkPop(elm_BAD_DEFINED);
-                     if (!child) return;
-                 }
-                 if (child->type == elm_UnitDefinitions){
-                     ud = (ListElement**)child->list;
-                     free(child);
-                     child = (ListElement *)checkPop(elm_BAD_DEFINED);
-                     if (!child) return;
-                 }
-                 // work around bug of SimulationX 3.x which places Implementation at wrong location
-                 if (!cs && (child->type == elm_CoSimulation_StandAlone || child->type == elm_CoSimulation_Tool)) {
-                     cs = (CoSimulation*)child;
-                     child = (ListElement *)checkPop(elm_BAD_DEFINED);
-                     if (!child) return;
-                 }
-
-                 if (!checkElementType(child, elm_fmiModelDescription)) return;
-                 md = (ModelDescription*)child;
-                 md->modelVariables = mv;
-                 md->vendorAnnotations = va;
-                 md->defaultExperiment = de;
-                 md->typeDefinitions = td;
-                 md->unitDefinitions = ud;
-                 md->cosimulation = cs;
-                 stackPush(stack, md);
-                 break;
-            }
-        case elm_Implementation:
-            {
-                 // replace Implementation element
-                 void* cs = checkPop(elm_BAD_DEFINED);
-                 void* im = checkPop(elm_Implementation);
-                 if (!cs || !im) return;
-                 stackPush(stack, cs);
-                 //printf("im=%x att=%x\n",im,((Element*)im)->attributes);
-                 free(im);
-                 el = ((Element*)cs)->type;
-                 break;
-            }
-        case elm_CoSimulation_StandAlone:
-            {
-                 Element* ca = (Element *)checkPop(elm_Capabilities);
-                 CoSimulation* cs = (CoSimulation *)checkPop(elm_CoSimulation_StandAlone);
-                 if (!ca || !cs) return;
-                 cs->capabilities = ca;
-                 stackPush(stack, cs);
-                 break;
-            }
-        case elm_CoSimulation_Tool:
-            {
-                 ListElement* mo = (ListElement *)checkPop(elm_Model);
-                 Element* ca = (Element *)checkPop(elm_Capabilities);
-                 CoSimulation* cs = (CoSimulation *)checkPop(elm_CoSimulation_Tool);
-                 if (!ca || !mo || !cs) return;
-                 cs->capabilities = ca;
-                 cs->model = mo;
-                 stackPush(stack, cs);
-                 break;
-            }
-        case elm_Type:
-            {
-                Type* tp;
-                Element* ts = (Element *)checkPop(elm_BAD_DEFINED);
-                if (!ts) return;
-                if (!checkPeek(elm_Type)) return;
-                tp = (Type*)stackPeek(stack);
-                switch (ts->type) {
-                    case elm_RealType:
-                    case elm_IntegerType:
-                    case elm_BooleanType:
-                    case elm_StringType:
-                    case elm_EnumerationType:
-                        break;
-                    default:
-                         logFatalTypeError("RealType or similar", ts->type);
-                         return;
-                }
-                tp->typeSpec = ts;
-                break;
-            }
-        case elm_ScalarVariable:
-            {
-                ScalarVariable* sv;
-                Element** list = NULL;
-                Element* child = (Element *)checkPop(elm_BAD_DEFINED);
-                if (!child) return;
-                if (child->type==elm_DirectDependency){
-                    list = ((ListElement*)child)->list;
-                    free(child);
-                    child = (Element *)checkPop(elm_BAD_DEFINED);
-                    if (!child) return;
-                }
-                if (!checkPeek(elm_ScalarVariable)) return;
-                sv = (ScalarVariable*)stackPeek(stack);
-                switch (child->type) {
-                    case elm_Real:
-                    case elm_Integer:
-                    case elm_Boolean:
-                    case elm_String:
-                    case elm_Enumeration:
-                        break;
-                    default:
-                         logFatalTypeError("Real or similar", child->type);
-                         return;
-                }
-                sv->directDependencies = list;
-                sv->typeSpec = child;
-                break;
-            }
-        case elm_ModelVariables:    popList(elm_ScalarVariable); break;
-        case elm_VendorAnnotations: popList(elm_Tool);break;
-        case elm_Tool:              popList(elm_Annotation); break;
-        case elm_TypeDefinitions:   popList(elm_Type); break;
-        case elm_EnumerationType:   popList(elm_Item); break;
-        case elm_UnitDefinitions:   popList(elm_BaseUnit); break;
-        case elm_BaseUnit:          popList(elm_DisplayUnitDefinition); break;
-        case elm_DirectDependency:  popList(elm_Name); break;
-        case elm_Model:             popList(elm_File); break;
-        case elm_Name:
-            {
-                 // Exception: the name value is represented as element content.
-                 // All other values of the XML file are represented using attributes.
-                 Element* name = (Element *)checkPop(elm_Name);
-                 if (!name) return;
-                 name->n = 2;
-                 name->attributes = (const char **)malloc(2*sizeof(char*));
-                 name->attributes[0] = attNames[att_input];
-                 name->attributes[1] = data;
-                 data = NULL;
-                 skipData = 1; // stop recording element content
-                 stackPush(stack, name);
-                 break;
-            }
-        case elm_BAD_DEFINED: return; // illegal element error
-        default: // must be a leaf Element
-                 assert(getAstNodeType(el)==astElement);
-                 break;
-    }
-    // All children of el removed from the stack.
-    // The top element must be of type el now.
-    checkPeek(el);
-}
-
-// Called to handle element data, e.g. "xy" in <Name>xy</Name>
-// Can be called many times, e.g. with "x" and then with "y" in the example above.
-// Feature in expat:
-// For some reason, if the element data is the empty string (Eg. <a></a>)
-// instead of an empty string with len == 0 we get "\n". The workaround is
-// to replace this with the empty string whenever we encounter "\n".
-void XMLCALL handleData(void *context, const XML_Char *s, int len) {
-    int n;
-    if (skipData) return;
-    if (!data) {
-        // start a new data string
-        if (len == 1 && s[0] == '\n') {
-            data = strdup("");
-        } else {
-            data = (char *)malloc(len + 1);
-            strncpy(data, s, len);
-            data[len] = '\0';
-        }
-    }
-    else {
-        // continue existing string
-        n = strlen(data) + len;
-        data = (char *)realloc(data, n+1);
-        strncat(data, s, len);
-        data[n] = '\0';
-    }
-    return;
-}
-
-
-#ifdef STANDALONE_XML_PARSER
-// -------------------------------------------------------------------------
-// printing
- 
-static void printList(int indent, void** list);
-
-void printElement(int indent, void* element){
-    int i;
-    Element* e = (Element*)element;
-    if (!e) return;
-    // print attributes
-    for (i=0; i<indent; i++) printf(" ");
-    printf("%s", elmNames[e->type]);
-    for (i=0; i<e->n; i+=2)
-        printf(" %s=%s", e->attributes[i], e->attributes[i+1]);
-    printf("\n");
-    // print child nodes
-    indent += 2;
-    switch (getAstNodeType(e->type)) {
-        case astElement:
-            // we already printed the attributes
-            break;
-        case astListElement:
-            printList(indent, (void **)((ListElement*)e)->list);
-            break;
-        case astScalarVariable:
-            printElement(indent, ((Type*)e)->typeSpec);
-            printList(indent, (void **)((ScalarVariable*)e)->directDependencies);
-            break;
-        case astType:
-            printElement(indent, ((Type*)e)->typeSpec);
-            break;
-        case astCoSimulation: {
-            CoSimulation* cs = (CoSimulation*)e;
-            printElement(indent, cs->capabilities);
-            printElement(indent, cs->model);
-            break;
-        }
-        case astModelDescription: {
-            ModelDescription *md = (ModelDescription*)e;
-            printList(indent, (void **)md->unitDefinitions);
-            printList(indent, (void **)md->typeDefinitions);
-            printElement(indent, md->defaultExperiment);
-            printList(indent, (void **)md->vendorAnnotations);
-            printList(indent, (void **)md->modelVariables);
-            printElement(indent, md->cosimulation);
-            break;
-        }
-    }
-}
-
-static void printList(int indent, void** list){
-    int i;
-    if (list) for (i=0; list[i]; i++)
-        printElement(indent, list[i]);
-}
-
-#endif // STANDALONE_XML_PARSER
-
-// -------------------------------------------------------------------------
-// free memory of the AST
-
-static void freeList(void** list);
-
-void freeElement(void* element){
-    int i;
-    Element* e = (Element *)element;
-    if (!e) return;
-    // free attributes
-    for (i=0; i<e->n; i+=2)
-        free((void *)e->attributes[i+1]);
-    if (e->attributes) free((void *)e->attributes);
-    // free child nodes
-    switch (getAstNodeType(e->type)) {
-        case astElement:
-            // we already freed the attributes
-            break;
-        case astListElement:
-            freeList((void **)((ListElement*)e)->list);
-            break;
-        case astScalarVariable:
-            freeList((void **)((ScalarVariable*)e)->directDependencies);
-        case astType:
-            freeElement(((Type*)e)->typeSpec);
-            break;
-        case astCoSimulation: {
-            CoSimulation* cs = (CoSimulation*)e;
-            freeElement(cs->capabilities);
-            freeElement(cs->model);
-            break;
-        }
-        case astModelDescription: {
-            ModelDescription* md = (ModelDescription*)e;
-            freeList((void **)md->unitDefinitions);
-            freeList((void **)md->typeDefinitions);
-            freeElement(md->defaultExperiment);
-            freeList((void **)md->vendorAnnotations);
-            freeList((void **)md->modelVariables);
-            freeElement(md->cosimulation);
-            break;
-        }
-    }
-    // free the struct
-    free(e);
-}
-
-static void freeList(void** list){
-    int i;
-    if (!list) return;
-    for (i=0; list[i]; i++)
-        freeElement(list[i]);
-    free(list);
-}
-
-// -------------------------------------------------------------------------
-// Validation - done after parsing to report all errors 
-
-ModelDescription* validate(ModelDescription* md) {
-    int error = 0;
-    int i;
-    if (md->modelVariables)
-    for (i=0; md->modelVariables[i]; i++){
-        ScalarVariable* sv = (ScalarVariable*)md->modelVariables[i];
-        const char* declaredType = getString(sv->typeSpec, att_declaredType);
-        Type* declType = getDeclaredType(md, declaredType);
-        if (declaredType && declType==NULL) {
-            logThis(ERROR_WARNING, "Declared type %s of variable %s not found in modelDescription.xml", declaredType, getName(sv));
-            error++;
-        }
-    }
-    if (error) {
-        logThis(ERROR_ERROR, "Found %d error in modelDescription.xml", error);
-        return NULL;
-    }
-    return md;
-}
-
-// -------------------------------------------------------------------------
-// Entry function parse() of the XML parser 
-
-static void cleanup(FILE *file) {
-    stackFree(stack);
-    stack = NULL;
-    XML_ParserFree(parser);
-    parser = NULL;
-    fclose(file);
-}
-
-// Returns NULL to indicate failure
-// Otherwise, return the root node md of the AST.
-// The receiver must call freeElement(md) to release AST memory.
-ModelDescription* parse(const char* xmlPath) {
-    ModelDescription* md = NULL;
-    FILE *file;
-    int done = 0;
-    stack = stackNew(100, 10);
-    if (!checkPointer(stack)) return NULL; // failure
-    parser = XML_ParserCreate(NULL);
-    if (!checkPointer(parser)) return NULL; // failure
-    XML_SetElementHandler(parser, startElement, endElement);
-    XML_SetCharacterDataHandler(parser, handleData);
-    file = fopen(xmlPath, "rb");
-    if (file == NULL) {
-        logThis(ERROR_ERROR, "Cannot open file '%s'", xmlPath);
-        XML_ParserFree(parser);
-        return NULL; // failure
-    }
-    logThis(ERROR_INFO, "parse %s", xmlPath);
-    while (!done) {
-        int n = fread(text, sizeof(char), XMLBUFSIZE, file);
-        if (n != XMLBUFSIZE) done = 1;
-        if (!XML_Parse(parser, text, n, done)){
-            logThis(ERROR_ERROR, "Parse error in file %s at line %d:\n%s\n",
-                    xmlPath,
-                    XML_GetCurrentLineNumber(parser),
-                    XML_ErrorString(XML_GetErrorCode(parser)));
-            while (!stackIsEmpty(stack)) md = (ModelDescription *)stackPop(stack);
-            if (md) freeElement(md);
-            cleanup(file);
-            return NULL; // failure
-        }
-    }
-    md = (ModelDescription *)stackPop(stack);
-    assert(stackIsEmpty(stack));
-    cleanup(file);
-    //printElement(1, md); // debug
-    return validate(md); // success if all refs are valid
-}
-
-// #define TEST
-#ifdef TEST
-int main(int argc, char**argv) {
-    ModelDescription* md;
-    // { char c='c'; while(c!='g') scanf("%c", &c); } // to debug: wait for the g key
-
-    if (argc!=2) {
-        printf("usage: xml_parser <filename>");
-        return;
-    }
-    logThis(ERROR_INFO, "Parsing %s ...\n", argv[1]);
-    md = parse(argv[1]);
-    if (md) {
-        printf("Successfully parsed %s\n", argv[1]);
-        printElement(1, md);
-        freeElement(md);
-    }
-    dumpMemoryLeaks();
-}
-#endif  // TEST

SemanticAdaptationForFMI/Experiments/fmusdk/fmu10/src/shared/xml_parser.h

@@ -1,180 +0,0 @@
-/*
- * Copyright QTronic GmbH. All rights reserved.
- */
-
-/* -------------------------------------------------------------------------
- * xml_parser.h
- * A parser for file modelVariables.xml of an FMU.
- * Supports "FMI for Model Exchange 1.0" and "FMI for Co-Simulation 1.0".
- * Author: Jakob Mauss, January 2010. 
- * -------------------------------------------------------------------------*/
-
-#ifndef xml_parser_h
-#define xml_parser_h
-
-// define XML_STATIC before including expat.h
-// to prevent error when linking with libexpatMT.lib
-#define XML_STATIC 
-#include "expat.h"
-#include "stack.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef fmiModelTypes_h
-#ifndef fmiPlatformTypes_h
-typedef unsigned int fmiValueReference;
-#endif
-#endif
-
-#define fmiUndefinedValueReference (fmiValueReference)(-1)
-
-#define SIZEOF_ELM 31
-extern const char *elmNames[SIZEOF_ELM];
-
-#define SIZEOF_ATT 47
-extern const char *attNames[SIZEOF_ATT];
-
-#define SIZEOF_ENU 13
-extern const char *enuNames[SIZEOF_ENU];
-
-// Attributes
-typedef enum {
-    elm_BAD_DEFINED = -1,
-    elm_fmiModelDescription,elm_UnitDefinitions,elm_BaseUnit,elm_DisplayUnitDefinition,elm_TypeDefinitions,
-    elm_Type,elm_RealType,elm_IntegerType,elm_BooleanType,elm_StringType,elm_EnumerationType,elm_Item,
-    elm_DefaultExperiment,elm_VendorAnnotations,elm_Tool,elm_Annotation,elm_ModelVariables,elm_ScalarVariable,
-    elm_DirectDependency,elm_Name,elm_Real,elm_Integer,elm_Boolean,elm_String,elm_Enumeration,
-    elm_Implementation,elm_CoSimulation_StandAlone,elm_CoSimulation_Tool,elm_Model,elm_File,elm_Capabilities
-} Elm;
-
-// Attributes
-typedef enum {
-    att_BAD_DEFINED = -1,
-    att_fmiVersion,att_displayUnit,att_gain,att_offset,att_unit,att_name,att_description,att_quantity,att_relativeQuantity,
-    att_min,att_max,att_nominal,att_declaredType,att_start,att_fixed,att_startTime,att_stopTime,att_tolerance,att_value,
-    att_valueReference,att_variability,att_causality,att_alias,att_modelName,att_modelIdentifier,att_guid,att_author,
-    att_version,att_generationTool,att_generationDateAndTime,att_variableNamingConvention,att_numberOfContinuousStates,
-    att_numberOfEventIndicators,att_input,
-    att_canHandleVariableCommunicationStepSize,att_canHandleEvents,att_canRejectSteps,att_canInterpolateInputs,
-    att_maxOutputDerivativeOrder,att_canRunAsynchronuously,att_canSignalEvents,att_canBeInstantiatedOnlyOncePerProcess,
-    att_canNotUseMemoryManagementFunctions,att_entryPoint,att_manualStart,att_type
-} Att;
-
-// Enumeration values
-typedef enum {
-    enu_BAD_DEFINED = -1,
-    enu_flat,enu_structured,enu_constant,enu_parameter,enu_discrete,enu_continuous,
-    enu_input,enu_output,enu_internal,enu_none,enu_noAlias,enu_alias,enu_negatedAlias
-} Enu;
-
-// AST node for element 
-// DisplayUnitDefinition, RealType, IntegerType, BooleanType, StringType, DefaultExperiment,
-// Item, Annotation, Name, Real, Integer, Boolean, String, Enumeration, Capabilities, File
-typedef struct {
-    Elm type;          // element type
-    const char** attributes; // null or n attribute value strings
-    int n;             // size of attributes, even number
-} Element;
-
-// AST node for element that has a list of elements 
-// BaseUnit, EnumerationType, Tool, DirectDependency, Model
-typedef struct {
-    Elm type;          // element type
-    const char** attributes; // null or n attribute value strings
-    int n;             // size of attributes, even number
-    Element** list;    // null-terminated array of pointers to elements, not null
-} ListElement;
-
-// AST node for element Type
-typedef struct {
-    Elm type;          // element type
-    const char** attributes; // null or n attribute value strings
-    int n;             // size of attributes, an even number
-    Element* typeSpec; // one of RealType, IntegerType etc.
-} Type;
-
-// AST node for element ScalarVariable
-typedef struct {
-    Elm type;          // element type
-    const char** attributes; // null or n attribute value strings
-    int n;             // size of attributes, even number
-    Element* typeSpec; // one of Real, Integer, etc
-    Element** directDependencies; // null or null-terminated list of Name
-    int  modelIdx;     // only used in fmu10
-} ScalarVariable;
-
-// AST node for element CoSimulation_StandAlone and CoSimulation_Tool
-typedef struct {
-    Elm type;                // one of elm_CoSimulation_StandAlone and elm_CoSimulation_Tool
-    const char** attributes; // null or n attribute value strings
-    int n;                   // size of attributes, even number
-    Element* capabilities;   // a set of capability attributes
-    ListElement* model;      // non-NULL to support tool coupling, NULL for standalone
-} CoSimulation;
-
-// AST node for element ModelDescription
-typedef struct {
-    Elm type;                // element type
-    const char** attributes; // null or n attribute value strings
-    int n;                   // size of attributes, even number
-    ListElement** unitDefinitions;    // NULL or null-terminated list of BaseUnits
-    Type**        typeDefinitions;    // NULL or null-terminated list of Types
-    Element*      defaultExperiment;  // NULL or DefaultExperiment
-    ListElement** vendorAnnotations;  // NULL or null-terminated list of Tools
-    ScalarVariable** modelVariables;  // NULL or null-terminated list of ScalarVariable
-    CoSimulation* cosimulation;       // NULL if this ModelDescription is for model exchange only
-} ModelDescription;
-
-// types of AST nodes used to represent an element
-typedef enum { 
-    astElement,
-    astListElement,
-    astType,
-    astScalarVariable,
-    astCoSimulation,
-    astModelDescription
-} AstNodeType;
-
-// Possible results when retrieving an attribute value from an element
-typedef enum { 
-    valueMissing,
-    valueDefined,
-    valueIllegal
-} ValueStatus;
-
-// Public methods: Parsing and low-level AST access
-ModelDescription* parse(const char* xmlPath);
-const char* getString(void* element, Att a);
-double getDouble     (void* element, Att a, ValueStatus* vs);
-int getInt           (void* element, Att a, ValueStatus* vs);
-unsigned int getUInt (void* element, Att a, ValueStatus* vs);
-char getBoolean      (void* element, Att a, ValueStatus* vs);
-Enu getEnumValue     (void* element, Att a, ValueStatus* vs);
-void freeElement     (void* element);
-
-// Convenience methods for AST access. To be used afer successful validation only.
-const char* getModelIdentifier(ModelDescription* md);
-int getNumberOfStates(ModelDescription* md);
-int getNumberOfEventIndicators(ModelDescription* md);
-const char* getName(void* element);
-Enu getCausality(void* scalarVariable);
-Enu getVariability(void* scalarVariable);
-Enu getAlias(void* scalarVariable);
-fmiValueReference getValueReference(void* scalarVariable);
-ScalarVariable* getVariableByName(ModelDescription* md, const char* name);
-ScalarVariable* getVariable(ModelDescription* md, fmiValueReference vr, Elm type);
-ScalarVariable* getNonAliasVariable(ModelDescription* md, fmiValueReference vr, Elm type);
-Type* getDeclaredType(ModelDescription* md, const char* declaredType);
-const char* getString2(ModelDescription* md, void* sv, Att a);
-const char * getDescription(ModelDescription* md, ScalarVariable* sv);
-const char * getVariableAttributeString(ModelDescription* md, fmiValueReference vr, Elm type, Att a);
-double getVariableAttributeDouble(ModelDescription* md, fmiValueReference vr, Elm type, Att a, ValueStatus* vs);
-//double getNominal(ModelDescription* md, ScalarVariable* sv);
-double getNominal(ModelDescription* md, fmiValueReference vr);
-
-#ifdef __cplusplus
-} // closing brace for extern "C"
-#endif
-#endif // xml_parser_h