From 0eee443bd2ca99b974cb37fe63376b8585e66b3a Mon Sep 17 00:00:00 2001 From: David Reid Date: Sun, 25 Mar 2018 08:53:51 +1000 Subject: [PATCH] Remove auto-generated code. --- mini_al.h | 263 +------------- tools/malgen/source/malgen.cpp | 620 --------------------------------- 2 files changed, 2 insertions(+), 881 deletions(-) delete mode 100644 tools/malgen/source/malgen.cpp diff --git a/mini_al.h b/mini_al.h index 6f1c76af..18be6dad 100644 --- a/mini_al.h +++ b/mini_al.h @@ -19307,268 +19307,9 @@ mal_result mal_decoder_seek_to_frame(mal_decoder* pDecoder, mal_uint64 frameInde // Should never get here, but if we do it means onSeekToFrame was not set by the backend. return MAL_INVALID_ARGS; } -#endif +#endif // MAL_NO_DECODING - - -#if 0 -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// -// -// -// AUTO-GENERATED -// -// -// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// -// FORMAT CONVERSION -// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -void mal_pcm_u8_to_s16(short* pOut, const unsigned char* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = pIn[i]; - r = x - 128; - r = r << 8; - pOut[i] = (short)r; - } -} - -void mal_pcm_u8_to_s24(void* pOut, const unsigned char* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = pIn[i]; - r = x - 128; - r = r << 16; - ((unsigned char*)pOut)[(i*3)+0] = (unsigned char)(r & 0xFF); ((unsigned char*)pOut)[(i*3)+1] = (unsigned char)((r & 0xFF00) >> 8); ((unsigned char*)pOut)[(i*3)+2] = (unsigned char)((r & 0xFF0000) >> 16); - } -} - -void mal_pcm_u8_to_s32(int* pOut, const unsigned char* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = pIn[i]; - r = x - 128; - r = r << 24; - pOut[i] = (int)r; - } -} - -void mal_pcm_u8_to_f32(float* pOut, const unsigned char* pIn, unsigned int count) -{ - float r; - for (unsigned int i = 0; i < count; ++i) { - int x = pIn[i]; - r = x * 0.00784313725490196078f; - r = r - 1; - pOut[i] = (float)r; - } -} - -void mal_pcm_s16_to_u8(unsigned char* pOut, const short* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = pIn[i]; - r = x >> 8; - r = r + 128; - pOut[i] = (unsigned char)r; - } -} - -void mal_pcm_s16_to_s24(void* pOut, const short* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = pIn[i]; - r = x << 8; - ((unsigned char*)pOut)[(i*3)+0] = (unsigned char)(r & 0xFF); ((unsigned char*)pOut)[(i*3)+1] = (unsigned char)((r & 0xFF00) >> 8); ((unsigned char*)pOut)[(i*3)+2] = (unsigned char)((r & 0xFF0000) >> 16); - } -} - -void mal_pcm_s16_to_s32(int* pOut, const short* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = pIn[i]; - r = x << 16; - pOut[i] = (int)r; - } -} - -void mal_pcm_s16_to_f32(float* pOut, const short* pIn, unsigned int count) -{ - float r; - for (unsigned int i = 0; i < count; ++i) { - int x = pIn[i]; - r = (float)(x + 32768); - r = r * 0.00003051804379339284f; - r = r - 1; - pOut[i] = (float)r; - } -} - -void mal_pcm_s24_to_u8(unsigned char* pOut, const void* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = ((int)(((unsigned int)(((unsigned char*)pIn)[i*3+0]) << 8) | ((unsigned int)(((unsigned char*)pIn)[i*3+1]) << 16) | ((unsigned int)(((unsigned char*)pIn)[i*3+2])) << 24)) >> 8; - r = x >> 16; - r = r + 128; - pOut[i] = (unsigned char)r; - } -} - -void mal_pcm_s24_to_s16(short* pOut, const void* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = ((int)(((unsigned int)(((unsigned char*)pIn)[i*3+0]) << 8) | ((unsigned int)(((unsigned char*)pIn)[i*3+1]) << 16) | ((unsigned int)(((unsigned char*)pIn)[i*3+2])) << 24)) >> 8; - r = x >> 8; - pOut[i] = (short)r; - } -} - -void mal_pcm_s24_to_s32(int* pOut, const void* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = ((int)(((unsigned int)(((unsigned char*)pIn)[i*3+0]) << 8) | ((unsigned int)(((unsigned char*)pIn)[i*3+1]) << 16) | ((unsigned int)(((unsigned char*)pIn)[i*3+2])) << 24)) >> 8; - r = x << 8; - pOut[i] = (int)r; - } -} - -void mal_pcm_s24_to_f32(float* pOut, const void* pIn, unsigned int count) -{ - float r; - for (unsigned int i = 0; i < count; ++i) { - int x = ((int)(((unsigned int)(((unsigned char*)pIn)[i*3+0]) << 8) | ((unsigned int)(((unsigned char*)pIn)[i*3+1]) << 16) | ((unsigned int)(((unsigned char*)pIn)[i*3+2])) << 24)) >> 8; - r = (float)(x + 8388608); - r = r * 0.00000011920929665621f; - r = r - 1; - pOut[i] = (float)r; - } -} - -void mal_pcm_s32_to_u8(unsigned char* pOut, const int* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = pIn[i]; - r = x >> 24; - r = r + 128; - pOut[i] = (unsigned char)r; - } -} - -void mal_pcm_s32_to_s16(short* pOut, const int* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = pIn[i]; - r = x >> 16; - pOut[i] = (short)r; - } -} - -void mal_pcm_s32_to_s24(void* pOut, const int* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = pIn[i]; - r = x >> 8; - ((unsigned char*)pOut)[(i*3)+0] = (unsigned char)(r & 0xFF); ((unsigned char*)pOut)[(i*3)+1] = (unsigned char)((r & 0xFF00) >> 8); ((unsigned char*)pOut)[(i*3)+2] = (unsigned char)((r & 0xFF0000) >> 16); - } -} - -void mal_pcm_s32_to_f32(float* pOut, const int* pIn, unsigned int count) -{ - float r; - for (unsigned int i = 0; i < count; ++i) { - int x = pIn[i]; - double t; - t = (double)(x + 2147483647UL); - t = t + 1; - t = t * 0.0000000004656612873077392578125; - r = (float)(t - 1); - pOut[i] = (float)r; - } -} - -void mal_pcm_f32_to_u8(unsigned char* pOut, const float* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - float x = pIn[i]; - float c; - c = ((x < -1) ? -1 : ((x > 1) ? 1 : x)); - c = c + 1; - r = (int)(c * 127.5f); - pOut[i] = (unsigned char)r; - } -} - -void mal_pcm_f32_to_s16(short* pOut, const float* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - float x = pIn[i]; - float c; - c = ((x < -1) ? -1 : ((x > 1) ? 1 : x)); - c = c + 1; - r = (int)(c * 32767.5f); - r = r - 32768; - pOut[i] = (short)r; - } -} - -void mal_pcm_f32_to_s24(void* pOut, const float* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - float x = pIn[i]; - float c; - c = ((x < -1) ? -1 : ((x > 1) ? 1 : x)); - c = c + 1; - r = (int)(c * 8388607.5f); - r = r - 8388608; - ((unsigned char*)pOut)[(i*3)+0] = (unsigned char)(r & 0xFF); ((unsigned char*)pOut)[(i*3)+1] = (unsigned char)((r & 0xFF00) >> 8); ((unsigned char*)pOut)[(i*3)+2] = (unsigned char)((r & 0xFF0000) >> 16); - } -} - -void mal_pcm_f32_to_s32(int* pOut, const float* pIn, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - float x = pIn[i]; - float c; - mal_int64 t; - c = ((x < -1) ? -1 : ((x > 1) ? 1 : x)); - c = c + 1; - t = (mal_int64)(c * 2147483647.5); - t = t - 2147483647; - r = (int)(t - 1); - pOut[i] = (int)r; - } -} -#endif - -#endif +#endif // MAL_IMPLEMENTATION // REVISION HISTORY diff --git a/tools/malgen/source/malgen.cpp b/tools/malgen/source/malgen.cpp deleted file mode 100644 index a602764d..00000000 --- a/tools/malgen/source/malgen.cpp +++ /dev/null @@ -1,620 +0,0 @@ - -#define DR_IMPLEMENTATION -#include "../../../../../dr_libs/dr.h" - -#include - -typedef struct -{ - const char* name; - const char* params[4]; - int paramCount; -} malgen_instruction; - -typedef struct -{ - const char* formatInStr; - const char* formatOutStr; - std::vector instructions; -} malgen_conversion_desc; - -typedef struct -{ - char* pFormatsFileData; - const char* userNamespace; - std::vector conversions; -} malgen_context; - -void u8_to_s16(const unsigned char* px, short* pr, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = px[i]; - - r = x - 128; - r = x << 8; - pr[i] = r; - } -} - -void u8_to_s24(const unsigned char* px, unsigned char* pr, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = px[i]; - - r = x - 128; - r = x << 16; - memcpy(&pr[i*3], &r, 3); - } -} - -void u8_to_s32(const unsigned char* px, int* pr, unsigned int count) -{ - int r; - for (unsigned int i = 0; i < count; ++i) { - int x = px[i]; - - r = x - 128; - r = x << 24; - pr[i] = r; - } -} - -void u8_to_f32(const unsigned char* pIn, float* pOut, unsigned int count) -{ - float r; - int x; - unsigned int i = 0; - - switch (((unsigned long long)pIn & 0x15) / sizeof(float)) - { - case 3: - x = pIn[i]; - r = x / 255.0f; - r = r * 2; - r = r - 1; - pOut[i++] = r; - case 2: - x = pIn[i]; - r = x / 255.0f; - r = r * 2; - r = r - 1; - pOut[i++] = r; - case 1: - x = pIn[i]; - r = x / 255.0f; - r = r * 2; - r = r - 1; - pOut[i++] = r; - } - - while (i+3 < count) { - float r[4]; - int x[4]; - - x[0] = pIn[i+0]; - x[1] = pIn[i+1]; - x[2] = pIn[i+2]; - x[3] = pIn[i+3]; - - r[0] = x[0] / 255.0f; - r[1] = x[1] / 255.0f; - r[2] = x[2] / 255.0f; - r[3] = x[3] / 255.0f; - - r[0] = r[0] * 2; - r[1] = r[1] * 2; - r[2] = r[2] * 2; - r[3] = r[3] * 2; - - r[0] = r[0] - 1; - r[1] = r[1] - 1; - r[2] = r[2] - 1; - r[3] = r[3] - 1; - - pOut[i+0] = r[0]; - pOut[i+1] = r[1]; - pOut[i+2] = r[2]; - pOut[i+3] = r[3]; - - i += 4; - } - - switch (count - i) - { - case 3: - x = pIn[i]; - r = x / 255.0f; - r = r * 2; - r = r - 1; - pOut[i++] = r; - case 2: - x = pIn[i]; - r = x / 255.0f; - r = r * 2; - r = r - 1; - pOut[i++] = r; - case 1: - x = pIn[i]; - r = x / 255.0f; - r = r * 2; - r = r - 1; - pOut[i++] = r; - } -} - -int malgen_compile(malgen_context* pContext) -{ - size_t formatsFileData; - pContext->pFormatsFileData = dr_open_and_read_text_file("../../../resources/format_conversions.txt", &formatsFileData); - if (pContext->pFormatsFileData == NULL) { - printf("Failed to open sample format conversion definitions.\n"); - return -1; - } - - // The first part is going to blank out comments. It just makes the actual parsing soooo much simpler. - char* pRunningStr = pContext->pFormatsFileData; - for (;;) { - if (pRunningStr[0] == '\0') break; - if (pRunningStr[0] == '#') { - while (pRunningStr[0] != '\n') { - if (pRunningStr[0] == '\0') { - break; - } - - pRunningStr[0] = ' '; - pRunningStr += 1; - } - } - pRunningStr += 1; - } - - - malgen_conversion_desc currentFunc; - malgen_instruction currentInst; - memset(¤tInst, 0, sizeof(currentInst)); - int currentParam = 0; - - // Level 0 = not inside a conversion function. - // Level 1 = inside a conversion function. - // Level 2 = inside an instruction (parsing parameters). - int level = 0; - - pRunningStr = pContext->pFormatsFileData; - for (;;) { - if (pRunningStr[0] == '\0') - return 0; - - if (level == 0) { - // Find the first non-whitespace. - for (;;) { - if (pRunningStr[0] == '\0') return 0; - if (!dr_is_whitespace(pRunningStr[0])) { - break; - } - - pRunningStr += 1; - } - - // Find the end of the conversion name. - char* pConversionNameBeg = pRunningStr; - char* pConversionNameEnd = pConversionNameBeg; - for (;;) { - if (pConversionNameEnd[0] == '\0') return -1; - if (dr_is_whitespace(pConversionNameEnd[0])) { - break; - } - - pConversionNameEnd += 1; - } - - pConversionNameEnd[0] = '\0'; - pRunningStr = pConversionNameEnd; - pRunningStr += 1; - - // Find the opening bracket. - for (;;) { - if (pRunningStr[0] == '\0') return -1; - if (pRunningStr[0] == '{') { - currentFunc.formatInStr = pConversionNameBeg; - char* formatInStrEnd = strstr((char*const)currentFunc.formatInStr, "->"); - formatInStrEnd[0] = '\0'; - currentFunc.formatOutStr = formatInStrEnd += 2; - - level += 1; - break; - } - - pRunningStr += 1; - } - } else if (level == 1) { - // Inside a function. - - // Find the first non-whitespace which is where the first instruction should be located. - for (;;) { - if (pRunningStr[0] == '\0') return -1; - if (!dr_is_whitespace(pRunningStr[0])) { - break; - } - - pRunningStr += 1; - } - - // Should be sitting at the name of the next instruction or the closing bracket. - if (pRunningStr[0] == '}') { - pContext->conversions.push_back(currentFunc); - currentFunc.formatInStr = NULL; - currentFunc.formatOutStr = NULL; - currentFunc.instructions.clear(); - pRunningStr += 1; - level -= 1; - continue; - } - - currentInst.name = pRunningStr; - - // Get to the end of the name and null terminate it. - for (;;) { - if (pRunningStr[0] == '\0') return -1; - if (dr_is_whitespace(pRunningStr[0])) { - break; - } - pRunningStr += 1; - } - - pRunningStr[0] = '\0'; - level += 1; - } else if (level == 2) { - // Inside an instruction. - - // Find the first non-whitespace which is where the next parameter should be located. - for (;;) { - if (pRunningStr[0] == '\0') return -1; - if (!dr_is_whitespace(pRunningStr[0])) { - break; - } - pRunningStr += 1; - } - - currentInst.params[currentParam++] = pRunningStr; - currentInst.paramCount += 1; - - // Should be sitting at the next parameter or the semi-colon. - if (pRunningStr[0] == ';') { - currentFunc.instructions.push_back(currentInst); - memset(¤tInst, 0, sizeof(currentInst)); - currentParam = 0; - pRunningStr[0] = '\0'; - pRunningStr += 1; - level -= 1; - continue; - } - - // Get to the end of the name and null terminate it. - for (;;) { - if (pRunningStr[0] == '\0') return -1; - if (dr_is_whitespace(pRunningStr[0])) { - break; - } - - if (pRunningStr[0] == ';') { - currentFunc.instructions.push_back(currentInst); - memset(¤tInst, 0, sizeof(currentInst)); - currentParam = 0; - pRunningStr[0] = '\0'; - pRunningStr += 1; - level -= 1; - break; - } - - pRunningStr += 1; - } - - pRunningStr[0] = '\0'; - } - - pRunningStr += 1; - } - - return 0; -} - - -std::string malgen_get_format_c_type_string(const char* formatStr) -{ - if (strcmp(formatStr, "u8") == 0) { - return "unsigned char"; - } - if (strcmp(formatStr, "s16") == 0) { - return "short"; - } - if (strcmp(formatStr, "s24") == 0) { - return "void"; - } - if (strcmp(formatStr, "s32") == 0) { - return "int"; - } - if (strcmp(formatStr, "f32") == 0) { - return "float"; - } - - return ""; -} - -std::string malgen_get_format_impl_c_type_string(const char* formatStr) -{ - if (strcmp(formatStr, "f32") == 0) { - return "float"; - } - - return "int"; -} - -std::string malgen_generate_code__conversion_func_params(malgen_context* pContext, malgen_conversion_desc* pFuncDesc) -{ - std::string code; - code += malgen_get_format_c_type_string(pFuncDesc->formatOutStr); code += "* pOut, "; - code += "const "; code += malgen_get_format_c_type_string(pFuncDesc->formatInStr); code += "* pIn, "; - code += "unsigned int count"; - - return code; -} - -std::string malgen_get_format_input_conversion_code(const char* formatStr) -{ - if (strcmp(formatStr, "s24") == 0) { - return "((int)(((unsigned int)(((unsigned char*)pIn)[i*3+0]) << 8) | ((unsigned int)(((unsigned char*)pIn)[i*3+1]) << 16) | ((unsigned int)(((unsigned char*)pIn)[i*3+2])) << 24)) >> 8"; - } - - return "pIn[i]"; -} - -std::string malgen_get_format_output_conversion_code(const char* formatStr) -{ - if (strcmp(formatStr, "s24") == 0) { - return "((unsigned char*)pOut)[(i*3)+0] = (unsigned char)(r & 0xFF); ((unsigned char*)pOut)[(i*3)+1] = (unsigned char)((r & 0xFF00) >> 8); ((unsigned char*)pOut)[(i*3)+2] = (unsigned char)((r & 0xFF0000) >> 16)"; - } - - std::string code; - code = "pOut[i] = ("; code += malgen_get_format_c_type_string(formatStr); code += ")r"; - - return code; -} - -std::string malgen_format_op_param(const char* param) -{ - std::string s(param); - - // (flt) -> (float) - { - const char* src = "(flt)"; const char* dst = "(float)"; - size_t loc = s.find(src); - if (loc != std::string::npos) { - s = s.replace(loc, strlen(src), dst); - } - } - - // (dbl) -> (double) - { - const char* src = "(dbl)"; const char* dst = "(double)"; - size_t loc = s.find(src); - if (loc != std::string::npos) { - s = s.replace(loc, strlen(src), dst); - } - } - - // (uint) -> (unsigned int) - { - const char* src = "(uint)"; const char* dst = "(unsigned int)"; - size_t loc = s.find(src); - if (loc != std::string::npos) { - s = s.replace(loc, strlen(src), dst); - } - } - - // (lng) -> (mal_int64) - { - const char* src = "(lng)"; const char* dst = "(mal_int64)"; - size_t loc = s.find(src); - if (loc != std::string::npos) { - s = s.replace(loc, strlen(src), dst); - } - } - - return s; -} - -std::string malgen_generate_code__conversion_func_inst_binary_op(const char* result, const char* param1, const char* param2, const char* op) -{ - bool requiresCast = false; - const char* resultVar = result; - if (resultVar[0] == '(') { - for (;;) { - if (resultVar[0] == '\0' || resultVar[0] == ')') { - resultVar += 1; - break; - } - resultVar += 1; - } - - requiresCast = true; - } - - std::string assignmentStr = malgen_format_op_param(param1) + " " + op + " " + malgen_format_op_param(param2); - - std::string code; - code += resultVar; code += " = "; - - if (requiresCast) { - char typeStr[64]; - strncpy_s(typeStr, result, resultVar - result); - - code += malgen_format_op_param(typeStr); code += "("; code += assignmentStr; code += ")"; - return code; - } else { - code += assignmentStr; - return code; - } -} - -std::string malgen_generate_code__conversion_func_inst(malgen_context* pContext, malgen_instruction* pInst) -{ - std::string code; - if (strcmp(pInst->name, "int") == 0) { - code += "int "; code += pInst->params[0]; - } - if (strcmp(pInst->name, "lng") == 0) { - code += "mal_int64 "; code += pInst->params[0]; - } - if (strcmp(pInst->name, "flt") == 0) { - code += "float "; code += pInst->params[0]; - } - if (strcmp(pInst->name, "dbl") == 0) { - code += "double "; code += pInst->params[0]; - } - - if (strcmp(pInst->name, "add") == 0) { - code += malgen_generate_code__conversion_func_inst_binary_op(pInst->params[0], pInst->params[1], pInst->params[2], "+"); - } - if (strcmp(pInst->name, "sub") == 0) { - code += malgen_generate_code__conversion_func_inst_binary_op(pInst->params[0], pInst->params[1], pInst->params[2], "-"); - } - if (strcmp(pInst->name, "mul") == 0) { - code += malgen_generate_code__conversion_func_inst_binary_op(pInst->params[0], pInst->params[1], pInst->params[2], "*"); - } - if (strcmp(pInst->name, "div") == 0) { - code += malgen_generate_code__conversion_func_inst_binary_op(pInst->params[0], pInst->params[1], pInst->params[2], "/"); - } - - if (strcmp(pInst->name, "shl") == 0) { - code += malgen_generate_code__conversion_func_inst_binary_op(pInst->params[0], pInst->params[1], pInst->params[2], "<<"); - } - if (strcmp(pInst->name, "shr") == 0) { - code += malgen_generate_code__conversion_func_inst_binary_op(pInst->params[0], pInst->params[1], pInst->params[2], ">>"); - } - - if (strcmp(pInst->name, "mov") == 0) { - code += pInst->params[0]; code += " = "; code += pInst->params[1]; - } - - if (strcmp(pInst->name, "sig") == 0) { // <-- This gets the sign of the first input parameter and moves it to the result. - code += pInst->params[0]; code += " = "; code += "(("; code += pInst->params[1]; code += " < 0) ? 1 : 0)"; // ((a < 0) ? 1 : 0) - } - - if (strcmp(pInst->name, "clip") == 0) { // clamp(a, -1, 1) -> r = ((a < -1) ? -1 : ((a > 1) ? 1 : a)) - code += pInst->params[0]; code += " = "; code += "(("; code += pInst->params[1]; code += " < -1) ? -1 : (("; code += pInst->params[1]; code += " > 1) ? 1 : "; code += pInst->params[1]; code += "))"; - } - - return code; -} - -std::string malgen_generate_code__conversion_func_decl(malgen_context* pContext, malgen_conversion_desc* pFuncDesc) -{ - std::string code = "void "; - code += pContext->userNamespace; - code += pFuncDesc->formatInStr; - code += "_to_"; - code += pFuncDesc->formatOutStr; - code += "("; - code += malgen_generate_code__conversion_func_params(pContext, pFuncDesc); - code += ")"; - - return code; -} - -std::string malgen_generate_code__conversion_func_impl(malgen_context* pContext, malgen_conversion_desc* pFuncDesc) -{ - std::string code; - - code += " "; code += malgen_get_format_impl_c_type_string(pFuncDesc->formatOutStr); code += " r;\n"; - code += " for (unsigned int i = 0; i < count; ++i) {\n"; - code += " "; code += malgen_get_format_impl_c_type_string(pFuncDesc->formatInStr); code += " x = "; code += malgen_get_format_input_conversion_code(pFuncDesc->formatInStr); code += ";\n"; - for (size_t i = 0; i < pFuncDesc->instructions.size(); ++i) { - code += " "; code += malgen_generate_code__conversion_func_inst(pContext, &pFuncDesc->instructions[i]); code += ";\n"; - } - code += " "; code += malgen_get_format_output_conversion_code(pFuncDesc->formatOutStr); code += ";\n"; - code += " }"; - - return code; -} - -std::string malgen_generate_code__conversion_func(malgen_context* pContext, malgen_conversion_desc* pFuncDesc) -{ - std::string code = malgen_generate_code__conversion_func_decl(pContext, pFuncDesc); - code += "\n{\n"; - code += malgen_generate_code__conversion_func_impl(pContext, pFuncDesc); - code += "\n}\n"; - - return code; -} - -int malgen_generate_code(malgen_context* pContext, std::string* pCodeOut) -{ - std::string code; - - // Conversion functions. - // Declarations. - for (size_t i = 0; i < pContext->conversions.size(); ++i) { - code += malgen_generate_code__conversion_func_decl(pContext, &pContext->conversions[i]); - code += ";\n"; - } - code += "\n"; - - // Definitions. - for (size_t i = 0; i < pContext->conversions.size(); ++i) { - code += malgen_generate_code__conversion_func(pContext, &pContext->conversions[i]); - code += "\n"; - } - - *pCodeOut = code; - return 0; -} - -int main(int argc, char** argv) -{ - (void)argc; - (void)argv; - - malgen_context context; - int result = malgen_compile(&context); - if (result != 0) { - return result; - } - - context.userNamespace = "mal_pcm_"; // TODO: Implement the "--namespace" command line argument. - - FILE* pOutputFile = dr_fopen("malgen_test0.c", "w"); - if (pOutputFile == NULL) { - printf("Failed to open output file.\n"); - return -2; - } - - std::string code; - result = malgen_generate_code(&context, &code); - if (result != 0) { - printf("Code generation failed.\n"); - return result; - } - - fprintf(pOutputFile, "%s", code.c_str()); - - - // We need conversion routines for each different combination of formats. - - - - // TESTING - for (size_t i = 0; i < context.conversions.size(); ++i) { - printf("%s to %s\n", context.conversions[i].formatInStr, context.conversions[i].formatOutStr); - for (size_t j = 0; j < context.conversions[i].instructions.size(); ++j) { - printf(" %s", context.conversions[i].instructions[j].name); - for (int k = 0; k < context.conversions[i].instructions[j].paramCount; ++k) { - printf(" %s", context.conversions[i].instructions[j].params[k]); - } - printf("\n"); - } - } - - return 0; -} \ No newline at end of file