diff --git a/c_compiler/c_bridge/c_bridge.c b/c_compiler/c_bridge/c_bridge.c index 567078c1e..ebfea82b8 100644 --- a/c_compiler/c_bridge/c_bridge.c +++ b/c_compiler/c_bridge/c_bridge.c @@ -1,4 +1,3 @@ - /// \seealso c_bridge.h for more information on why c_bridge exists and how it is used #include @@ -11,13 +10,11 @@ #include "c_bridge.h" - /// /// Provide the appropriate set of wrapping functions here. Note that they /// just call into the stdlib versions of the functions /// - // stdio.h // there is no way to forward a va_args, so we must dispatch to the version @@ -41,14 +38,626 @@ int snprintf_wrap(char *restrict buffer, size_t bufsz, const char *restrict form return ret; } -// string.h -void *memset_wrap(void *dest, int ch, size_t count) +double fmin_wrap(double x, double y) +{ + return fmin(x, y); +} + +double fmax_wrap(double x, double y) +{ + return fmax(x, y); +} + +FILE *resolve_file(FILE_wrap *file) +{ + if (file == 0) { + return 0; + } + if (file == stderr_wrap) { + return stderr; + } + if (file == stdout_wrap) { + return stdout; + } + if (file == stdin_wrap) { + return stdin; + } + return (FILE*)file->file_ptr; +} + +C_BRIDGE_API int fflush_wrap(FILE_wrap *stream) +{ + if (stream == 0) { + return fflush(0); + } else { + return fflush(resolve_file(stream)); + } +} + +C_BRIDGE_API int fprintf_wrap(FILE_wrap *stream, const char *format, ...) +{ + int ret = 0; + + va_list myargs; + + va_start(myargs, format); + ret = vfprintf(resolve_file(stream), format, myargs); + va_end(myargs); + + return ret; +} + +static FILE_wrap stderr_wrap_impl = {0}; +static FILE_wrap stdout_wrap_impl = {0}; +static FILE_wrap stdin_wrap_impl = {0}; + +FILE_wrap *stderr_wrap = &stderr_wrap_impl; +FILE_wrap *stdout_wrap = &stdout_wrap_impl; +FILE_wrap *stdin_wrap = &stdin_wrap_impl; + +/// Created by: https://docs.google.com/spreadsheets/d/126iyiRC-fspn9O-0QV39JneEetiVtKzm_KmFJkNxPGo/edit?usp=sharing + +/// +/// ctype.h +/// + +#include + +int isalnum_wrap(int c) +{ + return isalnum(c); +} + +int isalpha_wrap(int c) +{ + return isalpha(c); +} + +int isascii_wrap(int c) +{ + return isascii(c); +} + +int isblank_wrap(int c) +{ + return isblank(c); +} + +int iscntrl_wrap(int c) +{ + return iscntrl(c); +} + +int isdigit_wrap(int c) +{ + return isdigit(c); +} + +int isgraph_wrap(int c) +{ + return isgraph(c); +} + +int islower_wrap(int c) +{ + return islower(c); +} + +int isprint_wrap(int c) +{ + return isprint(c); +} + +int ispunct_wrap(int c) +{ + return ispunct(c); +} + +int isspace_wrap(int c) +{ + return isspace(c); +} + +int isupper_wrap(int c) +{ + return isupper(c); +} + +int toascii_wrap(int c) +{ + return toascii(c); +} + +int tolower_wrap(int c) +{ + return tolower(c); +} + +int toupper_wrap(int c) +{ + return toupper(c); +} + +/// +/// math.h +/// + +#include + +double acos_wrap(double x) +{ + return acos(x); +} + +double asin_wrap(double x) +{ + return asin(x); +} + +double atan_wrap(double x) +{ + return atan(x); +} + +double atan2_wrap(double y, double x) +{ + return atan2(y, x); +} + +double ceil_wrap(double x) +{ + return ceil(x); +} + +double cos_wrap(double x) +{ + return cos(x); +} + +double cosh_wrap(double x) +{ + return cosh(x); +} + +double erf_wrap(double x) +{ + return erf(x); +} + +double erfc_wrap(double x) +{ + return erfc(x); +} + +double exp_wrap(double x) +{ + return exp(x); +} + +double fabs_wrap(double x) +{ + return fabs(x); +} + +double floor_wrap(double x) +{ + return floor(x); +} + +double fmod_wrap(double x, double y) +{ + return fmod(x, y); +} + +double frexp_wrap(double x, int *expptr) +{ + return frexp(x, expptr); +} + +double gamma_wrap(double x) +{ + return gamma(x); +} + +double hypot_wrap(double side1, double side2) +{ + return hypot(side1, side2); +} + +double j0_wrap(double x) +{ + return j0(x); +} + +double j1_wrap(double x) +{ + return j1(x); +} + +double jn_wrap(int n, double x) +{ + return jn(n, x); +} + +double ldexp_wrap(double x, int exp) +{ + return ldexp(x, exp); +} + +double log_wrap(double x) +{ + return log(x); +} + +double log10_wrap(double x) +{ + return log10(x); +} + +double modf_wrap(double x, double *intptr) +{ + return modf(x, intptr); +} + +double nextafter_wrap(double x, double y) +{ + return nextafter(x, y); +} + +long double nextafterl_wrap(long double x, long double y) +{ + return nextafterl(x, y); +} + +double nexttoward_wrap(double x, long double y) +{ + return nexttoward(x, y); +} + +long double nexttowardl_wrap(long double x, long double y) +{ + return nexttowardl(x, y); +} + +double pow_wrap(double x, double y) +{ + return pow(x, y); +} + +double sin_wrap(double x) +{ + return sin(x); +} + +double sinh_wrap(double x) +{ + return sinh(x); +} + +double sqrt_wrap(double x) +{ + return sqrt(x); +} + +double tan_wrap(double x) +{ + return tan(x); +} + +double tanh_wrap(double x) +{ + return tanh(x); +} + +double y0_wrap(double x) +{ + return y0(x); +} + +double y1_wrap(double x) +{ + return y1(x); +} + +double yn_wrap(int n, double x) +{ + return yn(n, x); +} + +/// +/// stdio.h +/// + +#include + +int getchar_wrap(void) +{ + return getchar(); +} + +void perror_wrap(const char *string) +{ + return perror(string); +} +/* +int printf_wrap(const char *format_string, ...){ + return printf(format_string, ...); +}*/ + +int putchar_wrap(int c) +{ + return putchar(c); +} + +int puts_wrap(const char *string) +{ + return puts(string); +} + +int remove_wrap(const char *filename) +{ + return remove(filename); +} + +int rename_wrap(const char *oldname, const char *newname) +{ + return rename(oldname, newname); +} +/* +int scanf_wrap(const char *format_string, ...){ + return scanf(format_string, ...); +}*/ +/* +int snprintf_wrap(char *outbuf, size_t n, const char*, ...){ + return snprintf(outbuf,n,char*, ...); +}*/ +/* +int sprintf_wrap(char *buffer, const char *format_string, ...){ + return sprintf(buffer,format_string, ...); +}*/ +/* +int sscanf_wrap(const char *buffer, const char *format, ...){ + return sscanf(buffer,format, ...); +}*/ + +char *tmpnam_wrap(char *string) +{ + return tmpnam(string); +} + +/// +/// stdlib.h +/// + +#include + +void abort_wrap(void) +{ + return abort(); +} + +int abs_wrap(int n) +{ + return abs(n); +} + +double atof_wrap(const char *string) +{ + return atof(string); +} + +int atoi_wrap(const char *string) +{ + return atoi(string); +} + +long int atol_wrap(const char *string) +{ + return atol(string); +} + +void *calloc_wrap(size_t num, size_t size) +{ + return calloc(num, size); +} + +void exit_wrap(int status) +{ + return exit(status); +} + +void free_wrap(void *ptr) +{ + return free(ptr); +} + +char *getenv_wrap(const char *varname) +{ + return getenv(varname); +} + +long int labs_wrap(long int n) +{ + return labs(n); +} + +ldiv_t ldiv_wrap(long int numerator, long int denominator) +{ + return ldiv(numerator, denominator); +} + +void *malloc_wrap(size_t size) +{ + return malloc(size); +} + +int mblen_wrap(const char *string, size_t n) +{ + return mblen(string, n); +} + +int rand_wrap(void) +{ + return rand(); +} + +void *realloc_wrap(void *ptr, size_t size) +{ + return realloc(ptr, size); +} + +void srand_wrap(unsigned int seed) +{ + return srand(seed); +} + +double strtod_wrap(const char *nptr, char **endptr) +{ + return strtod(nptr, endptr); +} + +float strtof_wrap(const char *nptr, char **endptr) +{ + return strtof(nptr, endptr); +} + +long int strtol_wrap(const char *nptr, char **endptr, int base) +{ + return strtol(nptr, endptr, base); +} + +long double strtold_wrap(const char *nptr, char **endptr) +{ + return strtold(nptr, endptr); +} + +unsigned long int strtoul_wrap(const char *string1, char **string2, int base) +{ + return strtoul(string1, string2, base); +} + +int system_wrap(const char *string) +{ + return system(string); +} + +/// +/// string.h +/// + +#include + +void *memchr_wrap(const void *buf, int c, size_t count) +{ + return memchr(buf, c, count); +} + +int memcmp_wrap(const void *buf1, const void *buf2, size_t count) +{ + return memcmp(buf1, buf2, count); +} + +void *memcpy_wrap(void *dest, const void *src, size_t count) +{ + return memcpy(dest, src, count); +} + +void *memmove_wrap(void *dest, const void *src, size_t count) +{ + return memmove(dest, src, count); +} + +void *memset_wrap(void *dest, int c, size_t count) +{ + return memset(dest, c, count); +} + +char *strcat_wrap(char *string1, const char *string2) +{ + return strcat(string1, string2); +} + +char *strchr_wrap(const char *string, int c) +{ + return strchr(string, c); +} + +int strcmp_wrap(const char *string1, const char *string2) +{ + return strcmp(string1, string2); +} + +int strcoll_wrap(const char *string1, const char *string2) +{ + return strcoll(string1, string2); +} + +char *strcpy_wrap(char *string1, const char *string2) +{ + return strcpy(string1, string2); +} + +size_t strcspn_wrap(const char *string1, const char *string2) +{ + return strcspn(string1, string2); +} + +char *strerror_wrap(int errnum) +{ + return strerror(errnum); +} + +size_t strlen_wrap(const char *string) +{ + return strlen(string); +} + +char *strncat_wrap(char *string1, const char *string2, size_t count) +{ + return strncat(string1, string2, count); +} + +int strncmp_wrap(const char *string1, const char *string2, size_t count) +{ + return strncmp(string1, string2, count); +} + +char *strncpy_wrap(char *string1, const char *string2, size_t count) +{ + return strncpy(string1, string2, count); +} + +char *strpbrk_wrap(const char *string1, const char *string2) +{ + return strpbrk(string1, string2); +} + +char *strrchr_wrap(const char *string, int c) +{ + return strrchr(string, c); +} + +size_t strspn_wrap(const char *string1, const char *string2) +{ + return strspn(string1, string2); +} + +char *strstr_wrap(const char *string1, const char *string2) +{ + return strstr(string1, string2); +} + +char *strtok_wrap(char *string1, const char *string2) +{ + return strtok(string1, string2); +} + +char *strtok_r_wrap(char *string, const char *seps, char **lasts) { - return memset(dest, ch, count); + return strtok_r(string, seps, lasts); } -// math.h -double cos_wrap(double input) +size_t strxfrm_wrap(char *string1, const char *string2, size_t count) { - return cos(input); + return strxfrm(string1, string2, count); } diff --git a/c_compiler/c_bridge/c_bridge.h b/c_compiler/c_bridge/c_bridge.h index b041c5c7c..3bbdf5a54 100644 --- a/c_compiler/c_bridge/c_bridge.h +++ b/c_compiler/c_bridge/c_bridge.h @@ -85,26 +85,279 @@ typedef unsigned long long size_t; // stdio.h C_BRIDGE_API int snprintf_wrap(char *restrict buffer, size_t bufsz, const char *restrict format, ...); +C_BRIDGE_API double fmin_wrap(double x, double y); +C_BRIDGE_API double fmax_wrap(double x, double y); -// string.h -C_BRIDGE_API void *memset_wrap(void *dest, int ch, size_t count); +typedef struct C_BRIDGE_API FILE_wrap +{ + void *file_ptr; +} FILE_wrap; -// math.h -C_BRIDGE_API double cos_wrap(double); +C_BRIDGE_API int fflush_wrap(FILE_wrap *stream); +C_BRIDGE_API int fprintf_wrap(FILE_wrap *stream, const char *format, ...); + +extern FILE_wrap *stderr_wrap; +extern FILE_wrap *stdout_wrap; +extern FILE_wrap *stdin_wrap; /// if C_BRIDGE_IMPL is *not* defined (when this library is used, not being compiled) /// then we need to rename all of the functions we provide #ifndef C_BRIDGE_IMPL -// stdio.h #define snprintf snprintf_wrap +#define fmin fmin_wrap +#define fmax fmax_wrap +#define stderr stderr_wrap +#define stdout stdout_wrap +#define stdin stdin_wrap +#define FILE FILE_wrap +#define fflush fflush_wrap +#define fprintf fprintf_wrap -// string.h -#define memset memset_wrap +/// Created by: https://docs.google.com/spreadsheets/d/126iyiRC-fspn9O-0QV39JneEetiVtKzm_KmFJkNxPGo/edit?usp=sharing + +/// +/// ctype.h +/// + +C_BRIDGE_API int isalnum_wrap(int c); +C_BRIDGE_API int isalpha_wrap(int c); +C_BRIDGE_API int isascii_wrap(int c); +C_BRIDGE_API int isblank_wrap(int c); +C_BRIDGE_API int iscntrl_wrap(int c); +C_BRIDGE_API int isdigit_wrap(int c); +C_BRIDGE_API int isgraph_wrap(int c); +C_BRIDGE_API int islower_wrap(int c); +C_BRIDGE_API int isprint_wrap(int c); +C_BRIDGE_API int ispunct_wrap(int c); +C_BRIDGE_API int isspace_wrap(int c); +C_BRIDGE_API int isupper_wrap(int c); +C_BRIDGE_API int toascii_wrap(int c); +C_BRIDGE_API int tolower_wrap(int c); +C_BRIDGE_API int toupper_wrap(int c); + +/// +/// math.h +/// + +C_BRIDGE_API double acos_wrap(double x); +C_BRIDGE_API double asin_wrap(double x); +C_BRIDGE_API double atan_wrap(double x); +C_BRIDGE_API double atan2_wrap(double y, double x); +C_BRIDGE_API double ceil_wrap(double x); +C_BRIDGE_API double cos_wrap(double x); +C_BRIDGE_API double cosh_wrap(double x); +C_BRIDGE_API double erf_wrap(double x); +C_BRIDGE_API double erfc_wrap(double x); +C_BRIDGE_API double exp_wrap(double x); +C_BRIDGE_API double fabs_wrap(double x); +C_BRIDGE_API double floor_wrap(double x); +C_BRIDGE_API double fmod_wrap(double x, double y); +C_BRIDGE_API double frexp_wrap(double x, int *expptr); +C_BRIDGE_API double gamma_wrap(double x); +C_BRIDGE_API double hypot_wrap(double side1, double side2); +C_BRIDGE_API double j0_wrap(double x); +C_BRIDGE_API double j1_wrap(double x); +C_BRIDGE_API double jn_wrap(int n, double x); +C_BRIDGE_API double ldexp_wrap(double x, int exp); +C_BRIDGE_API double log_wrap(double x); +C_BRIDGE_API double log10_wrap(double x); +C_BRIDGE_API double modf_wrap(double x, double *intptr); +C_BRIDGE_API double nextafter_wrap(double x, double y); +C_BRIDGE_API long double nextafterl_wrap(long double x, long double y); +C_BRIDGE_API double nexttoward_wrap(double x, long double y); +C_BRIDGE_API long double nexttowardl_wrap(long double x, long double y); +C_BRIDGE_API double pow_wrap(double x, double y); +C_BRIDGE_API double sin_wrap(double x); +C_BRIDGE_API double sinh_wrap(double x); +C_BRIDGE_API double sqrt_wrap(double x); +C_BRIDGE_API double tan_wrap(double x); +C_BRIDGE_API double tanh_wrap(double x); +C_BRIDGE_API double y0_wrap(double x); +C_BRIDGE_API double y1_wrap(double x); +C_BRIDGE_API double yn_wrap(int n, double x); + +/// +/// stdio.h +/// + +C_BRIDGE_API int getchar_wrap(void); +C_BRIDGE_API void perror_wrap(const char *string); +// C_BRIDGE_API int printf_wrap(const char *format_string, ...); +C_BRIDGE_API int putchar_wrap(int c); +C_BRIDGE_API int puts_wrap(const char *string); +C_BRIDGE_API int remove_wrap(const char *filename); +C_BRIDGE_API int rename_wrap(const char *oldname, const char *newname); +// C_BRIDGE_API int scanf_wrap(const char *format_string, ...); +// C_BRIDGE_API int snprintf_wrap(char *outbuf, size_t n, const char*, ...); +// C_BRIDGE_API int sprintf_wrap(char *buffer, const char *format_string, ...); +// C_BRIDGE_API int sscanf_wrap(const char *buffer, const char *format, ...); +C_BRIDGE_API char *tmpnam_wrap(char *string); + +/// +/// stdlib.h +/// -// math.h +C_BRIDGE_API void abort_wrap(void); +C_BRIDGE_API int abs_wrap(int n); +C_BRIDGE_API double atof_wrap(const char *string); +C_BRIDGE_API int atoi_wrap(const char *string); +C_BRIDGE_API long int atol_wrap(const char *string); +C_BRIDGE_API void *calloc_wrap(size_t num, size_t size); +C_BRIDGE_API void exit_wrap(int status); +C_BRIDGE_API void free_wrap(void *ptr); +C_BRIDGE_API char *getenv_wrap(const char *varname); +C_BRIDGE_API long int labs_wrap(long int n); +C_BRIDGE_API ldiv_t ldiv_wrap(long int numerator, long int denominator); +C_BRIDGE_API void *malloc_wrap(size_t size); +C_BRIDGE_API int mblen_wrap(const char *string, size_t n); +C_BRIDGE_API int rand_wrap(void); +C_BRIDGE_API void *realloc_wrap(void *ptr, size_t size); +C_BRIDGE_API void srand_wrap(unsigned int seed); +C_BRIDGE_API double strtod_wrap(const char *nptr, char **endptr); +C_BRIDGE_API float strtof_wrap(const char *nptr, char **endptr); +C_BRIDGE_API long int strtol_wrap(const char *nptr, char **endptr, int base); +C_BRIDGE_API long double strtold_wrap(const char *nptr, char **endptr); +C_BRIDGE_API unsigned long int strtoul_wrap(const char *string1, char **string2, int base); +C_BRIDGE_API int system_wrap(const char *string); + +/// +/// string.h +/// + +C_BRIDGE_API void *memchr_wrap(const void *buf, int c, size_t count); +C_BRIDGE_API int memcmp_wrap(const void *buf1, const void *buf2, size_t count); +C_BRIDGE_API void *memcpy_wrap(void *dest, const void *src, size_t count); +C_BRIDGE_API void *memmove_wrap(void *dest, const void *src, size_t count); +C_BRIDGE_API void *memset_wrap(void *dest, int c, size_t count); +C_BRIDGE_API char *strcat_wrap(char *string1, const char *string2); +C_BRIDGE_API char *strchr_wrap(const char *string, int c); +C_BRIDGE_API int strcmp_wrap(const char *string1, const char *string2); +C_BRIDGE_API int strcoll_wrap(const char *string1, const char *string2); +C_BRIDGE_API char *strcpy_wrap(char *string1, const char *string2); +C_BRIDGE_API size_t strcspn_wrap(const char *string1, const char *string2); +C_BRIDGE_API char *strerror_wrap(int errnum); +C_BRIDGE_API size_t strlen_wrap(const char *string); +C_BRIDGE_API char *strncat_wrap(char *string1, const char *string2, size_t count); +C_BRIDGE_API int strncmp_wrap(const char *string1, const char *string2, size_t count); +C_BRIDGE_API char *strncpy_wrap(char *string1, const char *string2, size_t count); +C_BRIDGE_API char *strpbrk_wrap(const char *string1, const char *string2); +C_BRIDGE_API char *strrchr_wrap(const char *string, int c); +C_BRIDGE_API size_t strspn_wrap(const char *string1, const char *string2); +C_BRIDGE_API char *strstr_wrap(const char *string1, const char *string2); +C_BRIDGE_API char *strtok_wrap(char *string1, const char *string2); +C_BRIDGE_API char *strtok_r_wrap(char *string, const char *seps, char **lasts); +C_BRIDGE_API size_t strxfrm_wrap(char *string1, const char *string2, size_t count); + +#define isalnum isalnum_wrap +#define isalpha isalpha_wrap +#define isascii isascii_wrap +#define isblank isblank_wrap +#define iscntrl iscntrl_wrap +#define isdigit isdigit_wrap +#define isgraph isgraph_wrap +#define islower islower_wrap +#define isprint isprint_wrap +#define ispunct ispunct_wrap +#define isspace isspace_wrap +#define isupper isupper_wrap +#define toascii toascii_wrap +#define tolower tolower_wrap +#define toupper toupper_wrap +#define acos acos_wrap +#define asin asin_wrap +#define atan atan_wrap +#define atan2 atan2_wrap +#define ceil ceil_wrap #define cos cos_wrap +#define cosh cosh_wrap +#define erf erf_wrap +#define erfc erfc_wrap +#define exp exp_wrap +#define fabs fabs_wrap +#define floor floor_wrap +#define fmod fmod_wrap +#define frexp frexp_wrap +#define gamma gamma_wrap +#define hypot hypot_wrap +#define j0 j0_wrap +#define j1 j1_wrap +#define jn jn_wrap +#define ldexp ldexp_wrap +#define log log_wrap +#define log10 log10_wrap +#define modf modf_wrap +#define nextafter nextafter_wrap +#define nextafterl nextafterl_wrap +#define nexttoward nexttoward_wrap +#define nexttowardl nexttowardl_wrap +#define pow pow_wrap +#define sin sin_wrap +#define sinh sinh_wrap +#define sqrt sqrt_wrap +#define tan tan_wrap +#define tanh tanh_wrap +#define y0 y0_wrap +#define y1 y1_wrap +#define yn yn_wrap +#define getchar getchar_wrap +#define perror perror_wrap +// #define printf printf_wrap +#define putchar putchar_wrap +#define puts puts_wrap +#define remove remove_wrap +#define rename rename_wrap +// #define scanf scanf_wrap +// #define snprintf snprintf_wrap +// #define sprintf sprintf_wrap +// #define sscanf sscanf_wrap +#define tmpnam tmpnam_wrap +#define abort abort_wrap +#define abs abs_wrap +#define atof atof_wrap +#define atoi atoi_wrap +#define atol atol_wrap +#define calloc calloc_wrap +#define exit exit_wrap +#define free free_wrap +#define getenv getenv_wrap +#define labs labs_wrap +#define ldiv ldiv_wrap +#define malloc malloc_wrap +#define mblen mblen_wrap +#define rand rand_wrap +#define realloc realloc_wrap +#define srand srand_wrap +#define strtod strtod_wrap +#define strtof strtof_wrap +#define strtol strtol_wrap +#define strtold strtold_wrap +#define strtoul strtoul_wrap +#define system system_wrap +#define memchr memchr_wrap +#define memcmp memcmp_wrap +#define memcpy memcpy_wrap +#define memmove memmove_wrap +#define memset memset_wrap +#define strcat strcat_wrap +#define strchr strchr_wrap +#define strcmp strcmp_wrap +#define strcoll strcoll_wrap +#define strcpy strcpy_wrap +#define strcspn strcspn_wrap +#define strerror strerror_wrap +#define strlen strlen_wrap +#define strncat strncat_wrap +#define strncmp strncmp_wrap +#define strncpy strncpy_wrap +#define strpbrk strpbrk_wrap +#define strrchr strrchr_wrap +#define strspn strspn_wrap +#define strstr strstr_wrap +#define strtok strtok_wrap +#define strtok_r strtok_r_wrap +#define strxfrm strxfrm_wrap #endif diff --git a/c_compiler/c_bridge/notes.md b/c_compiler/c_bridge/notes.md new file mode 100644 index 000000000..b8373ca63 --- /dev/null +++ b/c_compiler/c_bridge/notes.md @@ -0,0 +1,68 @@ +# Functions called from an example OpenModelica model + + +C Standard Library + +* `assert` +* `calloc` *implemented* +* `fprintf` *implemented* +* `fflush` *implemented* +* `stderr` *implemented* +* `fmax` *implemented* +* `fmin` *implemented* +* `free` *implemented* +* `sizeof` *builtin* + +Presumed Macros + +* `max` +* `min` +* `EXIT` + +Open Modelica Macros / Functions + +* `MMC_CATCH_STACK` +* `MMC_CATCH_TOP` +* `MMC_DEFSTRINGLIT` +* `MMC_DEFSTRUCTLIT` +* `MMC_ELSE` +* `MMC_INIT` +* `MMC_REFSTRINGLIT` +* `MMC_REFSTRUCTLIT` +* `MMC_STRINGDATA` +* `MMC_TRY_STACK` +* `MMC_TRY_TOP` +* `DIVISION_SIM` +* `initial` +* `modelica_real_to_modelica_string_format` +* `omc_assert_warning` +* `omc_assert_warning_withEquationIndexes` +* `OpenModelica_updateUriMapping` +* `rt_accumulate` +* `rt_tick` +* `rml_execution_failed` + +Unknown + +* `assertStreamPrint` +* `functionAlg_system0` +* `Greater` +* `GreaterEq` +* `infoStreamPrint` +* `infoStreamPrintWithEquationIndexes` +* `LessZC` +* `messageClose` +* `printStacktraceMessages` +* `stringAppend` +* `throwStreamPrint` +* `relationhysteresis` +* `omp_get_max_threads` +* `String` + +Script Functions + +* `der` +* `zeros` + + + diff --git a/cli/main.cpp b/cli/main.cpp index e16082e34..08393ab2a 100644 --- a/cli/main.cpp +++ b/cli/main.cpp @@ -39,135 +39,156 @@ void handle_eptr(std::exception_ptr eptr) } } -int main(int argc, const char *argv[]) // NOLINT exception may escape from main +void main_command(CLI::App &app, [[maybe_unused]] nlohmann::json &user_input) { - CLI::App app{"Spawn of EnergyPlus"}; + app.set_help_all_flag("-H, --expanded-help", "Show expanded help for all subcommands"); - spdlog::cfg::load_env_levels(); + auto print_version = []() { std::cout << "Spawn-" << spawn::version_string() << std::endl; }; + app.add_flag_callback("-v,--version", print_version, "Print version info and exit"); - auto versionOption = app.add_flag("-v,--version", "Print version info and exit"); - auto verboseOption = app.add_flag("--verbose", "Use verbose logging"); - - std::string jsonInput = "spawn.json"; - auto createOption = app.add_option("-c,--create", jsonInput, "Create a standalone FMU based on json input", true); - - std::string outputPath; - auto outputPathOption = app.add_option("--output-path", - outputPath, - "Full path including filename and extension where the fmu should be placed. " - "Intermediate directories will be created if necessary", - true); - outputPathOption->needs(createOption); - - std::string outputDir; - auto outputDirOption = - app.add_option("--output-dir", - outputDir, - "Directory where the fmu should be placed. This path will be created if necessary", - true); - outputDirOption->needs(createOption); - outputDirOption->excludes(outputPathOption); - outputPathOption->excludes(outputDirOption); - - bool nozip = false; - auto zipOption = app.add_flag("--no-zip", nozip, "Stage FMU files on disk without creating a zip archive"); - zipOption->needs(createOption); - - bool nocompress = false; - auto compressOption = app.add_flag( - "--no-compress", - nocompress, - "Skip compressing the contents of the fmu zip archive. An uncompressed zip archive will be created instead"); - compressOption->needs(createOption); - - auto outputVarsOption = - app.add_flag("--output-vars", "Report the EnergyPlus output variables supported by this version of Spawn"); - - auto actuatorsOption = - app.add_flag("--actuators", "Report the EnergyPlus actuators supported by this version of Spawn"); + auto make_verbose = []() {}; + app.add_flag_callback("--verbose", make_verbose, "Use verbose logging"); +} +void modelica_command(CLI::App &app, nlohmann::json &user_input) +{ #if defined ENABLE_MODELICA_COMPILER - auto modelicaCommand = app.add_subcommand("modelica", "Subcommand for Modelica operations"); - std::string moinput; - auto createModelicaFMUOption = - modelicaCommand->add_option("--create-fmu", moinput, "Compile Modelica model to FMU format", true); + auto modelica_command = app.add_subcommand("modelica", "Subcommand for Modelica operations"); + modelica_command->add_option( + "--modelica-path", user_input["modelica"]["modelica-path"], "Additional Modelica search paths"); + modelica_command->add_flag("--optimica", user_input["modelica"]["optimica"], "Use Optimica compiler"); - std::vector modelicaPaths; - auto modelicaPathsOption = - modelicaCommand->add_option("--modelica-path", modelicaPaths, "Additional Modelica search paths"); - modelicaPathsOption->needs(createModelicaFMUOption); + auto create_fmu_command = modelica_command->add_subcommand("create-fmu", "Compile Modelica model to FMU format"); + create_fmu_command->add_option("Model", user_input["modelica"]["create-fmu"]["model"], "Modelica model path"); + create_fmu_command->add_option("--fmu-type", user_input["modelica"]["create-fmu"]["fmu-type"], "FMU Type, CS or ME"); - bool optimica = false; - auto optimicaOption = modelicaCommand->add_flag("--optimica", optimica, "Use Optimica compiler"); - optimicaOption->needs(createModelicaFMUOption); + create_fmu_command->callback( + [&user_input]() { std::cout << "create-fmu callback input: " << user_input << std::endl; }); +#endif +} - std::string fmuType = toString(spawn::fmu::FMUType::CS); - auto fmuTypeOption = modelicaCommand->add_option("--fmu-type", fmuType, "FMU Type, CS or ME"); - fmuTypeOption->needs(createModelicaFMUOption); +void energyplus_command(CLI::App &app, nlohmann::json &user_input) +{ + auto energyplus_command = app.add_subcommand("energyplus", "Subcommand for EnergyPlus related operations"); + energyplus_command->add_flag("-v, --version", "Print version info about the embedded EnergyPlus software"); - auto makeOption = app.add_flag("-f", "compile a Modelica external function, acting like 'make'"); -#endif + auto fmu_command = energyplus_command->add_subcommand("create-fmu", "Create a standalone FMU based on json input"); - auto fmuCommand = app.add_subcommand("fmu", "Subcommand for FMU related operations"); - std::string fmuinput; - double fmustart = 0.0; - double fmustop = 60.0; - double fmustep = 0.001; - auto fmuSimulateOption = fmuCommand->add_option("--simulate", fmuinput, "Simulate the FMU located at the given path"); - auto fmuStartOption = fmuCommand->add_option("--start", fmustart, "Simulation start time"); - fmuStartOption->needs(fmuSimulateOption); - auto fmuStopOption = fmuCommand->add_option("--stop", fmustop, "Simulation stop time"); - fmuStopOption->needs(fmuSimulateOption); - auto fmuStepOption = fmuCommand->add_option("--step", fmustep, "Simulation step size"); - fmuStepOption->needs(fmuSimulateOption); + auto &fmu_input_path = user_input["energyplus"]["create-fmu"]["input"]; + fmu_command->add_option("INPUT_FILE_PATH", fmu_input_path, "Spawn input file"); - auto energyplusCommand = app.add_subcommand("energyplus", "Subcommand for EnergyPlus related operations"); - auto energyplusVersionOption = - energyplusCommand->add_flag("-v, --version", "Print version info about the embedded EnergyPlus software"); + auto &fmu_output_path = user_input["energyplus"]["create-fmu"]["output-path"]; + constexpr auto output_path_doc = "Full path including filename and extension where the fmu should be placed"; + fmu_command->add_option("--output-path", fmu_output_path, output_path_doc); - app.allow_extras(); + auto &fmu_output_dir = user_input["energyplus"]["create-fmu"]["output-dir"]; + constexpr auto output_dir_doc = "Directory where the fmu should be placed. This path will be created if necessary"; + fmu_command->add_option("--output-dir", fmu_output_dir, output_dir_doc); - CLI11_PARSE(app, argc, argv); + auto &no_zip = user_input["energyplus"]["create-fmu"]["no-zip"]; + constexpr auto no_zip_doc = "Stage FMU files on disk without creating a zip archive"; + fmu_command->add_flag("--no-zip", no_zip, no_zip_doc); - std::exception_ptr eptr; + auto &no_compress = user_input["energyplus"]["create-fmu"]["no-compress"]; + constexpr auto no_compress_doc = + "Skip compressing the contents of the fmu zip archive. An uncompressed zip archive will be created instead"; + fmu_command->add_flag("--no-compress", no_compress, no_compress_doc); - try { - if (*verboseOption) { - spdlog::set_level(spdlog::level::trace); - } else { - spdlog::set_pattern("%v"); - spdlog::set_level(spdlog::level::info); - } + constexpr auto output_vars_doc = "Report the EnergyPlus output variables supported by this version of Spawn"; + auto output_vars_command = energyplus_command->add_subcommand("list-output-variables", output_vars_doc); + auto output_vars_callback = [&user_input]() { std::cout << "output vars input: " << user_input << std::endl; }; + output_vars_command->callback(output_vars_callback); - if (*createOption) { - spawn::energyplusToFMU( - jsonInput, nozip, nocompress, outputPath, outputDir, spawn::idd_install_path(), spawn::epfmi_install_path()); -#if defined ENABLE_MODELICA_COMPILER - } else if (*createModelicaFMUOption) { - auto optimica = spawn::Optimica(); - std::ignore = - optimica.generateFMU(moinput, spawn_fs::current_path(), modelicaPaths, spawn::fmu::toFMUType(fmuType)); - } else if (*makeOption) { - auto optimica = spawn::Optimica(); - optimica.makeModelicaExternalFunction(app.remaining(true)); -#endif - } else if (*versionOption) { - std::cout << "Spawn-" << spawn::version_string() << std::endl; - } else if (*energyplusVersionOption) { - std::cout << EnergyPlus::DataStringGlobals::VerString << std::endl; - } else if (*outputVarsOption) { - std::cout << nlohmann::json(outputtypes).dump(4) << std::endl; - } else if (*actuatorsOption) { - std::cout << nlohmann::json(actuatortypes).dump(4) << std::endl; - } else if (*fmuSimulateOption) { - spawn::fmu::Sim sim(fmuinput); - nlohmann::json config; - config["start"] = fmustart; - config["stop"] = fmustop; - config["step"] = fmustep; - sim.run(config); + constexpr auto actuators_doc = "Report the EnergyPlus output variables supported by this version of Spawn"; + auto actuators_command = energyplus_command->add_subcommand("list-actuators", actuators_doc); + auto actuators_vars_callback = [&user_input]() { std::cout << "actuators input: " << user_input << std::endl; }; + actuators_command->callback(actuators_vars_callback); +} + +void cc_command(CLI::App &app, [[maybe_unused]] nlohmann::json &user_input) +{ + auto cc_command = app.add_subcommand("cc", "Subcommand for C compiler with a 'make' style interface"); + cc_command->allow_extras(); +} + +void fmu_command(CLI::App &app, nlohmann::json &user_input) +{ + auto fmu_command = app.add_subcommand("fmu", "Subcommand for FMU related operations"); + auto simulate_command = fmu_command->add_subcommand("simulate", "Simulate an existing FMU"); + + auto &start = user_input["fmu"]["simulate"]["start"].get_ref(); + simulate_command->add_option("--start", start, "Simulation start time"); + auto &stop = user_input["fmu"]["simulate"]["stop"].get_ref(); + simulate_command->add_option("--stop", stop, "Simulation stop time"); + auto &step = user_input["fmu"]["simulate"]["step"].get_ref(); + simulate_command->add_option("--step", step, "Simulation step size"); + auto &fmu_path = user_input["fmu"]["simulate"]["fmu_path"]; + simulate_command->add_option("FMU_PATH", fmu_path, "FMU path"); + + auto callback = [&user_input]() { std::cout << "fmu_command input: " << user_input << std::endl; }; + simulate_command->callback(callback); +} + +int main(int argc, const char *argv[]) // NOLINT exception may escape from main +{ + spdlog::cfg::load_env_levels(); + + // clang-format off + nlohmann::json user_input = { + {"verbose", false}, + {"modelica", + { + {"modelica-path", ""}, + {"optimica", false}, + {"create-fmu", + { + {"model", ""}, + {"fmu-type", toString(spawn::fmu::FMUType::CS)} + } + } + } + }, + {"energyplus", + { + {"create-fmu", + { + {"input", ""}, + {"output-path", ""}, + {"output-dir", ""}, + {"no-zip", false}, + {"no-compress", false} + } + } + } + }, + {"cc", {}}, + {"fmu", + { + {"simulate", + { + {"fmu_path", ""}, + {"start", 0.0}, + {"stop", 60.0}, + {"step", 0.001} + } + } + } } + }; + // clang-format on + + CLI::App app{"Spawn of EnergyPlus"}; + + main_command(app, user_input); + modelica_command(app, user_input); + energyplus_command(app, user_input); + cc_command(app, user_input); + fmu_command(app, user_input); + std::exception_ptr eptr; + + try { + CLI11_PARSE(app, argc, argv); } catch (...) { eptr = std::current_exception(); } @@ -178,4 +199,42 @@ int main(int argc, const char *argv[]) // NOLINT exception may escape from main } else { return 0; } + + // if (*verboseOption) { + // spdlog::set_level(spdlog::level::trace); + // } else { + // spdlog::set_pattern("%v"); + // spdlog::set_level(spdlog::level::info); + // } + // + // if (*createOption) { + // spawn::energyplusToFMU( + // jsonInput, nozip, nocompress, outputPath, outputDir, spawn::idd_install_path(), + // spawn::epfmi_install_path()); + // #if defined ENABLE_MODELICA_COMPILER + // } else if (*createFMUCommand) { + // auto optimica = spawn::Optimica(); + // std::ignore = + // optimica.generateFMU(moinput, spawn_fs::current_path(), modelicaPaths, spawn::fmu::toFMUType(fmuType)); + // } else if (*makeOption) { + // auto optimica = spawn::Optimica(); + // optimica.makeModelicaExternalFunction(app.remaining(true)); + // #endif + // } else if (*versionOption) { + // std::cout << "Spawn-" << spawn::version_string() << std::endl; + // } else if (*energyplusVersionOption) { + // std::cout << EnergyPlus::DataStringGlobals::VerString << std::endl; + // } else if (*outputVarsOption) { + // std::cout << nlohmann::json(outputtypes).dump(4) << std::endl; + // } else if (*actuatorsOption) { + // std::cout << nlohmann::json(actuatortypes).dump(4) << std::endl; + // } else if (*fmuSimulateOption) { + // spawn::fmu::Sim sim(fmuinput); + // nlohmann::json config; + // config["start"] = fmustart; + // config["stop"] = fmustop; + // config["step"] = fmustep; + // sim.run(config); + // } + // } diff --git a/energyplus/actuatortypes.hpp b/energyplus/actuatortypes.hpp index 2d36ae531..fa3bde9bf 100644 --- a/energyplus/actuatortypes.hpp +++ b/energyplus/actuatortypes.hpp @@ -15,7 +15,7 @@ struct ActuatorProperties spawn::units::UnitType epUnitType; }; -static void to_json(nlohmann::json &j, const ActuatorProperties &p) +[[maybe_unused]] static void to_json(nlohmann::json &j, const ActuatorProperties &p) { j = nlohmann::json{{"componentType", p.componentType}, {"controlType", p.controlType}, diff --git a/open_modelica/cmake/build_and_import_open_modelica.cmake b/open_modelica/cmake/build_and_import_open_modelica.cmake index 9f0ac19ab..1603cb86a 100644 --- a/open_modelica/cmake/build_and_import_open_modelica.cmake +++ b/open_modelica/cmake/build_and_import_open_modelica.cmake @@ -40,6 +40,7 @@ ExternalProject_Add( GIT_TAG v1.20.0 GIT_SHALLOW GIT_SUBMODULES_RECURSE 1 + # CMAKE_ARGS -DBLA_STATIC=1 ) set_property(