Changeset df6240e in OpenModelica


Ignore:
Timestamp:
2020-10-21T14:04:15+02:00 (3 years ago)
Author:
Mahder Gebremedhin <mahder.gebremedhin@…>
Children:
c6856ffe
Parents:
91ac78f
git-author:
Mahder Gebremedhin <mahder.gebremedhin@…> (07/12/20 20:34:30)
git-committer:
Mahder Gebremedhin <mahder.gebremedhin@…> (10/21/20 14:04:15)
Message:

[cmake] Initial cmake configuration support.

Location:
OMCompiler
Files:
3 added
10 edited

Legend:

Unmodified
Added
Removed
  • OMCompiler/CMakeLists.txt

    r818a8f24 rdf6240e  
    1 # Jens Frenkel, Jens.Frenkel@tu-dresden.de, 2010-03-30
    2 # CMakefile for compilation of OMC
     1cmake_minimum_required(VERSION 3.14)
     2project(OMCompiler)
    33
    4 # CMAKE
    5 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
    6 # PROJECT
    7 PROJECT(OpenModelicaCompiler)
     4# set(CMAKE_VERBOSE_MAKEFILE ON)
    85
    9 # Defines for Visual Studio
    10 if(MSVC)
    11   add_definitions(-D_CRT_SECURE_NO_WARNINGS -DNOMINMAX -D_COMPLEX_DEFINED)
    12 endif(MSVC)
     6set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/.cmake/")
     7include(omc_utils)
    138
    14 # Global Variables
    15 SET(OMCTRUNCHOME ${CMAKE_CURRENT_SOURCE_DIR})
    16 SET(CODEGENDIR ${CMAKE_CURRENT_BINARY_DIR}/codegen)
    17 SET(OPENMODELICAHOME $ENV{OPENMODELICAHOME})
    18 SET(OMC_DEBUG ${OPENMODELICAHOME}/bin/omc.exe)
     9if(NOT CMAKE_BUILD_TYPE)
     10  set(CMAKE_BUILD_TYPE "Release" CACHE STRING
     11      "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
     12endif(NOT CMAKE_BUILD_TYPE)
     13omc_add_to_report(CMAKE_BUILD_TYPE)
    1914
    20 # Tests
    21 OPTION(RUN_TESTS  "Run Tests"  OFF)
    22 IF(RUN_TESTS)
    23 enable_testing()
    24 ADD_SUBDIRECTORY(testsuite)
    25 ENDIF(RUN_TESTS)
     15omc_add_subdirectory(3rdParty)
     16omc_add_subdirectory(SimulationRuntime)
     17omc_add_subdirectory(Compiler)
     18# omc_add_subdirectory(Parser)
    2619
    27 # Subdirectorys
    28 #ADD_SUBDIRECTORY(modelica_parser)
    29 #ADD_SUBDIRECTORY(flat_modelica_parser)
    30 #ADD_SUBDIRECTORY(Compiler)
    31 #ADD_SUBDIRECTORY(doc)
    32 #ADD_SUBDIRECTORY(Examples)
    33 ADD_SUBDIRECTORY(SimulationRuntime)
    34 #ADD_SUBDIRECTORY(3rdParty/FMIL/ThirdParty/Expat/expat-2.0.1)
    3520
    36 IF(RUN_TESTS)
    37 # -------------------------------------------------------------
    38 # Models
    39 # -------------------------------------------------------------
    40 # add here your models to compile (add filename without ".mo")
    41 # Example:
    42 #    BUILDMODEL(model dir Flags CSRC)
    43 #BUILDMODEL(BouncingBall ${CMAKE_CURRENT_SOURCE_DIR}/testsuite/mosfiles-dassl -d=bltdump "")
    44 #BUILDMODELFMU(Test ${CMAKE_CURRENT_SOURCE_DIR}/build/bin/Test/FMU -d=bltdump "")
    45 #BUILDMODELMOS(PolyEvaluate2 PolynomialEvaluatorB.mos ${CMAKE_CURRENT_SOURCE_DIR}/testsuite/simulation/modelica/arrays  +simCodeTarget=C "")
    46 #BUILDMODELFMUMOS(WheelLoader D:/Temp/Modell/Radlader-CNH/WheelLoader.mos -d=bltdump "")
    47 ENDIF(RUN_TESTS)
     21message(STATUS "--------------------------------------------------------------------------")
     22message(STATUS "--------------------------------------------------------------------------")
     23feature_summary(WHAT ALL)
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36# # Defines for Visual Studio
     37# if(MSVC)
     38#   add_definitions(-D_CRT_SECURE_NO_WARNINGS -DNOMINMAX -D_COMPLEX_DEFINED)
     39# endif(MSVC)
     40
     41# # Global Variables
     42# SET(OMCTRUNCHOME ${CMAKE_CURRENT_SOURCE_DIR})
     43# SET(CODEGENDIR ${CMAKE_CURRENT_BINARY_DIR}/codegen)
     44# SET(OPENMODELICAHOME $ENV{OPENMODELICAHOME})
     45# SET(OMC_DEBUG ${OPENMODELICAHOME}/bin/omc.exe)
     46
     47# # Tests
     48# OPTION(RUN_TESTS  "Run Tests"  OFF)
     49# IF(RUN_TESTS)
     50# enable_testing()
     51# ADD_SUBDIRECTORY(testsuite)
     52# ENDIF(RUN_TESTS)
     53
     54# # Subdirectorys
     55# #ADD_SUBDIRECTORY(modelica_parser)
     56# #ADD_SUBDIRECTORY(flat_modelica_parser)
     57# #ADD_SUBDIRECTORY(Compiler)
     58# #ADD_SUBDIRECTORY(doc)
     59# #ADD_SUBDIRECTORY(Examples)
     60# ADD_SUBDIRECTORY(SimulationRuntime)
     61# #ADD_SUBDIRECTORY(3rdParty/FMIL/ThirdParty/Expat/expat-2.0.1)
     62
     63# IF(RUN_TESTS)
     64# # -------------------------------------------------------------
     65# # Models
     66# # -------------------------------------------------------------
     67# # add here your models to compile (add filename without ".mo")
     68# # Example:
     69# #    BUILDMODEL(model dir Flags CSRC)
     70# #BUILDMODEL(BouncingBall ${CMAKE_CURRENT_SOURCE_DIR}/testsuite/mosfiles-dassl -d=bltdump "")
     71# #BUILDMODELFMU(Test ${CMAKE_CURRENT_SOURCE_DIR}/build/bin/Test/FMU -d=bltdump "")
     72# #BUILDMODELMOS(PolyEvaluate2 PolynomialEvaluatorB.mos ${CMAKE_CURRENT_SOURCE_DIR}/testsuite/simulation/modelica/arrays  +simCodeTarget=C "")
     73# #BUILDMODELFMUMOS(WheelLoader D:/Temp/Modell/Radlader-CNH/WheelLoader.mos -d=bltdump "")
     74# ENDIF(RUN_TESTS)
  • OMCompiler/Compiler/CMakeLists.txt

    r818a8f24 rdf6240e  
     1
     2# omc_add_subdirectory(runtime)
     3INCLUDE(ExternalProject)
     4
     5add_custom_target(omc_custom COMMAND make -f Makefile.omdev.mingw
     6                   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
     7)
     8
     9
    110
    211# The MO sources
    3 SET(SRCMO Absyn.mo AbsynDep.mo Algorithm.mo Builtin.mo
    4           Ceval.mo CevalScript.mo ClassInf.mo
    5       ClassLoader.mo Connect.mo ExpandableConnectors.mo
    6       ConnectionGraph.mo Convert.mo DAE.mo DAELow.mo
    7       DAEUtil.mo Differentiate.mo Debug.mo  DFA.mo Dump.mo
    8       DumpGraphviz.mo DynamicOptimization.mo Constants.mo Env.mo Error.mo
    9       Exp.mo SCode.mo SCodeUtil.mo Graphviz.mo HashTable.mo
    10       HashTable2.mo HashTable3.mo HashTable4.mo HashTable5.mo
    11       HashTable6.mo HashTableCG.mo HashTableStringToPath.mo
    12       Inline.mo Inst.mo InstExtends.mo Interactive.mo
    13       Lookup.mo Main.mo MMath.mo MetaUtil.mo Mod.mo
    14       PartFn.mo Patternm.mo Prefix.mo PrefixUtil.mo Static.mo
    15       SimCode.mo SimCodeC.mo SimCodeCSharp.mo
    16       Types.mo TaskGraph.mo Tpl.mo TplAbsyn.mo TplCodegen.mo
    17       TplParser.mo TplMain.mo Util.mo UnitAbsyn.mo
    18       UnitAbsynBuilder.mo UnitChecker.mo Values.mo ValuesUtil.mo
    19       VarTransform.mo BackendVarTransform.mo Refactor.mo
    20       DAEQuery.mo XMLDump.mo InstanceHierarchy.mo InnerOuter.mo
    21       ConnectUtil.mo Dependency.mo)
     12# SET(SRCMO Absyn.mo AbsynDep.mo Algorithm.mo Builtin.mo
     13#           Ceval.mo CevalScript.mo ClassInf.mo
     14#       ClassLoader.mo Connect.mo ExpandableConnectors.mo
     15#       ConnectionGraph.mo Convert.mo DAE.mo DAELow.mo
     16#       DAEUtil.mo Differentiate.mo Debug.mo  DFA.mo Dump.mo
     17#       DumpGraphviz.mo DynamicOptimization.mo Constants.mo Env.mo Error.mo
     18#       Exp.mo SCode.mo SCodeUtil.mo Graphviz.mo HashTable.mo
     19#       HashTable2.mo HashTable3.mo HashTable4.mo HashTable5.mo
     20#       HashTable6.mo HashTableCG.mo HashTableStringToPath.mo
     21#       Inline.mo Inst.mo InstExtends.mo Interactive.mo
     22#       Lookup.mo Main.mo MMath.mo MetaUtil.mo Mod.mo
     23#       PartFn.mo Patternm.mo Prefix.mo PrefixUtil.mo Static.mo
     24#       SimCode.mo SimCodeC.mo SimCodeCSharp.mo
     25#       Types.mo TaskGraph.mo Tpl.mo TplAbsyn.mo TplCodegen.mo
     26#       TplParser.mo TplMain.mo Util.mo UnitAbsyn.mo
     27#       UnitAbsynBuilder.mo UnitChecker.mo Values.mo ValuesUtil.mo
     28#       VarTransform.mo BackendVarTransform.mo Refactor.mo
     29#       DAEQuery.mo XMLDump.mo InstanceHierarchy.mo InnerOuter.mo
     30#       ConnectUtil.mo Dependency.mo)
    2231
    23 SET(ALLMO ${SRCMO} DAEEXT.mo DynLoad.mo Print.mo System.mo Parser.mo
    24     TaskGraphExt.mo Corba.mo Socket.mo ZeroMQ.mo ErrorExt.mo Settings.mo
    25     UnitParserExt.mo SimulationResults.mo Serializer.mo OMSimulator.mo)
     32# SET(ALLMO ${SRCMO} DAEEXT.mo DynLoad.mo Print.mo System.mo Parser.mo
     33#     TaskGraphExt.mo Corba.mo Socket.mo ZeroMQ.mo ErrorExt.mo Settings.mo
     34#     UnitParserExt.mo SimulationResults.mo Serializer.mo OMSimulator.mo)
    2635
    27 # RML
    28 IF(NOT RML)
    29   FIND_PROGRAM(RML rml DOC "Location of the RML executable"
    30                PATHS ENV OMDEV ${RMLHOME}/bin
    31                PATH_SUFFIXES bin tools/rml/bin)
    32   MESSAGE(STATUS "-- rml is " ${RML})
    33 ENDIF(NOT RML)
     36# # RML
     37# IF(NOT RML)
     38#   FIND_PROGRAM(RML rml DOC "Location of the RML executable"
     39#                PATHS ENV OMDEV ${RMLHOME}/bin
     40#                PATH_SUFFIXES bin tools/rml/bin)
     41#   MESSAGE(STATUS "-- rml is " ${RML})
     42# ENDIF(NOT RML)
    3443
    35 #copy all to CODEGENDIR
    36 FOREACH(DEP ${ALLMO})
     44# #copy all to CODEGENDIR
     45# FOREACH(DEP ${ALLMO})
    3746
    38   # Datei- und Pfadname
    39     GET_FILENAME_COMPONENT(DF ${DEP} NAME)
    40     GET_FILENAME_COMPONENT(DFWE ${DEP} NAME_WE)
    41     GET_FILENAME_COMPONENT(DP ${DEP} PATH)
     47#   # Datei- und Pfadname
     48#     GET_FILENAME_COMPONENT(DF ${DEP} NAME)
     49#     GET_FILENAME_COMPONENT(DFWE ${DEP} NAME_WE)
     50#     GET_FILENAME_COMPONENT(DP ${DEP} PATH)
    4251
    43   # Suchen
    44   FIND_FILE(${DEP}_FILE ${DF} PATHS ${DP} ${CMAKE_CURRENT_SOURCE_DIR})
     52#   # Suchen
     53#   FIND_FILE(${DEP}_FILE ${DF} PATHS ${DP} ${CMAKE_CURRENT_SOURCE_DIR})
    4554
    46   # Wenn nicht gefunden, dann Original nehmen
    47   STRING(COMPARE EQUAL ${${DEP}_FILE} ${DEP}_FILE-NOTFOUND FF)
    48   IF(${FF})
    49     SET(${DEP}_FILE "\"${DEP}\"")
    50   ENDIF(${FF})
     55#   # Wenn nicht gefunden, dann Original nehmen
     56#   STRING(COMPARE EQUAL ${${DEP}_FILE} ${DEP}_FILE-NOTFOUND FF)
     57#   IF(${FF})
     58#     SET(${DEP}_FILE "\"${DEP}\"")
     59#   ENDIF(${FF})
    5160
    52    SET(COPY_DEP  ${${DEP}_FILE})
     61#   SET(COPY_DEP  ${${DEP}_FILE})
    5362
    54   SET(COPY_OUTPUT  ${CODEGENDIR}/${DEP})
    55   # custom command for copy
    56   ADD_CUSTOM_COMMAND(OUTPUT ${COPY_OUTPUT}
    57                      COMMAND ${CMAKE_COMMAND} -E copy ${COPY_DEP} ${COPY_OUTPUT}
    58            DEPENDS ${COPY_DEP}
    59                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    60                      COMMENT "copy ${COPY_DEP} to ${COPY_OUTPUT}")
     63#   SET(COPY_OUTPUT  ${CODEGENDIR}/${DEP})
     64#   # custom command for copy
     65#   ADD_CUSTOM_COMMAND(OUTPUT ${COPY_OUTPUT}
     66#                      COMMAND ${CMAKE_COMMAND} -E copy ${COPY_DEP} ${COPY_OUTPUT}
     67#            DEPENDS ${COPY_DEP}
     68#                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     69#                      COMMENT "copy ${COPY_DEP} to ${COPY_OUTPUT}")
    6170
    62   # target fuer OM_OUTPUT
    63   ADD_CUSTOM_TARGET(${DFWE}_cp ALL DEPENDS ${COPY_OUTPUT})
     71#   # target fuer OM_OUTPUT
     72#   ADD_CUSTOM_TARGET(${DFWE}_cp ALL DEPENDS ${COPY_OUTPUT})
    6473
    65   # remember
    66   SET(COPY_ALL ${COPY_ALL} ${COPY_OUTPUT})
    67 ENDFOREACH(DEP)
     74#   # remember
     75#   SET(COPY_ALL ${COPY_ALL} ${COPY_OUTPUT})
     76# ENDFOREACH(DEP)
    6877
    69 #.depend:
    70 SET(DEPENDT_OUTPUT  ${CODEGENDIR}/.depend)
    71 # custom command for rml to sig
    72 ADD_CUSTOM_COMMAND(OUTPUT ${DEPENDT_OUTPUT}
    73                    COMMAND ${RML} -fdump-depends ${SRCMO} > .depend
    74                    DEPENDS ${COPY_ALL}
    75                    WORKING_DIRECTORY ${CODEGENDIR}
    76                    COMMENT "Generate .depend")
     78# #.depend:
     79# SET(DEPENDT_OUTPUT  ${CODEGENDIR}/.depend)
     80# # custom command for rml to sig
     81# ADD_CUSTOM_COMMAND(OUTPUT ${DEPENDT_OUTPUT}
     82#                    COMMAND ${RML} -fdump-depends ${SRCMO} > .depend
     83#                    DEPENDS ${COPY_ALL}
     84#                    WORKING_DIRECTORY ${CODEGENDIR}
     85#                    COMMENT "Generate .depend")
    7786
    78 # target fuer OM_OUTPUT
    79 ADD_CUSTOM_TARGET(depend ALL DEPENDS ${DEPENDT_OUTPUT})
     87# # target fuer OM_OUTPUT
     88# ADD_CUSTOM_TARGET(depend ALL DEPENDS ${DEPENDT_OUTPUT})
    8089
    8190
    82 # generate sig files
    83 FOREACH(DEP ${ALLMO})
     91# # generate sig files
     92# FOREACH(DEP ${ALLMO})
    8493
    85   # Datei- und Pfadname
    86     GET_FILENAME_COMPONENT(DF ${DEP} NAME)
    87     GET_FILENAME_COMPONENT(DFWE ${DEP} NAME_WE)
     94#   # Datei- und Pfadname
     95#     GET_FILENAME_COMPONENT(DF ${DEP} NAME)
     96#     GET_FILENAME_COMPONENT(DFWE ${DEP} NAME_WE)
    8897
    89   # Merken
    90   SET(SIG_DEP ${DFWE}.sig)
     98#   # Merken
     99#   SET(SIG_DEP ${DFWE}.sig)
    91100
    92   SET(SIGX_OUTPUT  ${CODEGENDIR}/${SIG_DEP})
    93   # custom command for rml to sig
    94   ADD_CUSTOM_COMMAND(OUTPUT ${SIGX_OUTPUT}
    95                      COMMAND ${RML} -fdump-interface ${DEP} > ${SIG_DEP}
    96            DEPENDS ${DEPENDT_OUTPUT}
    97                      WORKING_DIRECTORY ${CODEGENDIR}
    98                      COMMENT "Generate Sigx from ${DF}")
     101#   SET(SIGX_OUTPUT  ${CODEGENDIR}/${SIG_DEP})
     102#   # custom command for rml to sig
     103#   ADD_CUSTOM_COMMAND(OUTPUT ${SIGX_OUTPUT}
     104#                      COMMAND ${RML} -fdump-interface ${DEP} > ${SIG_DEP}
     105#            DEPENDS ${DEPENDT_OUTPUT}
     106#                      WORKING_DIRECTORY ${CODEGENDIR}
     107#                      COMMENT "Generate Sigx from ${DF}")
    99108
    100   # target fuer OM_OUTPUT
    101   ADD_CUSTOM_TARGET(${DFWE}_sig ALL DEPENDS ${SIGX_OUTPUT})
     109#   # target fuer OM_OUTPUT
     110#   ADD_CUSTOM_TARGET(${DFWE}_sig ALL DEPENDS ${SIGX_OUTPUT})
    102111
    103     # remember
    104   SET(SIGX_ALL ${SIGX_ALL} ${SIGX_OUTPUT} )
    105 ENDFOREACH(DEP)
     112#     # remember
     113#   SET(SIGX_ALL ${SIGX_ALL} ${SIGX_OUTPUT} )
     114# ENDFOREACH(DEP)
    106115
    107 # generate *.h and *.c from *.mo files
    108 FOREACH(DEP ${SRCMO})
     116# # generate *.h and *.c from *.mo files
     117# FOREACH(DEP ${SRCMO})
    109118
    110   # Datei- und Pfadname
    111     GET_FILENAME_COMPONENT(DF ${DEP} NAME)
    112     GET_FILENAME_COMPONENT(DFWE ${DEP} NAME_WE)
     119#   # Datei- und Pfadname
     120#     GET_FILENAME_COMPONENT(DF ${DEP} NAME)
     121#     GET_FILENAME_COMPONENT(DFWE ${DEP} NAME_WE)
    113122
    114   # Merken
    115   SET(MOCH_DEP ${CODEGENDIR}/${DFWE}.h ${CODEGENDIR}/${DFWE}.c)
     123#   # Merken
     124#   SET(MOCH_DEP ${CODEGENDIR}/${DFWE}.h ${CODEGENDIR}/${DFWE}.c)
    116125
    117   SET(MOCH_OUTPUT  ${MOCH_DEP})
    118   # custom command for rml to sig
    119   ADD_CUSTOM_COMMAND(OUTPUT ${MOCH_OUTPUT}
    120                      COMMAND ${RML} -Eplain -ftrace ${RMLCFLAGS} ${DEP}
    121            DEPENDS ${SIGX_ALL}
    122                      WORKING_DIRECTORY ${CODEGENDIR}
    123                      COMMENT "Generate *.h and *.c from ${DEP}")
     126#   SET(MOCH_OUTPUT  ${MOCH_DEP})
     127#   # custom command for rml to sig
     128#   ADD_CUSTOM_COMMAND(OUTPUT ${MOCH_OUTPUT}
     129#                      COMMAND ${RML} -Eplain -ftrace ${RMLCFLAGS} ${DEP}
     130#            DEPENDS ${SIGX_ALL}
     131#                      WORKING_DIRECTORY ${CODEGENDIR}
     132#                      COMMENT "Generate *.h and *.c from ${DEP}")
    124133
    125   # target fuer OM_OUTPUT
    126   ADD_CUSTOM_TARGET(${DFWE}_codegen ALL DEPENDS ${MOCH_OUTPUT})
     134#   # target fuer OM_OUTPUT
     135#   ADD_CUSTOM_TARGET(${DFWE}_codegen ALL DEPENDS ${MOCH_OUTPUT})
    127136
    128   # remember
    129   SET(MOCH_ALL ${MOCH_ALL} ${MOCH_OUTPUT})
    130   SET(MOCH_codegen_ALL ${MOCH_codegen_ALL} ${DFWE}_codegen)
    131 ENDFOREACH(DEP)
     137#   # remember
     138#   SET(MOCH_ALL ${MOCH_ALL} ${MOCH_OUTPUT})
     139#   SET(MOCH_codegen_ALL ${MOCH_codegen_ALL} ${DFWE}_codegen)
     140# ENDFOREACH(DEP)
    132141
    133 ADD_SUBDIRECTORY(runtime)
    134 ADD_SUBDIRECTORY(absyn_builder)
    135 ADD_SUBDIRECTORY(modpar)
     142# ADD_SUBDIRECTORY(runtime)
     143# ADD_SUBDIRECTORY(absyn_builder)
     144# ADD_SUBDIRECTORY(modpar)
    136145
    137 if(WIN32)
    138 INCLUDE_DIRECTORIES($ENV{OMDEV}/tools/rml/include/plain)
    139 link_directories($ENV{OMDEV}/lib/antlr-win32-msvc/md-mdd ${OMCTRUNCHOME}/Compiler/runtime/lpsolve/lib/win32)
    140 link_directories($ENV{OMDEV}/tools/rml/lib/plain)
    141 #link_directories(D:/Programming/OPENMODELICA/buildmmc/runtime/plain/RelWithDebInfo)
    142 else(WIN32)
    143 INCLUDE_DIRECTORIES(${RMLHOME}/include/plain)
    144 link_directories(${RMLHOME}/lib/plain)
    145 endif(WIN32)
    146 INCLUDE_DIRECTORIES(${CODEGENDIR})
     146# if(WIN32)
     147# INCLUDE_DIRECTORIES($ENV{OMDEV}/tools/rml/include/plain)
     148# link_directories($ENV{OMDEV}/lib/antlr-win32-msvc/md-mdd ${OMCTRUNCHOME}/Compiler/runtime/lpsolve/lib/win32)
     149# link_directories($ENV{OMDEV}/tools/rml/lib/plain)
     150# #link_directories(D:/Programming/OPENMODELICA/buildmmc/runtime/plain/RelWithDebInfo)
     151# else(WIN32)
     152# INCLUDE_DIRECTORIES(${RMLHOME}/include/plain)
     153# link_directories(${RMLHOME}/lib/plain)
     154# endif(WIN32)
     155# INCLUDE_DIRECTORIES(${CODEGENDIR})
    147156
    148 # mico und benoetigte Bibliotheken
    149 IF(WIN32)
    150   SET(platform_libs optimized mico2313 debug mico2313d optimized antlr debug antlrd)
    151 ELSE(WIN32)
    152   SET(platform_libs mico2.3.13 optimized antlr debug antlrd) #ssl pthread)
    153 ENDIF(WIN32)
    154 # omc program
     157# # mico und benoetigte Bibliotheken
     158# IF(WIN32)
     159#   SET(platform_libs optimized mico2313 debug mico2313d optimized antlr debug antlrd)
     160# ELSE(WIN32)
     161#   SET(platform_libs mico2.3.13 optimized antlr debug antlrd) #ssl pthread)
     162# ENDIF(WIN32)
     163# # omc program
    155164
    156 #add_definitions(/Ob2 /Ox /O2 /Ot /Oy /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_CRT_SECURE_NO_WARNINGS" /D "_MBCS" /FD /EHsc /MT /W3 /nologo /c /TC /wd4311 /wd4312)
    157 if(WIN32)
    158 add_definitions(/D "_CRT_SECURE_NO_WARNINGS" /D "_CONSOLE")
    159 endif(WIN32)
    160 ADD_EXECUTABLE(omc ${MOCH_ALL})
    161 if(WIN32)
    162 TARGET_LINK_LIBRARIES(omc absyn_builder libmodpar sendData c_runtime wsock32 shlwapi)
    163 TARGET_LINK_LIBRARIES(omc  rml)
    164 else(WIN32)
    165 TARGET_LINK_LIBRARIES(omc absyn_builder libmodpar sendData c_runtime runtime optimized lpsolve55 debug lpsolve55d ${platform_libs})
    166 TARGET_LINK_LIBRARIES(omc rml)
    167 endif(WIN32)
     165# #add_definitions(/Ob2 /Ox /O2 /Ot /Oy /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_CRT_SECURE_NO_WARNINGS" /D "_MBCS" /FD /EHsc /MT /W3 /nologo /c /TC /wd4311 /wd4312)
     166# if(WIN32)
     167# add_definitions(/D "_CRT_SECURE_NO_WARNINGS" /D "_CONSOLE")
     168# endif(WIN32)
     169# ADD_EXECUTABLE(omc ${MOCH_ALL})
     170# if(WIN32)
     171# TARGET_LINK_LIBRARIES(omc absyn_builder libmodpar sendData c_runtime wsock32 shlwapi)
     172# TARGET_LINK_LIBRARIES(omc  rml)
     173# else(WIN32)
     174# TARGET_LINK_LIBRARIES(omc absyn_builder libmodpar sendData c_runtime runtime optimized lpsolve55 debug lpsolve55d ${platform_libs})
     175# TARGET_LINK_LIBRARIES(omc rml)
     176# endif(WIN32)
    168177
    169 # install
    170 INSTALL(TARGETS omc
    171         RUNTIME DESTINATION bin)
     178# # install
     179# INSTALL(TARGETS omc
     180#         RUNTIME DESTINATION bin)
  • OMCompiler/Compiler/runtime/CMakeLists.txt

    r818a8f24 rdf6240e  
    1 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
    21
    3 # Global Variables
    4 IF(NOT OMCTRUNCHOME)
    5   SET(OMCTRUNCHOME ${CMAKE_CURRENT_SOURCE_DIR}/../../)
    6 ENDIF (NOT OMCTRUNCHOME)
    72
    8 IF(NOT IDL)
    9   FIND_PROGRAM(IDL idl DOC "Location of the idl executable"
    10                PATHS ENV OMDEV
    11                PATH_SUFFIXES bin bin/mico)
    12   MESSAGE(STATUS "-- idl is " ${IDL})
    13 ENDIF(NOT IDL)
    143
    15 if(MSVC)
    16   add_definitions(-DOMC_NO_THREADS -D_CRT_SECURE_NO_WARNINGS)
    17 endif(MSVC)
    18 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
    19 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/lpsolve)
    20 INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/SimulationRuntime/c)
    21 INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/SimulationRuntime/c/meta)
    22 INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/SimulationRuntime/c/util)
    23 INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/3rdParty/gc/include)
    244
    25 # custom command for idl
    26 IF(IDL)
    27 SET(IDL_OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/omc_communication.cc ${CMAKE_CURRENT_BINARY_DIR}/omc_communication.h)
    28 ADD_CUSTOM_COMMAND(OUTPUT ${IDL_OUTPUT}
    29                    COMMAND ${IDL} ${CMAKE_CURRENT_SOURCE_DIR}/omc_communication.idl
    30                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    31                    COMMENT "Generate omc_communication")
     5set(OMC_RUNTIIME_SOURCES Error_omc.cpp)
     6add_library(omcruntime ${OMC_RUNTIIME_SOURCES})
     7target_link_libraries(omcruntime PUBLIC OpenModelicaRuntimeC)
     8target_include_directories(omcruntime PUBLIC ${OMCompiler_SOURCE_DIR}/Compiler) #for OpenModelicaBootstrappingHeader.h :/
     9target_include_directories(omcruntime PUBLIC ${SimulationRuntimeC_SOURCE_DIR}) #for openmodelica.h :/
    3210
    33 # target fuer OM_OUTPUT
    34 ADD_CUSTOM_TARGET(omc_communication ALL DEPENDS ${IDL_OUTPUT})
    35 ENDIF(IDL)
     11# CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
    3612
    37 # Quellen und Header
    38 SET(CORBASRC ${IDL_OUTPUT} omc_communication_impl.cpp corbaimpl.cpp)
    39 SET(SRC socketimpl.c printimpl.c systemimpl.c settingsimpl.c SimulationResults.c)
    40 SET(CPPSRC  unitparser.cpp unitparserext.cpp ptolemyio.cpp Dynload.cpp BackendDAEEXT.cpp ErrorMessage.cpp errorext.cpp
    41             systemimplmisc.cpp ${CORBASRC} serializer.cpp OMSimulator_omc.c)
    42 SET(OBJ ${SRC} ${CPPSRC})
     13# # Global Variables
     14# IF(NOT OMCTRUNCHOME)
     15#   SET(OMCTRUNCHOME ${CMAKE_CURRENT_SOURCE_DIR}/../../)
     16# ENDIF (NOT OMCTRUNCHOME)
    4317
    44 IF(WIN32)
    45   SET(platform_libs optimized mico2313 debug mico2313d)
    46 ELSE(WIN32)
    47   SET(platform_libs mico2.3.13)
    48 ENDIF(WIN32)
    49 link_directories(${OMCTRUNCHOME}/Compiler/runtime/lpsolve/lib/win32)
     18# IF(NOT IDL)
     19#   FIND_PROGRAM(IDL idl DOC "Location of the idl executable"
     20#                PATHS ENV OMDEV
     21#                PATH_SUFFIXES bin bin/mico)
     22#   MESSAGE(STATUS "-- idl is " ${IDL})
     23# ENDIF(NOT IDL)
    5024
    51 # Library runtime
    52 ADD_LIBRARY(runtime ${OBJ})
    53 TARGET_LINK_LIBRARIES(runtime sendData c_runtime ${platform_libs} optimized lpsolve55 debug lpsolve55d)
    54 IF(MOCH_codegen_ALL)
    55 add_dependencies(runtime ${MOCH_codegen_ALL})
    56 ENDIF(MOCH_codegen_ALL)
     25# if(MSVC)
     26#   add_definitions(-DOMC_NO_THREADS -D_CRT_SECURE_NO_WARNINGS)
     27# endif(MSVC)
     28# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
     29# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/lpsolve)
     30# INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/SimulationRuntime/c)
     31# INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/SimulationRuntime/c/meta)
     32# INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/SimulationRuntime/c/util)
     33# INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/3rdParty/gc/include)
     34
     35# # custom command for idl
     36# IF(IDL)
     37# SET(IDL_OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/omc_communication.cc ${CMAKE_CURRENT_BINARY_DIR}/omc_communication.h)
     38# ADD_CUSTOM_COMMAND(OUTPUT ${IDL_OUTPUT}
     39#                    COMMAND ${IDL} ${CMAKE_CURRENT_SOURCE_DIR}/omc_communication.idl
     40#                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     41#                    COMMENT "Generate omc_communication")
     42
     43# # target fuer OM_OUTPUT
     44# ADD_CUSTOM_TARGET(omc_communication ALL DEPENDS ${IDL_OUTPUT})
     45# ENDIF(IDL)
     46
     47# # Quellen und Header
     48# SET(CORBASRC ${IDL_OUTPUT} omc_communication_impl.cpp corbaimpl.cpp)
     49# SET(SRC socketimpl.c printimpl.c systemimpl.c settingsimpl.c SimulationResults.c)
     50# SET(CPPSRC  unitparser.cpp unitparserext.cpp ptolemyio.cpp Dynload.cpp BackendDAEEXT.cpp ErrorMessage.cpp errorext.cpp
     51#             systemimplmisc.cpp ${CORBASRC} serializer.cpp OMSimulator_omc.c)
     52# SET(OBJ ${SRC} ${CPPSRC})
     53
     54# IF(WIN32)
     55#   SET(platform_libs optimized mico2313 debug mico2313d)
     56# ELSE(WIN32)
     57#   SET(platform_libs mico2.3.13)
     58# ENDIF(WIN32)
     59# link_directories(${OMCTRUNCHOME}/Compiler/runtime/lpsolve/lib/win32)
     60
     61# # Library runtime
     62# ADD_LIBRARY(runtime ${OBJ})
     63# TARGET_LINK_LIBRARIES(runtime sendData c_runtime ${platform_libs} optimized lpsolve55 debug lpsolve55d)
     64# IF(MOCH_codegen_ALL)
     65# add_dependencies(runtime ${MOCH_codegen_ALL})
     66# ENDIF(MOCH_codegen_ALL)
  • OMCompiler/Compiler/runtime/Error_omc.cpp

    r818a8f24 rdf6240e  
    3333
    3434#include "openmodelica.h"
    35 #include "meta_modelica.h"
     35#include "meta/meta_modelica.h"
    3636#include "util/modelica_string.h"
    3737#define ADD_METARECORD_DEFINITIONS static
    3838#include "OpenModelicaBootstrappingHeader.h"
    39 #include "ModelicaUtilitiesExtra.h"
     39#include "util/ModelicaUtilitiesExtra.h"
    4040
    4141#if !defined(Util__notrans)
  • OMCompiler/Compiler/runtime/errorext.cpp

    r818a8f24 rdf6240e  
    3939#include "errorext.h"
    4040#include "openmodelica.h"
    41 #include "meta_modelica.h"
     41#include "meta/meta_modelica.h"
    4242#include "util/omc_error.h"
    4343#include "util/ModelicaUtilitiesExtra.h"
  • OMCompiler/Parser/Modelica.g

    r818a8f24 rdf6240e  
    198198
    199199  #if !defined(OMJULIA)
    200   #include "meta_modelica.h"
     200  #include "meta/meta_modelica.h"
    201201  #include "OpenModelicaBootstrappingHeader.h"
    202202  parser_members members;
  • OMCompiler/SimulationRuntime/CMakeLists.txt

    r818a8f24 rdf6240e  
    33
    44# Subdirectorys
    5 ADD_SUBDIRECTORY(c)
     5omc_add_subdirectory(c)
     6# omc_add_subdirectory(ParModelica)
    67#ADD_SUBDIRECTORY(cpp)
    78#ADD_SUBDIRECTORY(fmi)
  • OMCompiler/SimulationRuntime/c/CMakeLists.txt

    r818a8f24 rdf6240e  
    1 # Jens Frenkel, Jens.Frenkel@tu-dresden.de, 2011-10-11
    2 # CMakefile for compilation of OMC
    3 
    4 # CMAKE
    5 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
    6 
    7 # PROJECT
    8 PROJECT(SimulationRuntimeC)
    9 
    10 # Global Variables
    11 IF(NOT OMCTRUNCHOME)
    12   SET(OMCTRUNCHOME ${CMAKE_CURRENT_SOURCE_DIR}/../../../)
    13 ENDIF (NOT OMCTRUNCHOME)
    14 
    15 # OMDEV PATH
    16 IF(NOT OMDEV)
    17   SET(OMDEV $ENV{OMDEV})
    18 ENDIF(NOT OMDEV)
    19 
    20 INCLUDE_DIRECTORIES(${OMDEV}/lib/expat-win32-msvc ${OMDEV}/include/lis ${OMDEV}/include/pthread)
    21 link_directories(${OMDEV}/lib/expat-win32-msvc)
    22 link_directories(${OMDEV}/lib/lapack-win32-msvc)
    23 
    24 IF(MSVC)
    25   SET(Sundials_Path ${OMCTRUNCHOME}/OMCompiler/3rdParty/sundials/build_msvc)
    26 ELSEIF(MSVC)
    27   SET(Sundials_Path ${OMCTRUNCHOME}/OMCompiler/3rdParty/sundials/build)
    28 ENDIF(MSVC)
    29 
    30 MESSAGE(STATUS "Sundials path:")
    31 MESSAGE(STATUS "${Sundials_Path}")
    32 
    33 # SUNDIALS Header
    34 FIND_PATH(SUNDIALS_INCLUDE_DIR sundials/sundials_config.h /usr/include /usr/local/include $ENV{INCLUDE} ${Sundials_Path}/include)
    35 
    36 MESSAGE(STATUS "Sundials include:")
    37 MESSAGE(STATUS "${SUNDIALS_INCLUDE_DIR}")
    38 
    39 # SUNDIALS Libraires
    40 if(MSVC)
    41 FIND_LIBRARY(SUNDIALS_LIBRARY_CVODE      NAMES sundials_cvode      PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
    42 FIND_LIBRARY(SUNDIALS_LIBRARY_IDA        NAMES sundials_ida        PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
    43 FIND_LIBRARY(SUNDIALS_LIBRARY_NVEC       NAMES sundials_nvecserial        PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
    44 FIND_LIBRARY(SUNDIALS_KINSOL       NAMES sundials_kinsol        PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
    45 else(MSVC)
    46 FIND_LIBRARY(SUNDIALS_LIBRARY_CVODE      NAMES libsundials_cvode      PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
    47 FIND_LIBRARY(SUNDIALS_LIBRARY_IDA        NAMES libsundials_ida        PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
    48 FIND_LIBRARY(SUNDIALS_LIBRARY_NVEC       NAMES libsundials_nvecserial        PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
    49 FIND_LIBRARY(SUNDIALS_KINSOL       NAMES libsundials_kinsol        PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
    50 endif(MSVC)
    51 
    52 IF(SUNDIALS_INCLUDE_DIR)
    53 
    54   INCLUDE_DIRECTORIES(${SUNDIALS_INCLUDE_DIR})
    55 
    56   if(SUNDIALS_LIBRARY_CVODE AND
    57    SUNDIALS_LIBRARY_IDA AND
    58    SUNDIALS_LIBRARY_NVEC AND
    59    SUNDIALS_KINSOL)
    60 
    61   SET(SUNDIALS_LIBRARIES ${SUNDIALS_LIBRARY_CVODE} ${SUNDIALS_LIBRARY_IDA} ${SUNDIALS_LIBRARY_NVEC} ${SUNDIALS_KINSOL})
    62 
    63   ENDIF(SUNDIALS_LIBRARY_CVODE AND
    64         SUNDIALS_LIBRARY_IDA AND
    65         SUNDIALS_LIBRARY_NVEC AND
    66         SUNDIALS_KINSOL)
    67 
    68 ENDIF(SUNDIALS_INCLUDE_DIR)
    69 
    70 # Defines for Visual Studio
    71 if(MSVC)
    72   add_definitions(-D_CRT_SECURE_NO_WARNINGS -DNOMINMAX -D_COMPLEX_DEFINED)
    73     # GC shall not use a dll
    74     add_definitions(-DGC_NOT_DLL)
    75 endif(MSVC)
    76 
    77 # includes
    78 INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/)
    79 INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/3rdParty/gc/include)
    80 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
    81 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/linearization)
    82 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/math-support)
    83 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/meta)
    84 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/meta/gc)
    85 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/simulation)
    86 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/optimization)
    87 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/simulation/results)
    88 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/simulation/solver)
    89 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/simulation/solver/initialization)
    90 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/util)
    91 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/dataReconciliation)
    92 
    93 # Subdirectorys
    94 ADD_SUBDIRECTORY(math-support)
    95 ADD_SUBDIRECTORY(meta)
    96 ADD_SUBDIRECTORY(simulation)
    97 ADD_SUBDIRECTORY(util)
    98 ADD_SUBDIRECTORY(fmi)
    99 
    100 # -------------------------------------------------------------
    101 # MACRO definitions
    102 # -------------------------------------------------------------
    103 
    104 # Macros to hide/show cached variables.
    105 # These two macros can be used to "hide" or "show" in the
    106 # list of cached variables various variables and/or options
    107 # that depend on other options.
    108 # Note that once a variable is modified, it will preserve its
    109 # value (hidding it merely makes it internal)
    110 
    111 MACRO(HIDE_VARIABLE var)
    112   IF(DEFINED ${var})
    113     SET(${var} "${${var}}" CACHE INTERNAL "")
    114   ENDIF(DEFINED ${var})
    115 ENDMACRO(HIDE_VARIABLE)
    116 
    117 MACRO(SHOW_VARIABLE var type doc default)
    118   IF(DEFINED ${var})
    119     SET(${var} "${${var}}" CACHE "${type}" "${doc}" FORCE)
    120   ELSE(DEFINED ${var})
    121     SET(${var} "${default}" CACHE "${type}" "${doc}")
    122   ENDIF(DEFINED ${var})
    123 ENDMACRO(SHOW_VARIABLE)
    124 
    125 # MACRO BUILDMODEL
    126 MACRO(BUILDMODEL model mo dir Flags CSRC)
    127 
    128 
    129   # includes
    130   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c)
    131   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/linearization)
    132   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/math-support)
    133   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta)
    134   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta/gc)
    135   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation)
    136   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/results)
    137   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver)
    138   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver/initialization)
    139   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/util)
    140   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/dataReconciliation)
    141 
    142 
    143   # OMDEV PATH
    144   IF(NOT OMDEV)
    145     SET(OMDEV $ENV{OMDEV})
    146   ENDIF(NOT OMDEV)
    147 
    148   INCLUDE_DIRECTORIES(${OMDEV}/lib/expat-win32-msvc)
    149   link_directories(${OMDEV}/lib/expat-win32-msvc)
    150   link_directories(${OMDEV}/lib/lapack-win32-msvc)
    151 
    152   # Variablen fuer openmodelica2sarturis
    153   SET(OMC_CODE   ${CMAKE_CURRENT_BINARY_DIR}/${model}.c
    154                  ${CMAKE_CURRENT_BINARY_DIR}/${model}_functions.c
    155                  ${CMAKE_CURRENT_BINARY_DIR}/${model}_init.txt)
    156   SET(OMC_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/${model}.c
    157   #               ${CMAKE_CURRENT_BINARY_DIR}/${model}_functions.cpp
    158           ${CMAKE_CURRENT_BINARY_DIR}/${model}_functions.h
    159           ${CMAKE_CURRENT_BINARY_DIR}/${model}_records.c)
    160 
    161   # custom command fuer openmodelicacompiler
    162   ADD_CUSTOM_COMMAND(OUTPUT ${OMC_OUTPUT}
    163                      COMMAND ${OMC_DEBUG} ${Flags} +s ${dir}/${mo} Modelica ModelicaServices
    164                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    165                      COMMENT "Erzeuge Code fuer ${model} with ${OMC_DEBUG}")
    166 
    167   # target fuer OM_OUTPUT
    168   ADD_CUSTOM_TARGET(${model}codegen ALL DEPENDS ${OMC_OUTPUT})
    169 
    170   ADD_EXECUTABLE(${model} ${OMC_OUTPUT} ${CSRC})
    171   TARGET_LINK_LIBRARIES(${model} simulation util math-support results solver meta ModelicaExternalC libexpat initialization lapack_win32_MT)
    172 
    173   # Dependencies
    174   ADD_DEPENDENCIES(${model} ${model}codegen)
    175 
    176   IF(MODELS_INSTALL)
    177     INSTALL(TARGETS ${model} RUNTIME DESTINATION ${MODELS_INSTALL_PATH})
    178     INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${model}_init.txt DESTINATION ${MODELS_INSTALL_PATH})
    179   ENDIF(MODELS_INSTALL)
    180 #ENDFOREACH(model ${model_sources})
    181 ENDMACRO(BUILDMODEL)
    182 
    183 # MACRO BUILDMODEL
    184 MACRO(BUILDMODELMOS model mos dir Flags CSRC)
    185 
    186 IF(WIN32)
    187   SET(COPY copy)
    188 else(WIN32)
    189   SET(COPY cp)
    190 endif(WIN32)
    191 
    192 IF(SUNDIALS_INCLUDE_DIR AND
    193    SUNDIALS_LIBRARY_CVODE AND
    194    SUNDIALS_LIBRARY_IDA AND
    195    SUNDIALS_LIBRARY_NVEC AND
    196    SUNDIALS_KINSOL)
    197 
    198   INCLUDE_DIRECTORIES(${SUNDIALS_INCLUDE_DIR})
    199   SET(SUNDIALS_LIBRARIES ${SUNDIALS_LIBRARY_CVODE} ${SUNDIALS_LIBRARY_IDA} ${SUNDIALS_LIBRARY_NVEC} ${SUNDIALS_KINSOL})
    200 
    201 ENDIF(SUNDIALS_INCLUDE_DIR AND
    202       SUNDIALS_LIBRARY_CVODE AND
    203       SUNDIALS_LIBRARY_IDA AND
    204    SUNDIALS_LIBRARY_NVEC AND
    205    SUNDIALS_KINSOL)
    206 
    207   # includes
    208   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c)
    209   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/linearization)
    210   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/math-support)
    211   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta)
    212   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta/gc)
    213   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/ModelicaExternalC)
    214   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation)
    215   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/results)
    216   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver)
    217   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver/initialization)
    218   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/util)
    219   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/dataReconciliation)
    220 
    221   INCLUDE_DIRECTORIES(${dir})
    222 
    223   # OMDEV PATH
    224   IF(NOT OMDEV)
    225     SET(OMDEV $ENV{OMDEV})
    226   ENDIF(NOT OMDEV)
    227 
    228   INCLUDE_DIRECTORIES(${OMDEV}/lib/expat-win32-msvc)
    229   link_directories(${OMDEV}/lib/expat-win32-msvc)
    230   link_directories(${OMDEV}/lib/lapack-win32-msvc)
    231 
    232   # custom command to copy expat.dll file
    233   SET(expat_CODE   ${OMDEV}/lib/expat-win32-msvc/libexpat.dll)
    234   STRING(REGEX REPLACE "/" "\\\\" expat_CODE_NEU ${expat_CODE})
    235   SET(expat_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo/libexpat.dll)
    236   STRING(REGEX REPLACE "/" "\\\\" expat_OUTPUT_NEU ${expat_OUTPUT})
    237 
    238     ADD_CUSTOM_COMMAND(OUTPUT ${expat_OUTPUT}
    239                      COMMAND ${COPY} ${expat_CODE_NEU} ${expat_OUTPUT_NEU}
    240                      WORKING_DIRECTORY ${dir}
    241                      COMMENT "copy file ${expat_CODE_NEU} to ${expat_OUTPUT_NEU}")
    242   # target fuer OM_OUTPUT
    243   ADD_CUSTOM_TARGET(expat${model} ALL DEPENDS ${expat_OUTPUT})
    244 
    245 
    246   SET(lapack_CODE   ${OMDEV}/lib/lapack-win32-msvc/lapack_win32_MT.dll)
    247   STRING(REGEX REPLACE "/" "\\\\" lapack_CODE_NEU ${lapack_CODE})
    248   SET(lapack_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo/lapack_win32_MT.dll)
    249   STRING(REGEX REPLACE "/" "\\\\" lapack_OUTPUT_NEU ${lapack_OUTPUT})
    250 
    251   ADD_CUSTOM_COMMAND(OUTPUT ${lapack_OUTPUT} ${blas_OUTPUT} ${lapack_OUTPUT}
    252                      COMMAND ${COPY} ${lapack_CODE_NEU} ${lapack_OUTPUT_NEU}
    253                      WORKING_DIRECTORY ${dir}
    254                      COMMENT "copy file ${lapack_CODE_NEU} to ${lapack_OUTPUT_NEU}")
    255   # target fuer OM_OUTPUT
    256   ADD_CUSTOM_TARGET(lapack${model} ALL DEPENDS ${lapack_OUTPUT})
    257 
    258 
    259   SET(blas_CODE   ${OMDEV}/lib/lapack-win32-msvc/blas_win32_MT.dll)
    260   STRING(REGEX REPLACE "/" "\\\\" blas_CODE_NEU ${blas_CODE})
    261   SET(blas_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo/blas_win32_MT.dll)
    262   STRING(REGEX REPLACE "/" "\\\\" blas_OUTPUT_NEU ${blas_OUTPUT})
    263 
    264   ADD_CUSTOM_COMMAND(OUTPUT ${blas_OUTPUT} ${blas_OUTPUT} ${lapack_OUTPUT}
    265                      COMMAND ${COPY} ${blas_CODE_NEU} ${blas_OUTPUT_NEU}
    266                      WORKING_DIRECTORY ${dir}
    267                      COMMENT "copy file ${blas_CODE_NEU} to ${blas_OUTPUT_NEU}")
    268   # target fuer OM_OUTPUT
    269   ADD_CUSTOM_TARGET(blas${model} ALL DEPENDS ${blas_OUTPUT})
    270 
    271   SET(OMC_MODELNAME ${model})
    272   # generate model.mos
    273 
    274   # Variablen fuer openmodelica2sarturis
    275   SET(OMC_CODE   ${dir}/${model}.c
    276                  ${dir}/${model}_functions.c
    277                  ${dir}/${model}_init.txt)
    278   SET(OMC_OUTPUT  ${dir}/${model}.c
    279   #                ${dir}/${model}_functions.cpp
    280           ${dir}/${model}_functions.h
    281           ${dir}/${model}_records.c)
    282   # custom command fuer openmodelicacompiler
    283   ADD_CUSTOM_COMMAND(OUTPUT ${OMC_OUTPUT}
    284                      COMMAND ${OMC_DEBUG} ${Flags} ${mos}
    285                      WORKING_DIRECTORY ${dir}
    286                      COMMENT "Generating code for ${model} with ${OMC_DEBUG}")
    287   # target fuer OM_OUTPUT
    288   ADD_CUSTOM_TARGET(${model}codegen ALL DEPENDS ${OMC_OUTPUT})
    289 
    290   ADD_CUSTOM_TARGET(${model}codegencpp ALL DEPENDS ${OMC_OUTPUT})
    291 
    292   ADD_DEFINITIONS(/TP)
    293   set_source_files_properties(${OMC_OUTPUT} PROPERTIES LANGUAGE CXX)
    294   ADD_EXECUTABLE(${model} ${OMC_OUTPUT} ${CSRC})
    295   TARGET_LINK_LIBRARIES(${model} simulation util math-support results solver meta ModelicaExternalC libexpat initialization lapack_win32_MT ${SUNDIALS_LIBRARIES})
    296 
    297   # custom command to copy xml file
    298   SET(XML_CODE   ${dir}/${model}_init.xml)
    299   STRING(REGEX REPLACE "/" "\\\\" XML_CODE_NEU ${XML_CODE})
    300   SET(XML_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo/${model}_init.xml)
    301   STRING(REGEX REPLACE "/" "\\\\" XML_OUTPUT_NEU ${XML_OUTPUT})
    302   ADD_CUSTOM_COMMAND(OUTPUT ${XML_OUTPUT}
    303                      COMMAND ${COPY} ${XML_CODE_NEU} ${XML_OUTPUT_NEU}
    304                      WORKING_DIRECTORY ${dir}
    305                      COMMENT "copy file ${XML_CODE_NEU} to ${XML_OUTPUT_NEU}")
    306   # target fuer OM_OUTPUT
    307   ADD_CUSTOM_TARGET(${model}cp_xml ALL DEPENDS ${XML_OUTPUT})
    308 
    309   # Dependencies
    310   ADD_DEPENDENCIES(${model}cp_xml ${model}codegen expat${model} lapack${model} blas${model})
    311   ADD_DEPENDENCIES(${model} ${model}cp_xml)
    312 
    313 #ENDFOREACH(model ${model_sources})
    314 ENDMACRO(BUILDMODELMOS)
    315 
    316 # MACRO BUILDMODEL
    317 MACRO(BUILDMODELFMU model dir Flags CSRC)
    318 
    319 IF(WIN32)
    320   SET(COPY copy)
    321 else(WIN32)
    322   SET(COPY cp)
    323 endif(WIN32)
    324 
    325 IF(SUNDIALS_INCLUDE_DIR AND
    326    SUNDIALS_LIBRARY_CVODE AND
    327    SUNDIALS_LIBRARY_IDA AND
    328    SUNDIALS_LIBRARY_NVEC AND
    329    SUNDIALS_KINSOL)
    330 
    331   INCLUDE_DIRECTORIES(${SUNDIALS_INCLUDE_DIR})
    332   SET(SUNDIALS_LIBRARIES ${SUNDIALS_LIBRARY_CVODE} ${SUNDIALS_LIBRARY_IDA} ${SUNDIALS_LIBRARY_NVEC} ${SUNDIALS_KINSOL})
    333 
    334 ENDIF(SUNDIALS_INCLUDE_DIR AND
    335       SUNDIALS_LIBRARY_CVODE AND
    336       SUNDIALS_LIBRARY_IDA AND
    337    SUNDIALS_LIBRARY_NVEC AND
    338    SUNDIALS_KINSOL)
    339 
    340   # includes
    341   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c)
    342   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/linearization)
    343   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/math-support)
    344   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta)
    345   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta/gc)
    346   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/ModelicaExternalC)
    347   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation)
    348   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/results)
    349   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver)
    350   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver/initialization)
    351   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/util)
    352   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1)
    353   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/dataReconciliation)
    354 
    355   # OMDEV PATH
    356   IF(NOT OMDEV)
    357     SET(OMDEV $ENV{OMDEV})
    358   ENDIF(NOT OMDEV)
    359 
    360   INCLUDE_DIRECTORIES(${OMDEV}/lib/expat-win32-msvc)
    361   link_directories(${OMDEV}/lib/expat-win32-msvc)
    362   link_directories(${OMDEV}/lib/lapack-win32-msvc)
    363 
    364   SET(OMC_MODELNAME ${model})
    365   SET(OMC_MODELDIR ${dir})
    366   # generate model.mos
    367   FIND_FILE(MOSFILE_IN model_fmu.in PATHS ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c)
    368   CONFIGURE_FILE(${MOSFILE_IN} ${dir}/${model}_FMU.mos)
    369 
    370   # Variablen fuer openmodelica2sarturis
    371   SET(OMC_CODE   ${CMAKE_CURRENT_BINARY_DIR}/${model}.c
    372                  ${CMAKE_CURRENT_BINARY_DIR}/${model}_functions.c
    373                  ${CMAKE_CURRENT_BINARY_DIR}/${model}_init.txt)
    374   SET(OMC_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/${model}.c
    375                   ${CMAKE_CURRENT_BINARY_DIR}/${model}_FMU.c
    376   #               ${CMAKE_CURRENT_BINARY_DIR}/${model}_functions.cpp
    377           ${CMAKE_CURRENT_BINARY_DIR}/${model}_functions.h
    378           ${CMAKE_CURRENT_BINARY_DIR}/${model}_records.c)
    379   # custom command fuer openmodelicacompiler
    380   ADD_CUSTOM_COMMAND(OUTPUT ${OMC_OUTPUT}
    381                      COMMAND ${OMC_DEBUG} ${Flags} ${dir}/${model}_FMU.mos
    382                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    383                      COMMENT "Erzeuge Code fuer ${model} with ${OMC_DEBUG}")
    384   # target fuer OM_OUTPUT
    385   ADD_CUSTOM_TARGET(${model}codegen ALL DEPENDS ${OMC_OUTPUT})
    386 
    387   SET(OMC_FMU_CODE ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1/fmu1_model_interface.h
    388                    ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1/fmiModelFunctions.h
    389            ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1/fmiModelTypes.h)
    390 
    391   ADD_LIBRARY(${model} SHARED ${OMC_OUTPUT} ${CSRC} ${OMC_FMU_CODE})
    392   TARGET_LINK_LIBRARIES(${model} simulation util math-support results solver meta ModelicaExternalC libexpat initialization lapack_win32_MT)
    393 
    394   # Dependencies
    395   ADD_DEPENDENCIES(${model} ${model}codegen)
    396 
    397   IF(MODELS_INSTALL)
    398     INSTALL(TARGETS ${model} ARCHIVE DESTINATION ${MODELS_INSTALL_PATH})
    399     INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${model}_init.txt DESTINATION ${MODELS_INSTALL_PATH})
    400   ENDIF(MODELS_INSTALL)
    401 #ENDFOREACH(model ${model_sources})
    402 ENDMACRO(BUILDMODELFMU)
    403 
    404 # MACRO BUILDMODEL
    405 MACRO(BUILDMODELFMUMOS model mos Flags CSRC)
    406 
    407 IF(WIN32)
    408   SET(COPY copy)
    409 else(WIN32)
    410   SET(COPY cp)
    411 endif(WIN32)
    412 
    413 IF(SUNDIALS_INCLUDE_DIR AND
    414    SUNDIALS_LIBRARY_CVODE AND
    415    SUNDIALS_LIBRARY_IDA AND
    416    SUNDIALS_LIBRARY_NVEC AND
    417    SUNDIALS_KINSOL)
    418 
    419   INCLUDE_DIRECTORIES(${SUNDIALS_INCLUDE_DIR})
    420   SET(SUNDIALS_LIBRARIES ${SUNDIALS_LIBRARY_CVODE} ${SUNDIALS_LIBRARY_IDA} ${SUNDIALS_LIBRARY_NVEC} ${SUNDIALS_KINSOL})
    421 
    422 ENDIF(SUNDIALS_INCLUDE_DIR AND
    423       SUNDIALS_LIBRARY_CVODE AND
    424       SUNDIALS_LIBRARY_IDA AND
    425    SUNDIALS_LIBRARY_NVEC AND
    426    SUNDIALS_KINSOL)
    427 
    428   # includes
    429   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c)
    430   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/linearization)
    431   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/math-support)
    432   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta)
    433   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta/gc)
    434   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/ModelicaExternalC)
    435   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation)
    436   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/results)
    437   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver)
    438   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver/initialization)
    439   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/util)
    440   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export)
    441   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/dataReconciliation)
    442 
    443   # OMDEV PATH
    444   IF(NOT OMDEV)
    445     SET(OMDEV $ENV{OMDEV})
    446   ENDIF(NOT OMDEV)
    447 
    448   INCLUDE_DIRECTORIES(${OMDEV}/lib/expat-win32-msvc)
    449   link_directories(${OMDEV}/lib/expat-win32-msvc)
    450   link_directories(${OMDEV}/lib/lapack-win32-msvc)
    451 
    452   STRING(REPLACE "." "_" FMU_MODELNAME ${model})
    453   # generate model.mos
    454 
    455   # Variablen fuer openmodelica2sarturis
    456   SET(OMC_CODE   ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}.c
    457                  ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}_functions.c
    458                  ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}_init.txt)
    459   SET(OMC_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}.c
    460                   ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}_FMU.c
    461   #               ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}_functions.cpp
    462           ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}_functions.h
    463           ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}_records.c)
    464   # custom command fuer openmodelicacompiler
    465   ADD_CUSTOM_COMMAND(OUTPUT ${OMC_OUTPUT}
    466                      COMMAND ${OMC_DEBUG} ${Flags} ${mos}
    467                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    468                      COMMENT "Erzeuge Code fuer ${model} with ${OMC_DEBUG} in ${CMAKE_CURRENT_BINARY_DIR}")
    469   # target fuer OM_OUTPUT
    470   ADD_CUSTOM_TARGET(${model}codegen ALL DEPENDS ${OMC_OUTPUT})
    471 
    472   SET(OMC_FMU_CODE ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1/fmu1_model_interface.h
    473                    ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1/fmiModelFunctions.h
    474            ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1/fmiModelTypes.h)
    475 
    476   ADD_DEFINITIONS(/TP ${FMU_MODELNAME}.c)
    477   set_source_files_properties(${OMC_OUTPUT} PROPERTIES LANGUAGE CXX)
    478   ADD_LIBRARY(${model} SHARED ${OMC_OUTPUT} ${CSRC} ${OMC_FMU_CODE})
    479   TARGET_LINK_LIBRARIES(${model} simulation util math-support results solver meta ModelicaExternalC libexpat initialization lapack_win32_MT ${SUNDIALS_LIBRARIES})
    480 
    481   # Dependencies
    482   ADD_DEPENDENCIES(${model} ${model}codegen)
    483 
    484   IF(MODELS_INSTALL)
    485     INSTALL(TARGETS ${model} ARCHIVE DESTINATION ${MODELS_INSTALL_PATH})
    486     INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/modelDescription.xml DESTINATION ${MODELS_INSTALL_PATH})
    487   ENDIF(MODELS_INSTALL)
    488 #ENDFOREACH(model ${model_sources})
    489 ENDMACRO(BUILDMODELFMUMOS)
    490 
    491 # Check if example files are to be exported
    492 SHOW_VARIABLE(MODELS_INSTALL BOOL "Install models" ON)
    493 
    494 # If MODELS are to be exported, check where we should install them.
    495 IF(MODELS_INSTALL)
    496 
    497   SHOW_VARIABLE(MODELS_INSTALL_PATH STRING
    498     "Output directory for installing models files" "${CMAKE_INSTALL_PREFIX}")
    499 
    500   IF(NOT MODELS_INSTALL_PATH)
    501     PRINT_WARNING("The example installation path is empty"
    502       "Example installation path was reset to its default value")
    503     SET(MODELS_INSTALL_PATH "${CMAKE_INSTALL_PREFIX}" CACHE STRING
    504       "Output directory for installing example files" FORCE)
    505   ENDIF(NOT MODELS_INSTALL_PATH)
    506 
    507 ELSE(MODELS_INSTALL)
    508    HIDE_VARIABLE(MODELS_INSTALL_PATH)
    509 ENDIF(MODELS_INSTALL)
     1cmake_minimum_required(VERSION 3.14)
     2
     3project(SimulationRuntimeC)
     4
     5
     6file(GLOB OMC_SIMRT_UTIL_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/util/*.c)
     7file(GLOB OMC_SIMRT_UTIL_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/util/*.h)
     8
     9file(GLOB OMC_SIMRT_META_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/meta/*.c)
     10file(GLOB OMC_SIMRT_META_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/meta/*.h)
     11
     12file(GLOB OMC_SIMRT_GC_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/gc/*.c)
     13file(GLOB OMC_SIMRT_GC_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/gc/*.h)
     14
     15file(GLOB OMC_SIMRT_FMI_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/fmi/*.c)
     16file(GLOB OMC_SIMRT_FMI_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/fmi/*.h)
     17
     18
     19set(libOpenModelicaRuntimeC_BUILD_TYPE STATIC CACHE STRING "Type of OpenModelicaRuntimeC to build")
     20omc_add_to_report(libOpenModelicaRuntimeC_BUILD_TYPE)
     21
     22add_library(OpenModelicaRuntimeC STATIC #${libOpenModelicaRuntimeC_BUILD_TYPE}
     23                                    ${OMC_SIMRT_UTIL_SOURCES}
     24                                    ${OMC_SIMRT_META_SOURCES}
     25                                    ${OMC_SIMRT_GC_SOURCES})
     26target_link_libraries(OpenModelicaRuntimeC PUBLIC gc-lib regex dbghelp)
     27target_compile_options(OpenModelicaRuntimeC PRIVATE $<$<CXX_COMPILER_ID:GNU>:-Werror=implicit-function-declaration>)
     28# target_link_libraries(OpenModelicaRuntimeC PUBLIC $<$<CXX_COMPILER_ID:gcc>:dbghelp>)
     29
     30
     31
     32set(libOpenModelicaFMIRuntimeC_BUILD_TYPE SHARED CACHE STRING "Type of OpenModelicaFMIRuntimeC to build")
     33omc_add_to_report(libOpenModelicaFMIRuntimeC_BUILD_TYPE)
     34
     35add_library(OpenModelicaFMIRuntimeC ${libOpenModelicaFMIRuntimeC_BUILD_TYPE}
     36                                    ${OMC_SIMRT_FMI_SOURCES})
     37
     38
     39# FMIL is BAD at using cmake. We need things like this.
     40target_include_directories(OpenModelicaFMIRuntimeC PUBLIC ${FMILibrary_SOURCE_DIR}/install/include)
     41target_link_libraries(OpenModelicaFMIRuntimeC PUBLIC fmilib_shared)
     42target_link_libraries(OpenModelicaFMIRuntimeC PUBLIC OpenModelicaRuntimeC)
     43target_compile_options(OpenModelicaFMIRuntimeC PRIVATE $<$<CXX_COMPILER_ID:GNU>:-Werror=implicit-function-declaration>)
     44
     45
     46
     47
     48# # Global Variables
     49# IF(NOT OMCTRUNCHOME)
     50#   SET(OMCTRUNCHOME ${CMAKE_CURRENT_SOURCE_DIR}/../../../)
     51# ENDIF (NOT OMCTRUNCHOME)
     52
     53# # OMDEV PATH
     54# IF(NOT OMDEV)
     55#   SET(OMDEV $ENV{OMDEV})
     56# ENDIF(NOT OMDEV)
     57
     58# INCLUDE_DIRECTORIES(${OMDEV}/lib/expat-win32-msvc ${OMDEV}/include/lis ${OMDEV}/include/pthread)
     59# link_directories(${OMDEV}/lib/expat-win32-msvc)
     60# link_directories(${OMDEV}/lib/lapack-win32-msvc)
     61
     62# IF(MSVC)
     63#   SET(Sundials_Path ${OMCTRUNCHOME}/OMCompiler/3rdParty/sundials/build_msvc)
     64# ELSEIF(MSVC)
     65#   SET(Sundials_Path ${OMCTRUNCHOME}/OMCompiler/3rdParty/sundials/build)
     66# ENDIF(MSVC)
     67
     68# MESSAGE(STATUS "Sundials path:")
     69# MESSAGE(STATUS "${Sundials_Path}")
     70
     71# # SUNDIALS Header
     72# FIND_PATH(SUNDIALS_INCLUDE_DIR sundials/sundials_config.h /usr/include /usr/local/include $ENV{INCLUDE} ${Sundials_Path}/include)
     73
     74# MESSAGE(STATUS "Sundials include:")
     75# MESSAGE(STATUS "${SUNDIALS_INCLUDE_DIR}")
     76
     77# # SUNDIALS Libraires
     78# if(MSVC)
     79#   FIND_LIBRARY(SUNDIALS_LIBRARY_CVODE      NAMES sundials_cvode      PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
     80#   FIND_LIBRARY(SUNDIALS_LIBRARY_IDA        NAMES sundials_ida        PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
     81#   FIND_LIBRARY(SUNDIALS_LIBRARY_NVEC       NAMES sundials_nvecserial        PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
     82#   FIND_LIBRARY(SUNDIALS_KINSOL       NAMES sundials_kinsol        PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
     83# else(MSVC)
     84#   FIND_LIBRARY(SUNDIALS_LIBRARY_CVODE      NAMES libsundials_cvode      PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
     85#   FIND_LIBRARY(SUNDIALS_LIBRARY_IDA        NAMES libsundials_ida        PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
     86#   FIND_LIBRARY(SUNDIALS_LIBRARY_NVEC       NAMES libsundials_nvecserial        PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
     87#   FIND_LIBRARY(SUNDIALS_KINSOL       NAMES libsundials_kinsol        PATHS /usr/lib /usr/local/lib $ENV{LIB} $(Sundials_Path)/lib)
     88# endif(MSVC)
     89
     90# IF(SUNDIALS_INCLUDE_DIR)
     91
     92#   INCLUDE_DIRECTORIES(${SUNDIALS_INCLUDE_DIR})
     93
     94#   if(SUNDIALS_LIBRARY_CVODE AND
     95#    SUNDIALS_LIBRARY_IDA AND
     96#    SUNDIALS_LIBRARY_NVEC AND
     97#    SUNDIALS_KINSOL)
     98
     99#   SET(SUNDIALS_LIBRARIES ${SUNDIALS_LIBRARY_CVODE} ${SUNDIALS_LIBRARY_IDA} ${SUNDIALS_LIBRARY_NVEC} ${SUNDIALS_KINSOL})
     100
     101#   ENDIF(SUNDIALS_LIBRARY_CVODE AND
     102#         SUNDIALS_LIBRARY_IDA AND
     103#         SUNDIALS_LIBRARY_NVEC AND
     104#         SUNDIALS_KINSOL)
     105
     106# ENDIF(SUNDIALS_INCLUDE_DIR)
     107
     108# # Defines for Visual Studio
     109# if(MSVC)
     110#   add_definitions(-D_CRT_SECURE_NO_WARNINGS -DNOMINMAX -D_COMPLEX_DEFINED)
     111#     # GC shall not use a dll
     112#     add_definitions(-DGC_NOT_DLL)
     113# endif(MSVC)
     114
     115# # includes
     116# INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/)
     117# INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/3rdParty/gc/include)
     118# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
     119# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/linearization)
     120# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/math-support)
     121# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/meta)
     122# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/meta/gc)
     123# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/simulation)
     124# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/optimization)
     125# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/simulation/results)
     126# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/simulation/solver)
     127# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/simulation/solver/initialization)
     128# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/util)
     129# INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/dataReconciliation)
     130
     131# # Subdirectorys
     132# ADD_SUBDIRECTORY(math-support)
     133# ADD_SUBDIRECTORY(meta)
     134# ADD_SUBDIRECTORY(simulation)
     135# ADD_SUBDIRECTORY(util)
     136# ADD_SUBDIRECTORY(fmi)
     137
     138# # -------------------------------------------------------------
     139# # MACRO definitions
     140# # -------------------------------------------------------------
     141
     142# # Macros to hide/show cached variables.
     143# # These two macros can be used to "hide" or "show" in the
     144# # list of cached variables various variables and/or options
     145# # that depend on other options.
     146# # Note that once a variable is modified, it will preserve its
     147# # value (hidding it merely makes it internal)
     148
     149# MACRO(HIDE_VARIABLE var)
     150#   IF(DEFINED ${var})
     151#     SET(${var} "${${var}}" CACHE INTERNAL "")
     152#   ENDIF(DEFINED ${var})
     153# ENDMACRO(HIDE_VARIABLE)
     154
     155# MACRO(SHOW_VARIABLE var type doc default)
     156#   IF(DEFINED ${var})
     157#     SET(${var} "${${var}}" CACHE "${type}" "${doc}" FORCE)
     158#   ELSE(DEFINED ${var})
     159#     SET(${var} "${default}" CACHE "${type}" "${doc}")
     160#   ENDIF(DEFINED ${var})
     161# ENDMACRO(SHOW_VARIABLE)
     162
     163# # MACRO BUILDMODEL
     164# MACRO(BUILDMODEL model mo dir Flags CSRC)
     165
     166
     167#   # includes
     168#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c)
     169#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/linearization)
     170#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/math-support)
     171#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta)
     172#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta/gc)
     173#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation)
     174#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/results)
     175#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver)
     176#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver/initialization)
     177#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/util)
     178#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/dataReconciliation)
     179
     180
     181#   # OMDEV PATH
     182#   IF(NOT OMDEV)
     183#     SET(OMDEV $ENV{OMDEV})
     184#   ENDIF(NOT OMDEV)
     185
     186#   INCLUDE_DIRECTORIES(${OMDEV}/lib/expat-win32-msvc)
     187#   link_directories(${OMDEV}/lib/expat-win32-msvc)
     188#   link_directories(${OMDEV}/lib/lapack-win32-msvc)
     189
     190#   # Variablen fuer openmodelica2sarturis
     191#   SET(OMC_CODE   ${CMAKE_CURRENT_BINARY_DIR}/${model}.c
     192#                  ${CMAKE_CURRENT_BINARY_DIR}/${model}_functions.c
     193#                  ${CMAKE_CURRENT_BINARY_DIR}/${model}_init.txt)
     194#   SET(OMC_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/${model}.c
     195#   #               ${CMAKE_CURRENT_BINARY_DIR}/${model}_functions.cpp
     196#           ${CMAKE_CURRENT_BINARY_DIR}/${model}_functions.h
     197#           ${CMAKE_CURRENT_BINARY_DIR}/${model}_records.c)
     198
     199#   # custom command fuer openmodelicacompiler
     200#   ADD_CUSTOM_COMMAND(OUTPUT ${OMC_OUTPUT}
     201#                      COMMAND ${OMC_DEBUG} ${Flags} +s ${dir}/${mo} Modelica ModelicaServices
     202#                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     203#                      COMMENT "Erzeuge Code fuer ${model} with ${OMC_DEBUG}")
     204
     205#   # target fuer OM_OUTPUT
     206#   ADD_CUSTOM_TARGET(${model}codegen ALL DEPENDS ${OMC_OUTPUT})
     207
     208#   ADD_EXECUTABLE(${model} ${OMC_OUTPUT} ${CSRC})
     209#   TARGET_LINK_LIBRARIES(${model} simulation util math-support results solver meta ModelicaExternalC libexpat initialization lapack_win32_MT)
     210
     211#   # Dependencies
     212#   ADD_DEPENDENCIES(${model} ${model}codegen)
     213
     214#   IF(MODELS_INSTALL)
     215#     INSTALL(TARGETS ${model} RUNTIME DESTINATION ${MODELS_INSTALL_PATH})
     216#     INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${model}_init.txt DESTINATION ${MODELS_INSTALL_PATH})
     217#   ENDIF(MODELS_INSTALL)
     218# #ENDFOREACH(model ${model_sources})
     219# ENDMACRO(BUILDMODEL)
     220
     221# # MACRO BUILDMODEL
     222# MACRO(BUILDMODELMOS model mos dir Flags CSRC)
     223
     224#   IF(WIN32)
     225#     SET(COPY copy)
     226#   else(WIN32)
     227#     SET(COPY cp)
     228#   endif(WIN32)
     229
     230#   IF(SUNDIALS_INCLUDE_DIR AND
     231#     SUNDIALS_LIBRARY_CVODE AND
     232#     SUNDIALS_LIBRARY_IDA AND
     233#     SUNDIALS_LIBRARY_NVEC AND
     234#     SUNDIALS_KINSOL)
     235
     236#     INCLUDE_DIRECTORIES(${SUNDIALS_INCLUDE_DIR})
     237#     SET(SUNDIALS_LIBRARIES ${SUNDIALS_LIBRARY_CVODE} ${SUNDIALS_LIBRARY_IDA} ${SUNDIALS_LIBRARY_NVEC} ${SUNDIALS_KINSOL})
     238
     239#   ENDIF(SUNDIALS_INCLUDE_DIR AND
     240#         SUNDIALS_LIBRARY_CVODE AND
     241#         SUNDIALS_LIBRARY_IDA AND
     242#     SUNDIALS_LIBRARY_NVEC AND
     243#     SUNDIALS_KINSOL)
     244
     245#   # includes
     246#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c)
     247#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/linearization)
     248#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/math-support)
     249#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta)
     250#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta/gc)
     251#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/ModelicaExternalC)
     252#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation)
     253#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/results)
     254#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver)
     255#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver/initialization)
     256#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/util)
     257#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/dataReconciliation)
     258
     259#   INCLUDE_DIRECTORIES(${dir})
     260
     261#   # OMDEV PATH
     262#   IF(NOT OMDEV)
     263#     SET(OMDEV $ENV{OMDEV})
     264#   ENDIF(NOT OMDEV)
     265
     266#   INCLUDE_DIRECTORIES(${OMDEV}/lib/expat-win32-msvc)
     267#   link_directories(${OMDEV}/lib/expat-win32-msvc)
     268#   link_directories(${OMDEV}/lib/lapack-win32-msvc)
     269
     270#   # custom command to copy expat.dll file
     271#   SET(expat_CODE   ${OMDEV}/lib/expat-win32-msvc/libexpat.dll)
     272#   STRING(REGEX REPLACE "/" "\\\\" expat_CODE_NEU ${expat_CODE})
     273#   SET(expat_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo/libexpat.dll)
     274#   STRING(REGEX REPLACE "/" "\\\\" expat_OUTPUT_NEU ${expat_OUTPUT})
     275
     276#     ADD_CUSTOM_COMMAND(OUTPUT ${expat_OUTPUT}
     277#                      COMMAND ${COPY} ${expat_CODE_NEU} ${expat_OUTPUT_NEU}
     278#                      WORKING_DIRECTORY ${dir}
     279#                      COMMENT "copy file ${expat_CODE_NEU} to ${expat_OUTPUT_NEU}")
     280#   # target fuer OM_OUTPUT
     281#   ADD_CUSTOM_TARGET(expat${model} ALL DEPENDS ${expat_OUTPUT})
     282
     283
     284#   SET(lapack_CODE   ${OMDEV}/lib/lapack-win32-msvc/lapack_win32_MT.dll)
     285#   STRING(REGEX REPLACE "/" "\\\\" lapack_CODE_NEU ${lapack_CODE})
     286#   SET(lapack_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo/lapack_win32_MT.dll)
     287#   STRING(REGEX REPLACE "/" "\\\\" lapack_OUTPUT_NEU ${lapack_OUTPUT})
     288
     289#   ADD_CUSTOM_COMMAND(OUTPUT ${lapack_OUTPUT} ${blas_OUTPUT} ${lapack_OUTPUT}
     290#                      COMMAND ${COPY} ${lapack_CODE_NEU} ${lapack_OUTPUT_NEU}
     291#                      WORKING_DIRECTORY ${dir}
     292#                      COMMENT "copy file ${lapack_CODE_NEU} to ${lapack_OUTPUT_NEU}")
     293#   # target fuer OM_OUTPUT
     294#   ADD_CUSTOM_TARGET(lapack${model} ALL DEPENDS ${lapack_OUTPUT})
     295
     296
     297#   SET(blas_CODE   ${OMDEV}/lib/lapack-win32-msvc/blas_win32_MT.dll)
     298#   STRING(REGEX REPLACE "/" "\\\\" blas_CODE_NEU ${blas_CODE})
     299#   SET(blas_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo/blas_win32_MT.dll)
     300#   STRING(REGEX REPLACE "/" "\\\\" blas_OUTPUT_NEU ${blas_OUTPUT})
     301
     302#   ADD_CUSTOM_COMMAND(OUTPUT ${blas_OUTPUT} ${blas_OUTPUT} ${lapack_OUTPUT}
     303#                      COMMAND ${COPY} ${blas_CODE_NEU} ${blas_OUTPUT_NEU}
     304#                      WORKING_DIRECTORY ${dir}
     305#                      COMMENT "copy file ${blas_CODE_NEU} to ${blas_OUTPUT_NEU}")
     306#   # target fuer OM_OUTPUT
     307#   ADD_CUSTOM_TARGET(blas${model} ALL DEPENDS ${blas_OUTPUT})
     308
     309#   SET(OMC_MODELNAME ${model})
     310#   # generate model.mos
     311
     312#   # Variablen fuer openmodelica2sarturis
     313#   SET(OMC_CODE   ${dir}/${model}.c
     314#                  ${dir}/${model}_functions.c
     315#                  ${dir}/${model}_init.txt)
     316#   SET(OMC_OUTPUT  ${dir}/${model}.c
     317#   #                ${dir}/${model}_functions.cpp
     318#           ${dir}/${model}_functions.h
     319#           ${dir}/${model}_records.c)
     320#   # custom command fuer openmodelicacompiler
     321#   ADD_CUSTOM_COMMAND(OUTPUT ${OMC_OUTPUT}
     322#                      COMMAND ${OMC_DEBUG} ${Flags} ${mos}
     323#                      WORKING_DIRECTORY ${dir}
     324#                      COMMENT "Generating code for ${model} with ${OMC_DEBUG}")
     325#   # target fuer OM_OUTPUT
     326#   ADD_CUSTOM_TARGET(${model}codegen ALL DEPENDS ${OMC_OUTPUT})
     327
     328#   ADD_CUSTOM_TARGET(${model}codegencpp ALL DEPENDS ${OMC_OUTPUT})
     329
     330#   ADD_DEFINITIONS(/TP)
     331#   set_source_files_properties(${OMC_OUTPUT} PROPERTIES LANGUAGE CXX)
     332#   ADD_EXECUTABLE(${model} ${OMC_OUTPUT} ${CSRC})
     333#   TARGET_LINK_LIBRARIES(${model} simulation util math-support results solver meta ModelicaExternalC libexpat initialization lapack_win32_MT ${SUNDIALS_LIBRARIES})
     334
     335#   # custom command to copy xml file
     336#   SET(XML_CODE   ${dir}/${model}_init.xml)
     337#   STRING(REGEX REPLACE "/" "\\\\" XML_CODE_NEU ${XML_CODE})
     338#   SET(XML_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/RelWithDebInfo/${model}_init.xml)
     339#   STRING(REGEX REPLACE "/" "\\\\" XML_OUTPUT_NEU ${XML_OUTPUT})
     340#   ADD_CUSTOM_COMMAND(OUTPUT ${XML_OUTPUT}
     341#                      COMMAND ${COPY} ${XML_CODE_NEU} ${XML_OUTPUT_NEU}
     342#                      WORKING_DIRECTORY ${dir}
     343#                      COMMENT "copy file ${XML_CODE_NEU} to ${XML_OUTPUT_NEU}")
     344#   # target fuer OM_OUTPUT
     345#   ADD_CUSTOM_TARGET(${model}cp_xml ALL DEPENDS ${XML_OUTPUT})
     346
     347#   # Dependencies
     348#   ADD_DEPENDENCIES(${model}cp_xml ${model}codegen expat${model} lapack${model} blas${model})
     349#   ADD_DEPENDENCIES(${model} ${model}cp_xml)
     350
     351# #ENDFOREACH(model ${model_sources})
     352# ENDMACRO(BUILDMODELMOS)
     353
     354# # MACRO BUILDMODEL
     355# MACRO(BUILDMODELFMU model dir Flags CSRC)
     356
     357#   IF(WIN32)
     358#     SET(COPY copy)
     359#   else(WIN32)
     360#     SET(COPY cp)
     361#   endif(WIN32)
     362
     363#   IF(SUNDIALS_INCLUDE_DIR AND
     364#     SUNDIALS_LIBRARY_CVODE AND
     365#     SUNDIALS_LIBRARY_IDA AND
     366#     SUNDIALS_LIBRARY_NVEC AND
     367#     SUNDIALS_KINSOL)
     368
     369#     INCLUDE_DIRECTORIES(${SUNDIALS_INCLUDE_DIR})
     370#     SET(SUNDIALS_LIBRARIES ${SUNDIALS_LIBRARY_CVODE} ${SUNDIALS_LIBRARY_IDA} ${SUNDIALS_LIBRARY_NVEC} ${SUNDIALS_KINSOL})
     371
     372#   ENDIF(SUNDIALS_INCLUDE_DIR AND
     373#         SUNDIALS_LIBRARY_CVODE AND
     374#         SUNDIALS_LIBRARY_IDA AND
     375#     SUNDIALS_LIBRARY_NVEC AND
     376#     SUNDIALS_KINSOL)
     377
     378#   # includes
     379#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c)
     380#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/linearization)
     381#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/math-support)
     382#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta)
     383#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta/gc)
     384#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/ModelicaExternalC)
     385#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation)
     386#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/results)
     387#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver)
     388#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver/initialization)
     389#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/util)
     390#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1)
     391#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/dataReconciliation)
     392
     393#   # OMDEV PATH
     394#   IF(NOT OMDEV)
     395#     SET(OMDEV $ENV{OMDEV})
     396#   ENDIF(NOT OMDEV)
     397
     398#   INCLUDE_DIRECTORIES(${OMDEV}/lib/expat-win32-msvc)
     399#   link_directories(${OMDEV}/lib/expat-win32-msvc)
     400#   link_directories(${OMDEV}/lib/lapack-win32-msvc)
     401
     402#   SET(OMC_MODELNAME ${model})
     403#   SET(OMC_MODELDIR ${dir})
     404#   # generate model.mos
     405#   FIND_FILE(MOSFILE_IN model_fmu.in PATHS ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c)
     406#   CONFIGURE_FILE(${MOSFILE_IN} ${dir}/${model}_FMU.mos)
     407
     408#   # Variablen fuer openmodelica2sarturis
     409#   SET(OMC_CODE   ${CMAKE_CURRENT_BINARY_DIR}/${model}.c
     410#                  ${CMAKE_CURRENT_BINARY_DIR}/${model}_functions.c
     411#                  ${CMAKE_CURRENT_BINARY_DIR}/${model}_init.txt)
     412#   SET(OMC_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/${model}.c
     413#                   ${CMAKE_CURRENT_BINARY_DIR}/${model}_FMU.c
     414#   #               ${CMAKE_CURRENT_BINARY_DIR}/${model}_functions.cpp
     415#           ${CMAKE_CURRENT_BINARY_DIR}/${model}_functions.h
     416#           ${CMAKE_CURRENT_BINARY_DIR}/${model}_records.c)
     417#   # custom command fuer openmodelicacompiler
     418#   ADD_CUSTOM_COMMAND(OUTPUT ${OMC_OUTPUT}
     419#                      COMMAND ${OMC_DEBUG} ${Flags} ${dir}/${model}_FMU.mos
     420#                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     421#                      COMMENT "Erzeuge Code fuer ${model} with ${OMC_DEBUG}")
     422#   # target fuer OM_OUTPUT
     423#   ADD_CUSTOM_TARGET(${model}codegen ALL DEPENDS ${OMC_OUTPUT})
     424
     425#   SET(OMC_FMU_CODE ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1/fmu1_model_interface.h
     426#                    ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1/fmiModelFunctions.h
     427#            ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1/fmiModelTypes.h)
     428
     429#   ADD_LIBRARY(${model} SHARED ${OMC_OUTPUT} ${CSRC} ${OMC_FMU_CODE})
     430#   TARGET_LINK_LIBRARIES(${model} simulation util math-support results solver meta ModelicaExternalC libexpat initialization lapack_win32_MT)
     431
     432#   # Dependencies
     433#   ADD_DEPENDENCIES(${model} ${model}codegen)
     434
     435#   IF(MODELS_INSTALL)
     436#     INSTALL(TARGETS ${model} ARCHIVE DESTINATION ${MODELS_INSTALL_PATH})
     437#     INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${model}_init.txt DESTINATION ${MODELS_INSTALL_PATH})
     438#   ENDIF(MODELS_INSTALL)
     439# #ENDFOREACH(model ${model_sources})
     440# ENDMACRO(BUILDMODELFMU)
     441
     442# # MACRO BUILDMODEL
     443# MACRO(BUILDMODELFMUMOS model mos Flags CSRC)
     444
     445#   IF(WIN32)
     446#     SET(COPY copy)
     447#   else(WIN32)
     448#     SET(COPY cp)
     449#   endif(WIN32)
     450
     451#   IF(SUNDIALS_INCLUDE_DIR AND
     452#     SUNDIALS_LIBRARY_CVODE AND
     453#     SUNDIALS_LIBRARY_IDA AND
     454#     SUNDIALS_LIBRARY_NVEC AND
     455#     SUNDIALS_KINSOL)
     456
     457#     INCLUDE_DIRECTORIES(${SUNDIALS_INCLUDE_DIR})
     458#     SET(SUNDIALS_LIBRARIES ${SUNDIALS_LIBRARY_CVODE} ${SUNDIALS_LIBRARY_IDA} ${SUNDIALS_LIBRARY_NVEC} ${SUNDIALS_KINSOL})
     459
     460#   ENDIF(SUNDIALS_INCLUDE_DIR AND
     461#         SUNDIALS_LIBRARY_CVODE AND
     462#         SUNDIALS_LIBRARY_IDA AND
     463#     SUNDIALS_LIBRARY_NVEC AND
     464#     SUNDIALS_KINSOL)
     465
     466#   # includes
     467#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c)
     468#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/linearization)
     469#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/math-support)
     470#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta)
     471#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/meta/gc)
     472#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/ModelicaExternalC)
     473#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation)
     474#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/results)
     475#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver)
     476#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/simulation/solver/initialization)
     477#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/util)
     478#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export)
     479#   INCLUDE_DIRECTORIES(${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/c/dataReconciliation)
     480
     481#   # OMDEV PATH
     482#   IF(NOT OMDEV)
     483#     SET(OMDEV $ENV{OMDEV})
     484#   ENDIF(NOT OMDEV)
     485
     486#   INCLUDE_DIRECTORIES(${OMDEV}/lib/expat-win32-msvc)
     487#   link_directories(${OMDEV}/lib/expat-win32-msvc)
     488#   link_directories(${OMDEV}/lib/lapack-win32-msvc)
     489
     490#   STRING(REPLACE "." "_" FMU_MODELNAME ${model})
     491#   # generate model.mos
     492
     493#   # Variablen fuer openmodelica2sarturis
     494#   SET(OMC_CODE   ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}.c
     495#                  ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}_functions.c
     496#                  ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}_init.txt)
     497#   SET(OMC_OUTPUT  ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}.c
     498#                   ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}_FMU.c
     499#   #               ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}_functions.cpp
     500#           ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}_functions.h
     501#           ${CMAKE_CURRENT_BINARY_DIR}/${FMU_MODELNAME}_records.c)
     502#   # custom command fuer openmodelicacompiler
     503#   ADD_CUSTOM_COMMAND(OUTPUT ${OMC_OUTPUT}
     504#                      COMMAND ${OMC_DEBUG} ${Flags} ${mos}
     505#                      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     506#                      COMMENT "Erzeuge Code fuer ${model} with ${OMC_DEBUG} in ${CMAKE_CURRENT_BINARY_DIR}")
     507#   # target fuer OM_OUTPUT
     508#   ADD_CUSTOM_TARGET(${model}codegen ALL DEPENDS ${OMC_OUTPUT})
     509
     510#   SET(OMC_FMU_CODE ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1/fmu1_model_interface.h
     511#                    ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1/fmiModelFunctions.h
     512#            ${OMCTRUNCHOME}/OMCompiler/SimulationRuntime/fmi/export/fmi1/fmiModelTypes.h)
     513
     514#   ADD_DEFINITIONS(/TP ${FMU_MODELNAME}.c)
     515#   set_source_files_properties(${OMC_OUTPUT} PROPERTIES LANGUAGE CXX)
     516#   ADD_LIBRARY(${model} SHARED ${OMC_OUTPUT} ${CSRC} ${OMC_FMU_CODE})
     517#   TARGET_LINK_LIBRARIES(${model} simulation util math-support results solver meta ModelicaExternalC libexpat initialization lapack_win32_MT ${SUNDIALS_LIBRARIES})
     518
     519#   # Dependencies
     520#   ADD_DEPENDENCIES(${model} ${model}codegen)
     521
     522#   IF(MODELS_INSTALL)
     523#     INSTALL(TARGETS ${model} ARCHIVE DESTINATION ${MODELS_INSTALL_PATH})
     524#     INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/modelDescription.xml DESTINATION ${MODELS_INSTALL_PATH})
     525#   ENDIF(MODELS_INSTALL)
     526# #ENDFOREACH(model ${model_sources})
     527# ENDMACRO(BUILDMODELFMUMOS)
     528
     529# # Check if example files are to be exported
     530# SHOW_VARIABLE(MODELS_INSTALL BOOL "Install models" ON)
     531
     532# # If MODELS are to be exported, check where we should install them.
     533# IF(MODELS_INSTALL)
     534
     535#   SHOW_VARIABLE(MODELS_INSTALL_PATH STRING
     536#     "Output directory for installing models files" "${CMAKE_INSTALL_PREFIX}")
     537
     538#   IF(NOT MODELS_INSTALL_PATH)
     539#     PRINT_WARNING("The example installation path is empty"
     540#       "Example installation path was reset to its default value")
     541#     SET(MODELS_INSTALL_PATH "${CMAKE_INSTALL_PREFIX}" CACHE STRING
     542#       "Output directory for installing example files" FORCE)
     543#   ENDIF(NOT MODELS_INSTALL_PATH)
     544
     545# ELSE(MODELS_INSTALL)
     546#    HIDE_VARIABLE(MODELS_INSTALL_PATH)
     547# ENDIF(MODELS_INSTALL)
  • OMCompiler/SimulationRuntime/c/Makefile.common

    r818a8f24 rdf6240e  
    247247$(SIMOBJSPATH):$(BUILDPATH)/%$(OBJ_EXT): %.cpp linearization/linearize.cpp dataReconciliation/dataReconciliation.cpp $(SIMHFILESPATH) $(COMMON_HEADERS)
    248248  $(MKBUILDDIR)
    249   $(CXX) -c -Ilinearization/ -IdataReconciliation/ $(CXXFLAGS) -o $@ $<
     249  $(CXX) -c $(CXXFLAGS) -o $@ $<
    250250
    251251$(SIMOBJSPATHC):$(BUILDPATH)/%$(OBJ_EXT): %.c $(SIMHFILESPATH) $(COMMON_HEADERS)
  • OMCompiler/SimulationRuntime/c/util/omc_error.h

    r6421631 rdf6240e  
    5757
    5858DLLExport extern void printInfo(FILE *stream, FILE_INFO info);
    59 DLLExport extern void (*omc_assert)(threadData_t*, FILE_INFO, const char*, ...) __attribute__ ((noreturn));
    60 DLLExport extern void (*omc_assert_warning)(FILE_INFO, const char*, ...);
     59// DLLExport extern void (*omc_assert)(threadData_t*, FILE_INFO, const char*, ...) __attribute__ ((noreturn));
     60// DLLExport extern void (*omc_assert_warning)(FILE_INFO, const char*, ...);
    6161DLLExport extern void (*omc_terminate)(FILE_INFO, const char*, ...);
    6262DLLExport extern void (*omc_throw)(threadData_t*) __attribute__ ((noreturn));
     
    6969void reactivateLogging();
    7070void omc_assert_function(threadData_t*,FILE_INFO info, const char *msg, ...) __attribute__ ((noreturn));
     71#define omc_assert(...) omc_assert_function(__VA_ARGS__)
     72
    7173void omc_assert_warning_function(FILE_INFO info,  const char *msg, ...);
     74#define omc_assert_warning(...) omc_assert_warning_function(__VA_ARGS__)
     75
    7276void omc_terminate_function(FILE_INFO info, const char *msg, ...);
    7377void omc_throw_function(threadData_t*) __attribute__ ((noreturn));
Note: See TracChangeset for help on using the changeset viewer.