From 22ec4a86b8f0102a2b448f22c53f70ca6f5f3adc Mon Sep 17 00:00:00 2001 From: Brian Fiete Date: Mon, 14 Oct 2019 14:08:29 -0700 Subject: [PATCH] Initial macOS changes Many changes are related to fixing warnings --- .DS_Store | Bin 0 -> 14340 bytes BeefBoot/BootApp.cpp | 1 + BeefBoot/CMakeLists.txt | 46 +- BeefRT/CMakeLists.txt | 69 +- BeefRT/dbg/DbgInternal.cpp | 2 +- BeefRT/rt/Chars.cpp | 6 + BeefRT/rt/Internal.cpp | 3 +- BeefySysLib/.DS_Store | Bin 0 -> 10244 bytes BeefySysLib/CMakeLists.txt | 43 +- BeefySysLib/Common.cpp | 3 + BeefySysLib/DataStream.cpp | 2 +- BeefySysLib/HeadlessApp.h | 16 +- BeefySysLib/img/BFIData.cpp | 10 +- BeefySysLib/img/ImageData.cpp | 2 +- BeefySysLib/img/ImgEffects.cpp | 6 +- BeefySysLib/img/ImgEffects.h | 16 +- BeefySysLib/img/PSDReader.cpp | 4 +- BeefySysLib/platform/darwin/DarwinCommon.cpp | 2151 +++++++++++++++++- BeefySysLib/platform/darwin/DarwinCommon.h | 218 +- BeefySysLib/platform/darwin/PlatformApp.h | 6 +- BeefySysLib/platform/linux/LinuxCommon.cpp | 14 +- BeefySysLib/platform/osx/BFPlatform.h | 10 +- BeefySysLib/platform/sdl/SdlBFApp.cpp | 15 + BeefySysLib/platform/sdl/SdlBFApp.h | 5 +- BeefySysLib/util/Array.h | 17 +- BeefySysLib/util/BeefPerf.cpp | 8 + BeefySysLib/util/Deque.h | 2 +- BeefySysLib/util/PolySpline.cpp | 2 +- BeefySysLib/util/SizedArray.h | 2 +- BeefySysLib/util/String.cpp | 2 +- IDEHelper/CMakeLists.txt | 43 +- IDEHelper/Compiler/BfAst.cpp | 2 + IDEHelper/Compiler/BfAst.h | 2 + IDEHelper/Compiler/BfAutoComplete.cpp | 4 +- IDEHelper/Compiler/BfCompiler.cpp | 2 +- IDEHelper/Compiler/BfDefBuilder.cpp | 2 +- IDEHelper/Compiler/BfExprEvaluator.cpp | 11 +- IDEHelper/Compiler/BfIRBuilder.cpp | 64 +- IDEHelper/Compiler/BfIRCodeGen.cpp | 5 + IDEHelper/Compiler/BfMangler.cpp | 7 + IDEHelper/Compiler/BfModule.cpp | 11 +- IDEHelper/Compiler/BfModule.h | 2 +- IDEHelper/Compiler/BfModuleTypeUtils.cpp | 92 +- IDEHelper/Compiler/BfParser.cpp | 51 +- IDEHelper/Compiler/BfPrinter.h | 2 +- IDEHelper/Compiler/BfReducer.cpp | 40 +- IDEHelper/Compiler/BfResolvedTypeUtils.h | 34 +- IDEHelper/Compiler/BfSourceClassifier.cpp | 2 +- IDEHelper/Compiler/BfSystem.cpp | 1 + IDEHelper/LinuxDebugger.cpp | 54 +- bin/build.sh | 27 +- extern/.DS_Store | Bin 0 -> 6148 bytes 52 files changed, 2873 insertions(+), 266 deletions(-) create mode 100644 .DS_Store create mode 100644 BeefySysLib/.DS_Store create mode 100644 extern/.DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..288a0d76440c670d286ec93540a37715c3711b66 GIT binary patch literal 14340 zcmeHNYj6|S6+TDC&hA>qi{oI3vPi}l2pF)9c?bx|vJDZ~K(PTs2u89tc*9z2wDN-( zGEQfbNt34Ob4p5^w3+YxbgLr_gy_BSCA^o%O0pA0@2TC4b?}rE-OvVawMo9kZpcC7|vv#(H z=ZW$Z2k^Q`LBSWo9E$hmD{JM|?w`ca^ptXN;C>8C>$HbT3{=GlK~vl%+v zHrU{?siJGsXm}5E%-uC6mu_m(9xM3imDHGN*tyo$UtpkOL1ooVlB7sVjdFMYh&9=t zOXkMycrtqzD;-ScMpA|RfMuDbd@^;!&?kq~`YtPzOBxwH%Z-h+PAVsk8kw{;8MnqW zX`5fCUo=RPEXhM^!}Ro)tu2wZw&;bH$aJ)QV@qUHGl7G9oEE6Szw6O?n!(X=PJ#2f>kEza?m#W~7KbttiSpE9J@P0-K}jO7d~V;|A8 zHpwBi)~4wuhONxOtj^kx4qN8qPG-?&e=2Xp#Vj^&QqRyNng z6$cHnWpzWUI&SNSbTTj|^lmboT-&;7+pg|>&B9uBQJtb3C$D63#yy6f zJv?cob0f!+_OPBw8=2EbCk)$2nfgE`IjS$h&&YDVW^u!krMHGc^QjJwr;M}XM(&*2 zBuRO7VQq~P4mHZ^3(|=+jiS#=v!2qtB@_-dOVVAezALNKSyU^lLu+I;DGk^(5pjui z$_81r<$*JFOND8>(jlp7`LLNx>87aKqC_QipL}#ecvDpFPi_xzV2dnG7v zdUO3P%bHfNYu~b?vveyxch3nVjvWCG4w@n;_$_oJQ2<)e4imQYsrhiN-o#KO<(YOk zqG>9Fk0`Earec5)E{eCW(G<0U@GEoW^&1pTtt6<5){PyCqAnmTi`K1CYONyFO8KP? zOBO3Tm6*&PG!?k9+^i||wtC+Pd>SspH{kp5Dk1OZ@N0Mr{tVX$b(L6)4TQPdP{U=o z3U9}?*n;bDGj1jHZ72No;2uoiUc%r29>GC8hR1Ojbwc0>8ki*nPT(X?;RE<#j>L!Y z6ZlEO;-?9VPvd0|@)AYN35m~nk>@0-sjUJMw1o9|mLFOoT}z5AwCK6hX-OSp%aGfG zFN{-;g|Q0mon3<6x`8D1yV{{EIdx$O(sSrL7x!vfrW3Si_rQLl?|bNtFaU!v;I;y` z>^etO4QFWq9hsd0+0h%sZN(Q}rFp0&?Z2q?L-A zK;~a(FXCqTXWs+92Ye6s9`HTjdteR^Fz#RcpU(b!Ur$lG>16`gM#QtZDE?O;2aA5* zh@Q3yE`7Q5-+sKvAe3(rTo$t<;$H!j@ePcdaBp{tBVzg)IODlK<0qW@RizOfD%<3+ z**dpIv!fs2vo*b=VcQ~?#XR3Kc*aD0#Cx&&KV=){@sWdf$QOgS*B!h=utwXvueWc1 z@H%i0jHwvTTBdo>vJFOI94oOAWle+cgP&N~5MIH9yjV}3u@k}i;Nl_);f>53yak0! zEiw=7@^y@zxJ}c%+QqB5`3c@fqt;Z;Pp}rPQCsEVC%C~Ht!0*<;58e9ZL|CYH|+>+ zcJLFtDjMAG;wN}zeQ=lLASZZTT;kiaNZN=!s@rNx@<(w&6zX zz)l_>_EK<|#1y6}IJ}or6D%+k^u)tNP&|$o@d>;{B*ioMW&8>!DZWiK1tTf)_y+zC ze~*8_xA7|eJy01?0ym36mq?3)g;^9tpq?`GBfm&rT$&sC;oW=gOziz1M*bB}#u3S} zxFOQKW3&!!1sXf0pA0@ z2W|ilREjaSG7g|;{_p>9fSLG1^gZBv;DdSq7j*Y`$H}_*U%U500jh}5af%M6^DR19 zqC7XD6H{RY{y82M*yng#SzR$vTa4vN&In04O8@Z>0sZ)&zQp;rFkgQB-xRxH;{SgF DAEc9I literal 0 HcmV?d00001 diff --git a/BeefBoot/BootApp.cpp b/BeefBoot/BootApp.cpp index a3c07bf6..8a502248 100644 --- a/BeefBoot/BootApp.cpp +++ b/BeefBoot/BootApp.cpp @@ -199,6 +199,7 @@ void BootApp::OutputLine(const String& text, OutputPri outputPri) if (mVerbosity < Verbosity_Minimal) return; break; + default: break; } if (outputPri == OutputPri_Warning) diff --git a/BeefBoot/CMakeLists.txt b/BeefBoot/CMakeLists.txt index 9c4ef8d6..3466c664 100644 --- a/BeefBoot/CMakeLists.txt +++ b/BeefBoot/CMakeLists.txt @@ -32,17 +32,33 @@ add_definitions( -DBFSYSLIB_DYNAMIC ) -include_directories( - . - ../BeefySysLib/ - ../BeefySysLib/platform/linux - ../BeefySysLib/third_party - ../BeefySysLib/third_party/freetype/include - ../ - ../extern/llvm-project_8_0_0/llvm/include - ../extern/llvm-project_8_0_0/llvm/lib/Target - ../IDEHelper -) +if (${APPLE}) + include_directories( + . + ../ + ../BeefySysLib/ + ../BeefySysLib/third_party + ../BeefySysLib/third_party/freetype/include + ../extern/llvm-project_8_0_0/llvm/include + ../extern/llvm-project_8_0_0/llvm/lib/Target + ../IDEHelper + + ../BeefySysLib/platform/osx + ) +else() + include_directories( + . + ../ + ../BeefySysLib/ + ../BeefySysLib/third_party + ../BeefySysLib/third_party/freetype/include + ../extern/llvm-project_8_0_0/llvm/include + ../extern/llvm-project_8_0_0/llvm/lib/Target + ../IDEHelper + + ../BeefySysLib/platform/linux + ) +endif() ############## Artefacts Output ################# # Defines outputs , depending Debug or Release. # @@ -112,11 +128,17 @@ add_executable(${PROJECT_NAME} ${SRC_FILES} ) +if (${APPLE}) + set(TARGET_LIBS_OS "") +else() + set(TARGET_LIBS_OS "tinfo") +endif() + # Link with other dependencies. if(MSVC) target_link_libraries(${PROJECT_NAME} BeefySysLib IDEHelper kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib) else() - target_link_libraries(${PROJECT_NAME} BeefySysLib IDEHelper tinfo + target_link_libraries(${PROJECT_NAME} BeefySysLib IDEHelper ${TARGET_LIBS_OS} #${LLVM_LIB}/libLLVMMC.a ) endif() diff --git a/BeefRT/CMakeLists.txt b/BeefRT/CMakeLists.txt index 768a170c..35520bac 100644 --- a/BeefRT/CMakeLists.txt +++ b/BeefRT/CMakeLists.txt @@ -35,19 +35,37 @@ add_definitions( -DBFRTMERGED ) -include_directories( - . - ../BeefySysLib/ - ../BeefySysLib/platform/linux - ../BeefySysLib/third_party - ../BeefySysLib/third_party/freetype/include - ../BeefySysLib/third_party/libffi/x86_64-unknown-linux-gnu/include - ../ - ../extern - ../extern/llvm/include - ../extern/llvm_linux/include - ../extern/llvm/lib/Target -) +if (${APPLE}) + include_directories( + . + ../BeefySysLib/ + ../BeefySysLib/third_party + ../BeefySysLib/third_party/freetype/include + ../BeefySysLib/third_party/libffi/x86_64-apple-darwin12.5.0/include + ../ + ../extern + ../extern/llvm/include + ../extern/llvm_linux/include + ../extern/llvm/lib/Target + + ../BeefySysLib/platform/osx + ) +else() + include_directories( + . + ../BeefySysLib/ + ../BeefySysLib/third_party + ../BeefySysLib/third_party/freetype/include + ../BeefySysLib/third_party/libffi/x86_64-unknown-linux-gnu/include + ../ + ../extern + ../extern/llvm/include + ../extern/llvm_linux/include + ../extern/llvm/lib/Target + + ../BeefySysLib/platform/linux + ) +endif() ############## Artefacts Output ################# # Defines outputs , depending Debug or Release. # @@ -117,21 +135,38 @@ file(GLOB SRC_FILES ../BeefySysLib/util/BeefPerf.cpp ../BeefySysLib/util/String.cpp ../BeefySysLib/util/UTF8.cpp - ../BeefySysLib/third_party/utf8proc/utf8proc.c - ../BeefySysLib/platform/linux/BFPlatform.cpp - ../BeefySysLib/platform/linux/LinuxCommon.cpp + ../BeefySysLib/third_party/utf8proc/utf8proc.c ) +if (${APPLE}) + file(GLOB SRC_FILES_OS + ../BeefySysLib/platform/darwin/BFPlatform.cpp + ../BeefySysLib/platform/darwin/DarwinCommon.cpp + ) +else() + file(GLOB SRC_FILES_OS + ../BeefySysLib/platform/linux/BFPlatform.cpp + ../BeefySysLib/platform/linux/LinuxCommon.cpp + ) +endif() + # Add library to build. add_library(${PROJECT_NAME} SHARED ${SRC_FILES} + ${SRC_FILES_OS} ) +if (${APPLE}) + set(TARGET_LIBS_OS "") +else() + set(TARGET_LIBS_OS "backtrace") +endif() + # Link with other dependencies. if(MSVC) target_link_libraries(${PROJECT_NAME} BeefySysLib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib LLVMX86Disassembler.lib LLVMMCDisassembler.lib LLVMSupport.lib LLVMX86Info.lib LLVMX86Utils.lib LLVMX86AsmPrinter.lib LLVMX86Desc.lib %(AdditionalDependencies) LLVMMC.lib LLVMObject.lib LLVMCore.lib LLVMBitReader.lib LLVMAsmParser.lib LLVMMCParser.lib LLVMCodeGen.lib LLVMTarget.lib LLVMX86CodeGen.lib LLVMScalarOpts.lib LLVMInstCombine.lib LLVMSelectionDAG.lib LLVMProfileData.lib LLVMTransformUtils.lib LLVMAnalysis.lib LLVMX86AsmParser.lib LLVMAsmPrinter.lib LLVMBitWriter.lib LLVMVectorize.lib LLVMipo.lib LLVMInstrumentation.lib LLVMDebugInfoDWARF.lib LLVMDebugInfoPDB.lib LLVMDebugInfoCodeView.lib LLVMGlobalISel.lib LLVMBinaryFormat.lib libcurl_a.lib) else() set(LLVM_LIB "${CMAKE_CURRENT_SOURCE_DIR}/../extern/llvm_linux/lib") - target_link_libraries(${PROJECT_NAME} BeefySysLib pthread dl backtrace ffi + target_link_libraries(${PROJECT_NAME} BeefySysLib pthread dl ffi ${TARGET_LIBS_OS} ) endif() diff --git a/BeefRT/dbg/DbgInternal.cpp b/BeefRT/dbg/DbgInternal.cpp index 2d00486f..aeea1a9b 100644 --- a/BeefRT/dbg/DbgInternal.cpp +++ b/BeefRT/dbg/DbgInternal.cpp @@ -2,7 +2,7 @@ #define HEAPHOOK #include -#include +//#include #include #include diff --git a/BeefRT/rt/Chars.cpp b/BeefRT/rt/Chars.cpp index 79471d84..d1b0fa8a 100644 --- a/BeefRT/rt/Chars.cpp +++ b/BeefRT/rt/Chars.cpp @@ -80,6 +80,7 @@ bool bf::System::Char32::get__IsLetterOrDigit(char32_t c) case UTF8PROC_CATEGORY_ND: case UTF8PROC_CATEGORY_NL: case UTF8PROC_CATEGORY_NO: return true; + default: break; } return false; } @@ -94,6 +95,7 @@ bool bf::System::Char32::get__IsLetter(char32_t c) case UTF8PROC_CATEGORY_LT: case UTF8PROC_CATEGORY_LM: case UTF8PROC_CATEGORY_LO: return true; + default: break; } return false; } @@ -106,6 +108,7 @@ bool bf::System::Char32::get__IsNumber(char32_t c) case UTF8PROC_CATEGORY_ND: case UTF8PROC_CATEGORY_NL: case UTF8PROC_CATEGORY_NO: return true; + default: break; } return false; } @@ -150,6 +153,7 @@ bool bf::System::Char16::get__IsLetterOrDigit(char16_t c) case UTF8PROC_CATEGORY_ND: case UTF8PROC_CATEGORY_NL: case UTF8PROC_CATEGORY_NO: return true; + default: break; } return false; } @@ -164,6 +168,7 @@ bool bf::System::Char16::get__IsLetter(char16_t c) case UTF8PROC_CATEGORY_LT: case UTF8PROC_CATEGORY_LM: case UTF8PROC_CATEGORY_LO: return true; + default: break; } return false; } @@ -176,6 +181,7 @@ bool bf::System::Char16::get__IsNumber(char16_t c) case UTF8PROC_CATEGORY_ND: case UTF8PROC_CATEGORY_NL: case UTF8PROC_CATEGORY_NO: return true; + default: break; } return false; } diff --git a/BeefRT/rt/Internal.cpp b/BeefRT/rt/Internal.cpp index 82ddb297..b5ef2234 100644 --- a/BeefRT/rt/Internal.cpp +++ b/BeefRT/rt/Internal.cpp @@ -7,7 +7,7 @@ #include //#include -#include +//#include #include #include //#include @@ -453,6 +453,7 @@ void* Internal::VirtualAlloc(intptr size, bool canExecute, bool canWrite) return ptr; #else BF_FATAL("Not supported"); + return NULL; #endif } diff --git a/BeefySysLib/.DS_Store b/BeefySysLib/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..a0ed73712d693ae738c8197edd323725abbbd1c5 GIT binary patch literal 10244 zcmeHM;c65~5U$Qfo$O{~&_KldGYEoU2+19yL4l>Yb#>2Fhlo_Q-&iFIi6}s4 zIX{a-PUGLXkF=@m&Q(YSJkcZCrG#G6GNmKh{)T73GvFEU40r}S11Et2ytBClB`y8Y zGvFEU3>-1Q>qCgnvXaT6ma=rQdK6tM?B2{8;pB;P+rbb`u;c zUmYtyO=bl#Z6UT6b|zxj?b%kRBFE~5iLLhW)UasV6Q({GOkEsfZv*I*BJ?Jnd6|xR za{A=NcBs^B`Wht&sc~Zn-{TfYL`U2hFzmRb*Pc=Lo&xi z>8MPU>xZ+%M9hkxXJDDVBs9qPBza)sia9vP7mu|HjImyzI~dVT+Cg44XkA7(!u&{) zcQLNo`M#M+%g(t8>^QM7zm|96R|j zEAVV#0te&7$NXCQbAN*$=6TQHd3Fre@hQBTxB^y!I_)`6&&-)x3&?w3FJih6{y1y+ z{D-5+xoX)tH-Q}|Vqw*cW$wtv5B&?nCU$lV*6}G>{Ka6mK-=KSVM(|&wa$Va&S}j~ z54m;BS|QnKqRV5^PISVmi7a4j+O+MAA!nnhRYvZ|(3^}k6IsedI#DraQ_l^~idZH2 z?XpE1m|?M=ZFY>zpoJ;pt*bFlz9YuWHDsuT4B)K=?o;?n;I(agV$MeN_5OT})d}l> zqYw5h{USYm%ubGBKSQ+VcVEw`-;SDy{8PGeNMGP9P+<&`-ybxSgW5uP!{dt%I+ zh_lN*zeHKW)Z?jroN;Nhgh(op@Kk%|;BB-=8%* zjbufdhnvX z|K{NB;kyrb2coI0WWv{)-9F;71V(Z=dR^P?w35y?!_lX~I)9-!--EnPS&ZBE{gr3H zGvFEU44g~`3OcNi_y6yX|NsBV4BkiO8So7JD-5XV_1bzBroMkDx>k9wJw$(j&W-hk zS_%XQ*^Y;l?RZ@9cKj7|)?H!A4d<0i4zM;MS@C HmBits[i] = 0xFF000000 | val | (val << 8) | (val << 16); } - delete fFTLog; + delete [] fFTLog; delete [] nums; } @@ -563,7 +563,7 @@ void DCT_1D(double* array, int size, int pitch) array[idxOut*pitch] = 0.5 * scale * val; } - delete prev; + delete [] prev; } void IDCT_1D(double* array, int size, int pitch) @@ -583,7 +583,7 @@ void IDCT_1D(double* array, int size, int pitch) array[idxOut*pitch] = 0.5 * val; } - delete prev; + delete [] prev; } const int DCT_1D_I_TABLE[64] = @@ -619,7 +619,7 @@ void DCT_1D_I(int* array, int size, int pitch) } - delete prev; + delete [] prev; } const int IDCT_1D_I_TABLE[64] = diff --git a/BeefySysLib/img/ImageData.cpp b/BeefySysLib/img/ImageData.cpp index 0670598f..7b5800bd 100644 --- a/BeefySysLib/img/ImageData.cpp +++ b/BeefySysLib/img/ImageData.cpp @@ -85,7 +85,7 @@ bool ImageData::LoadFromFile(const StringImpl& path) int size = 0; uint8* aData = LoadBinaryData(path, &size); if (aData == NULL) - return NULL; + return false; SetSrcData(aData, size); bool result = ReadData(); if (mKeepSrcDataValid) diff --git a/BeefySysLib/img/ImgEffects.cpp b/BeefySysLib/img/ImgEffects.cpp index 70308e4e..c01dd534 100644 --- a/BeefySysLib/img/ImgEffects.cpp +++ b/BeefySysLib/img/ImgEffects.cpp @@ -441,7 +441,7 @@ void SoftBlur(uint32* data, int w, int h, float radius, uint32 defaultValue) BoxBlur(tempBuffer, data, h, w, d, defaultValue); } } - delete tempBuffer; + delete [] tempBuffer; } static int gAlphaCheckOfs [][2] = @@ -1705,7 +1705,7 @@ void ChokedPixelTransform(ImageData* src, ImageData* dest, float radius, float c } } - delete tempBuffer; + delete [] tempBuffer; } void ImageOuterGlowEffect::Apply(PSDLayerInfo* layerInfo, ImageData* imageData, ImageData* destImageData) @@ -2251,7 +2251,7 @@ void ImageBevelEffect::Apply(int pass, int style, PSDLayerInfo* layerInfo, Image } } - delete normalMap; + delete [] normalMap; } void ImageBevelEffect::Apply(ImageEffectCtx* ctx) diff --git a/BeefySysLib/img/ImgEffects.h b/BeefySysLib/img/ImgEffects.h index 93ef0a0f..aa4c75fb 100644 --- a/BeefySysLib/img/ImgEffects.h +++ b/BeefySysLib/img/ImgEffects.h @@ -152,7 +152,7 @@ public: public: virtual void Init() override; virtual void CreateContourAndGradientData(); - virtual int GetNeededBorderSize(); + virtual int GetNeededBorderSize() override; }; class ImageOuterGlowEffect : public ImageGlowEffect @@ -266,9 +266,9 @@ public: void Init() override; void Apply(PSDLayerInfo* layerInfo, ImageData* imageData, ImageData* destImageData) override; virtual void Apply(ImageEffectCtx* ctx) override; - virtual int GetMixType(); + virtual int GetMixType() override; void Apply(int pass, int style, PSDLayerInfo* layerInfo, ImageData* imageData, ImageData* hiliteImage, ImageData* shadowImage); - virtual int GetNeededBorderSize(); + virtual int GetNeededBorderSize() override; }; typedef std::vector ImageEffectVector; @@ -286,10 +286,10 @@ public: bool mInvert; public: - virtual void Init(); + virtual void Init() override; virtual void Apply(PSDLayerInfo* layerInfo, ImageData* imageData, ImageData* destImageData) override; - virtual int GetMixType(); // Default:Interior - virtual int GetNeededBorderSize(); + virtual int GetMixType() override; // Default:Interior + virtual int GetNeededBorderSize() override; }; class ImageColorOverlayEffect : public BaseImageEffect @@ -334,8 +334,8 @@ public: public: virtual void Apply(PSDLayerInfo* layerInfo, ImageData* imageData, ImageData* destImageData) override; virtual void Apply(ImageEffectCtx* ctx) override; - virtual int GetMixType(); // Default:Interior - virtual int GetNeededBorderSize(); + virtual int GetMixType() override; // Default:Interior + virtual int GetNeededBorderSize() override; virtual bool NeedsOrigBits(ImageEffects* effects) override; }; diff --git a/BeefySysLib/img/PSDReader.cpp b/BeefySysLib/img/PSDReader.cpp index 41223a5a..6e34ff24 100644 --- a/BeefySysLib/img/PSDReader.cpp +++ b/BeefySysLib/img/PSDReader.cpp @@ -1907,12 +1907,12 @@ bool PSDLayerInfo::ReadData() } } - delete rowData; + delete [] rowData; } } } - delete rowLengths; + delete [] rowLengths; if (((mLayerMask != NULL) || (mVectorMask != NULL)) && (!mLayerMaskHidesEffects)) ApplyMask(this); diff --git a/BeefySysLib/platform/darwin/DarwinCommon.cpp b/BeefySysLib/platform/darwin/DarwinCommon.cpp index 79091ae4..361ca20c 100644 --- a/BeefySysLib/platform/darwin/DarwinCommon.cpp +++ b/BeefySysLib/platform/darwin/DarwinCommon.cpp @@ -1,3 +1,2150 @@ +#include "Common.h" +#include "BFPlatform.h" +#include +#include +#include +#include +#include +#include +#include +//#include +#include +#include +#include +#include +#include +#include +#include +#include "../PlatformInterface.h" +#include "../PlatformHelper.h" +#include "../util/CritSect.h" +#include "../util/Dictionary.h" +#include "../util/Hash.h" +#include +//#include "backtrace.h" +//#include "backtrace-supported.h" +#include "../third_party/stb/stb_sprintf.h" +#include +#include + +USING_NS_BF; + + +struct BfpPipeInfo +{ + String mPipePath; + int mWriteHandle; +}; + +struct BfpFile +{ + BfpPipeInfo* mPipeInfo; + int mHandle; + bool mNonBlocking; + bool mAllowTimeout; + bool mIsStd; + + BfpFile() + { + mPipeInfo = NULL; + mHandle = -1; + mNonBlocking = false; + mAllowTimeout = false; + mIsStd = false; + } + + BfpFile(int handle) + { + mPipeInfo = NULL; + mHandle = handle; + mNonBlocking = false; + mAllowTimeout = false; + mIsStd = false; + } + + ~BfpFile() + { + delete mPipeInfo; + } +}; + +BfpTimeStamp BfpToTimeStamp(const timespec& ts) +{ + return (int64)(ts.tv_sec * 10000000) + (int64)(ts.tv_nsec / 100) + 116444736000000000; +} + +int gBFPlatformLastError = 0; + +uint32 Beefy::BFTickCount() +{ + struct timespec now; + if (clock_gettime(CLOCK_MONOTONIC, &now)) + return 0; + return (uint32)((uint64)now.tv_sec * 1000.0 + (uint64)now.tv_nsec / 1000000); +} + +int64 Beefy::EndianSwap(int64 val) +{ + return __builtin_bswap64(val); +} + +/*int* GetStdHandle(int32 handleId) +{ + if (handleId == STD_INPUT_HANDLE) + return (int*)STDIN_FILENO; + if (handleId == STD_OUTPUT_HANDLE) + return (int*)STDOUT_FILENO; + return (int*)STDERR_FILENO; +}*/ + +/*int32 GetFileType(HANDLE fileHandle) +{ + if (isatty(file->mHandleHandle)) + return FILE_TYPE_CHAR; + return FILE_TYPE_DISK; +}*/ + +/*bool WriteFile(HANDLE hFile, void* lpBuffer, uint32 nNumberOfBytesToWrite, uint32* lpNumberOfBytesWritten, OVERLAPPED* lpOverlapped) +{ +#ifdef BF_PLATFORM_IOS + int logType = -1; + if (hFile == (int*)STDOUT_FILENO) + logType = LOG_WARNING; + else if (hFile == (int*)STDERR_FILENO) + logType = LOG_ERR; + + if (logType != -1) + { + static std::string strOut; + strOut.resize(nNumberOfBytesToWrite); + memcpy(&strOut[0], lpBuffer, nNumberOfBytesToWrite); + if ((strOut[0] != '\r') && (strOut[0] != '\n')) + syslog(LOG_WARNING, "%s", strOut.c_str()); + } +#endif + + int writeCount = (int)::write((int)(intptr)hFile, lpBuffer, nNumberOfBytesToWrite); + if (writeCount == -1) + { + //TODO: set gBFPlatformLastError + lpNumberOfBytesWritten = 0; + return false; + } + + *lpNumberOfBytesWritten = (uint32)writeCount; + return true; +}*/ + +int64 Beefy::GetFileTimeWrite(const StringImpl& path) +{ + struct stat statbuf = {0}; + int result = stat(path.c_str(), &statbuf); + if (result == -1) + return 0; + + //int64 fileTime = 0; + //BFSystemTimeToFileTime(statbuf.st_mtime, 0, &fileTime); + return statbuf.st_mtime; +} + +/*DWORD GetTimeZoneInformation(TIME_ZONE_INFORMATION* lpTimeZoneInformation) +{ + std::wstring tzName0 = Beefy::UTF8Decode(tzname[0]); + std::wstring tzName1 = Beefy::UTF8Decode(tzname[1]); + + bool isDST = false; + + time_t timeNow; + time(&timeNow); + tm tmNow = *gmtime(&timeNow); + isDST = tmNow.tm_isdst; + + struct tm checkTM; + memset(&checkTM, 0, sizeof(tm)); + checkTM.tm_mday = 1; + checkTM.tm_year = tmNow.tm_year; + time_t checkTime = mktime(&checkTM); + + time_t lastOffset = 0; + time_t minOffset = 0; + time_t maxOffset = 0; + + for (int pass = 0; pass < 2; pass++) + { + int searchDir = 60*60*24; + int thresholdCount = 0; + + while (true) + { + checkTime += searchDir; + + tm checkTM = *gmtime(&checkTime); + + if (checkTM.tm_year != tmNow.tm_year) + break; // No DST + + mktime(&checkTM); + + time_t offset = checkTM.tm_gmtoff; + if (lastOffset != offset) + { + if (thresholdCount == 0) + { + minOffset = offset; + maxOffset = offset; + } + else if (thresholdCount == 3) + { + SYSTEMTIME* sysTimeP = (offset == minOffset) ? + &lpTimeZoneInformation->StandardDate : + &lpTimeZoneInformation->DaylightDate; + + if (offset == minOffset) + tzName0 = Beefy::UTF8Decode(checkTM.tm_zone); + else + tzName1 = Beefy::UTF8Decode(checkTM.tm_zone); + + sysTimeP->wDay = 0; + sysTimeP->wDayOfWeek = 0; + sysTimeP->wYear = checkTM.tm_year + 1900; + sysTimeP->wMonth = checkTM.tm_mon; + sysTimeP->wDay = checkTM.tm_mday + 1; + sysTimeP->wHour = checkTM.tm_hour; + sysTimeP->wMinute = checkTM.tm_min; + sysTimeP->wSecond = checkTM.tm_sec; + sysTimeP->wMilliseconds = 0; + + break; + } + else + { + if (thresholdCount == 1) + searchDir /= -24; + else + searchDir /= -60; + minOffset = std::min(minOffset, offset); + maxOffset = std::max(maxOffset, offset); + } + thresholdCount++; + lastOffset = offset; + } + } + } + + wcsncpy(lpTimeZoneInformation->StandardName, tzName0.c_str(), 32); + wcsncpy(lpTimeZoneInformation->DaylightName, tzName1.c_str(), 32); + + lpTimeZoneInformation->DaylightBias = (int32)maxOffset; + lpTimeZoneInformation->StandardBias = (int32)minOffset; + + if (minOffset == maxOffset) + return 0; + return isDST ? 2 : 1; +}*/ + +bool Beefy::FileExists(const StringImpl& path, String* outActualName) +{ + struct stat statbuf = {0}; + int result = stat(path.c_str(), &statbuf); + if (result != 0) + return false; + return !S_ISDIR(statbuf.st_mode); +} + +bool Beefy::DirectoryExists(const StringImpl& path, String* outActualName) +{ + struct stat statbuf = {0}; + int result = stat(path.c_str(), &statbuf); + if (result != 0) + return false; + return S_ISDIR(statbuf.st_mode); +} + +uint64 Beefy::BFGetTickCountMicro() +{ + struct timespec now; + if (clock_gettime(CLOCK_MONOTONIC, &now)) + return 0; + return ((uint64)now.tv_sec * 1000000.0 + (uint64)now.tv_nsec / 1000); +} + +uint64 Beefy::BFGetTickCountMicroFast() +{ + return BFGetTickCountMicro(); +} + +/* +int64 abs(int64 val) +{ + return llabs(val); +} +*/ +void mkdir(const char* path) +{ + mkdir(path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); +} + +typedef void(*CrashInfoFunc)(); + +static CritSect gSysCritSect; +static String gCrashInfo; +static Array gCrashInfoFuncs; + +static String gCmdLine; +static String gExePath; + +static void Crashed() +{ + // + { + AutoCrit autoCrit(gSysCritSect); + + String debugDump; + + debugDump += "**** FATAL APPLICATION ERROR ****\n"; + + for (auto func : gCrashInfoFuncs) + func(); + + if (!gCrashInfo.IsEmpty()) + { + debugDump += gCrashInfo; + debugDump += "\n"; + } + + fprintf(stderr, "%s", debugDump.c_str()); + } + + void* array[64]; + size_t size; + char** strings; + size_t i; + + size = backtrace(array, 64); + strings = backtrace_symbols(array, size); + + for (i = 0; i < size; i++) + fprintf(stderr, "%s\n", strings[i]); + + free(strings); + + exit(1); +} + +static void SigHandler(int sig) +{ + //printf("SigHandler paused...\n"); + + const char* sigName = NULL; + switch (sig) + { + case SIGFPE: + sigName = "SIGFPE"; + break; + case SIGSEGV: + sigName = "SIGSEGV"; + break; + case SIGABRT: + sigName = "SIGABRT"; + break; + case SIGILL: + sigName = "SIGILL"; + break; + } + + if (sigName != NULL) + gCrashInfo += StrFormat("Signal: %s\n", sigName); + else + gCrashInfo += StrFormat("Signal: %d\n", sig); + Crashed(); +} + +BFP_EXPORT void BFP_CALLTYPE BfpSystem_Init(int version, BfpSystemInitFlags flags) +{ + if (version != BFP_VERSION) + { + BfpSystem_FatalError(StrFormat("Bfp build version '%d' does not match requested version '%d'", BFP_VERSION, version).c_str(), "BFP FATAL ERROR"); + } + + signal(SIGSEGV, SigHandler); + signal(SIGFPE, SigHandler); + signal(SIGABRT, SigHandler); +} + +BFP_EXPORT void BFP_CALLTYPE BfpSystem_SetCommandLine(int argc, char** argv) +{ + char* relPath = argv[0]; + + char* cwd = getcwd(NULL, 0); + gExePath = GetAbsPath(relPath, cwd); + free(cwd); + + for (int i = 0; i < argc; i++) + { + if (i != 0) + gCmdLine.Append(' '); + + String arg = argv[i]; + if ((arg.Contains(' ')) || (arg.Contains('\"'))) + { + arg.Replace("\"", "\\\""); + gCmdLine.Append("\""); + gCmdLine.Append(arg); + gCmdLine.Append("\""); + } + else + gCmdLine.Append(arg); + } +} + + +BFP_EXPORT void BFP_CALLTYPE BfpSystem_SetCrashReportKind(BfpCrashReportKind crashReportKind) +{ + +} + +BFP_EXPORT void BFP_CALLTYPE BfpSystem_AddCrashInfoFunc(BfpCrashInfoFunc crashInfoFunc) +{ + AutoCrit autoCrit(gSysCritSect); + gCrashInfoFuncs.Add(crashInfoFunc); +} + +BFP_EXPORT void BFP_CALLTYPE BfpSystem_AddCrashInfo(const char* str) // Can do at any time, or during CrashInfoFunc callbacks +{ + AutoCrit autoCrit(gSysCritSect); + gCrashInfo.Append(str); +} + +void BfpSystem_Shutdown() +{ + +} + +BFP_EXPORT uint32 BFP_CALLTYPE BfpSystem_TickCount() +{ + return Beefy::BFTickCount(); +} + +BFP_EXPORT BfpTimeStamp BFP_CALLTYPE BfpSystem_GetTimeStamp() +{ + struct timeval tv; + BfpTimeStamp result = 11644473600LL; + gettimeofday(&tv, NULL); + result += tv.tv_sec; + result *= 10000000LL; + result += tv.tv_usec * 10; + return result; +} + +BFP_EXPORT uint16 BFP_CALLTYPE BfpSystem_EndianSwap16(uint16 val) +{ + return __builtin_bswap16(val); +} + +BFP_EXPORT uint32 BFP_CALLTYPE BfpSystem_EndianSwap32(uint32 val) +{ + return __builtin_bswap32(val); +} + +BFP_EXPORT uint64 BFP_CALLTYPE BfpSystem_EndianSwap64(uint64 val) +{ + return __builtin_bswap64(val); +} + +BFP_EXPORT uint32 BFP_CALLTYPE BfpSystem_InterlockedExchange32(uint32* ptr, uint32 val) +{ + // __sync_lock_test_and_set only has Acquire semantics, so we need a __sync_synchronize to enforce a full barrier + uint32 prevVal = __sync_lock_test_and_set(ptr, val); + __sync_synchronize(); + return prevVal; +} + +BFP_EXPORT uint64 BFP_CALLTYPE BfpSystem_InterlockedExchange64(uint64* ptr, uint64 val) +{ + // __sync_lock_test_and_set only has Acquire semantics, so we need a __sync_synchronize to enforce a full barrier + uint64 prevVal = __sync_lock_test_and_set(ptr, val); + __sync_synchronize(); + return prevVal; +} + +BFP_EXPORT uint32 BFP_CALLTYPE BfpSystem_InterlockedExchangeAdd32(uint32* ptr, uint32 val) +{ + return __sync_fetch_and_add(ptr, val); +} + +BFP_EXPORT uint64 BFP_CALLTYPE BfpSystem_InterlockedExchangeAdd64(uint64* ptr, uint64 val) +{ + return __sync_fetch_and_add(ptr, val); +} + +BFP_EXPORT uint32 BFP_CALLTYPE BfpSystem_InterlockedCompareExchange32(uint32* ptr, uint32 oldVal, uint32 newVal) +{ + return __sync_val_compare_and_swap(ptr, oldVal, newVal); +} + +BFP_EXPORT uint64 BFP_CALLTYPE BfpSystem_InterlockedCompareExchange64(uint64* ptr, uint64 oldVal, uint64 newVal) +{ + return __sync_val_compare_and_swap(ptr, oldVal, newVal); +} + +BFP_EXPORT void BFP_CALLTYPE BfpSystem_FatalError(const char* error, const char* title) +{ + fprintf(stderr, "%s\n", error); + fflush(stderr); + Crashed(); +} + +BFP_EXPORT void BFP_CALLTYPE BfpSystem_GetCommandLine(char* outStr, int* inOutStrSize, BfpSystemResult* outResult) +{ + TryStringOut(gCmdLine, outStr, inOutStrSize, (BfpResult*)outResult); +} + +BFP_EXPORT void BFP_CALLTYPE BfpSystem_GetExecutablePath(char* outStr, int* inOutStrSize, BfpSystemResult* outResult) +{ + TryStringOut(gExePath, outStr, inOutStrSize, (BfpResult*)outResult); +} + +extern char **environ; + +BFP_EXPORT void BFP_CALLTYPE BfpSystem_GetEnvironmentStrings(char* outStr, int* inOutStrSize, BfpSystemResult* outResult) +{ + String env; + + char** envPtr = environ; + while (true) + { + char* envStr = *envPtr; + env.Append(envStr, strlen(envStr) + 1); + ++envPtr; + } + + TryStringOut(env, outStr, inOutStrSize, (BfpResult*)outResult); +} + +BFP_EXPORT int BFP_CALLTYPE BfpSystem_GetNumLogicalCPUs(BfpSystemResult* outResult) +{ + OUTRESULT(BfpSystemResult_Ok); + int count = 1; + size_t count_len = sizeof(count); + sysctlbyname("hw.logicalcpu", &count, &count_len, NULL, 0); + return count; +} + +BFP_EXPORT int64 BFP_CALLTYPE BfpSystem_GetCPUTick() +{ + return 10000000; +} + +BFP_EXPORT int64 BFP_CALLTYPE BfpSystem_GetCPUTickFreq() +{ + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + return (now.tv_sec * 10000000LL) + now.tv_nsec / 100; +} + +BFP_EXPORT void BFP_CALLTYPE BfpSystem_CreateGUID(BfpGUID* outGuid) +{ +// uuid_t guid; +// uuid_generate(guid); +// BfpGUID bfpGuid; +// memcpy(&bfpGuid, guid, 16); +// return bfpGuid; + + uint8* ptr = (uint8*)outGuid; + + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution dis(0, 255); + for (int i = 0; i < 16; i++) + ptr[i] = dis(gen); + + // variant must be 10xxxxxx + ptr[8] &= 0xBF; + ptr[8] |= 0x80; + + // version must be 0100xxxx + ptr[6] &= 0x4F; + ptr[6] |= 0x40; +} + +BFP_EXPORT void BFP_CALLTYPE BfpSystem_GetComputerName(char* outStr, int* inOutStrSize, BfpSystemResult* outResult) +{ + char hostName[1024]; + gethostname(hostName, 1024); + TryStringOut(hostName, outStr, inOutStrSize, (BfpResult*)outResult); +} + +// BfpProcess + +BFP_EXPORT intptr BFP_CALLTYPE BfpProcess_GetCurrentId() +{ + return getpid(); +} + +BFP_EXPORT bool BFP_CALLTYPE BfpProcess_IsRemoteMachine(const char* machineName) +{ + return false; +} + +BFP_EXPORT BfpProcess* BFP_CALLTYPE BfpProcess_GetById(const char* machineName, int processId, BfpProcessResult* outResult) +{ + NOT_IMPL; + return NULL; +} + +BFP_EXPORT void BFP_CALLTYPE BfpProcess_Enumerate(const char* machineName, BfpProcess** outProcesses, int* inOutProcessesSize, BfpProcessResult* outResult) +{ + NOT_IMPL; +} + +BFP_EXPORT void BFP_CALLTYPE BfpProcess_Release(BfpProcess* process) +{ + NOT_IMPL; +} + +BFP_EXPORT void BFP_CALLTYPE BfpProcess_GetMainWindowTitle(BfpProcess* process, char* outTitle, int* inOutTitleSize, BfpProcessResult* outResult) +{ + NOT_IMPL; +} + +BFP_EXPORT void BFP_CALLTYPE BfpProcess_GetProcessName(BfpProcess* process, char* outName, int* inOutNameSize, BfpProcessResult* outResult) +{ + NOT_IMPL; +} + +BFP_EXPORT int BFP_CALLTYPE BfpProcess_GetProcessId(BfpProcess* process) +{ + NOT_IMPL; + return 0; +} + +// BfpSpawn + +struct BfpSpawn +{ + int mPid; + bool mExited; + int mStatus; + int mStdInFD; + int mStdOutFD; + int mStdErrFD; +}; + +BFP_EXPORT BfpSpawn* BFP_CALLTYPE BfpSpawn_Create(const char* inTargetPath, const char* args, const char* workingDir, const char* env, BfpSpawnFlags flags, BfpSpawnResult* outResult) +{ + Beefy::Array stringViews; + + //printf("Executing: %s %s %x\n", inTargetPath, args, flags); + + if ((workingDir != NULL) && (workingDir[0] != 0)) + { + if (chdir(workingDir) != 0) + { + //printf("CHDIR failed %s\n", workingDir); + OUTRESULT(BfpSpawnResult_UnknownError); + return NULL; + } + } + + String newArgs; + String tempFileName; + + if ((flags & BfpSpawnFlag_UseArgsFile) != 0) + { + char tempFileNameStr[256]; + int size = 256; + BfpFileResult fileResult; + BfpFile_GetTempFileName(tempFileNameStr, &size, &fileResult); + if (fileResult == BfpFileResult_Ok) + { + tempFileName = tempFileNameStr; + + BfpFileResult fileResult; + BfpFile* file = BfpFile_Create(tempFileNameStr, BfpFileCreateKind_CreateAlways, BfpFileCreateFlag_Write, BfpFileAttribute_Normal, &fileResult); + if (file == NULL) + { + OUTRESULT(BfpSpawnResult_TempFileError); + return NULL; + } + + if ((flags & BfpSpawnFlag_UseArgsFile_Native) != 0) + { + UTF16String wStr = UTF8Decode(args); + + if ((flags & BfpSpawnFlag_UseArgsFile_BOM) != 0) + { + uint8 bom[2] = { 0xFF, 0xFE }; + BfpFile_Write(file, bom, 2, -1, NULL); + } + + BfpFile_Write(file, wStr.c_str(), wStr.length() * 2, -1, NULL); + } + else + BfpFile_Write(file, args, strlen(args), -1, NULL); + BfpFile_Release(file); + + newArgs.Append("@"); + newArgs.Append(tempFileName); + if (newArgs.Contains(' ')) + { + newArgs.Insert(0, '\"'); + newArgs.Append('\"'); + } + + args = newArgs.c_str(); + } + } + + int32 firstCharIdx = -1; + bool inQuote = false; + + String targetPath = inTargetPath; + String verb; + if ((flags & BfpSpawnFlag_UseShellExecute) != 0) + { + String target = targetPath; + int barPos = (int)target.IndexOf('|'); + if (barPos != -1) + { + verb = targetPath.Substring(barPos + 1); + targetPath.RemoveToEnd(barPos); + } + } + + int32 i = 0; + for ( ; true; i++) + { + char c = args[i]; + if (c == '\0') + break; + if ((c == ' ') && (!inQuote)) + { + if (firstCharIdx != -1) + { + stringViews.Add(Beefy::StringView(args, firstCharIdx, i - firstCharIdx)); + firstCharIdx = -1; + } + } + else + { + if (firstCharIdx == -1) + firstCharIdx = i; + if (c == '"') + inQuote = !inQuote; + else if ((inQuote) && (c == '\\')) + { + c = args[i + 1]; + if (c == '"') + i++; + } + } + } + if (firstCharIdx != -1) + stringViews.Add(Beefy::StringView(args, firstCharIdx, i - firstCharIdx)); + + Beefy::Array argvArr; + + if ((flags & BfpSpawnFlag_ArgsIncludesTarget) == 0) + argvArr.Add(strdup(targetPath.c_str())); + + for (int32 i = 0; i < (int32)stringViews.size(); i++) + { + Beefy::StringView stringView = stringViews[i]; + char* str = NULL; + for (int32 pass = 0; pass < 2; pass++) + { + char* strPtr = str; + + int32 strPos = 0; + for (int32 char8Idx = 0; char8Idx < stringView.mLength; char8Idx++) + { + char c = stringView.mPtr[char8Idx]; + if (c == '"') + inQuote = !inQuote; + else + { + if ((inQuote) && (c == '\\') && (char8Idx < stringView.mLength - 1)) + { + char nextC = stringView.mPtr[char8Idx + 1]; + if (nextC == '"') + { + c = nextC; + char8Idx++; + } + } + if (strPtr != NULL) + *(strPtr++) = c; + strPos++; + } + } + if (pass == 0) + str = (char*)malloc(strPos + 1); + else + *(strPtr++) = 0; + } + + argvArr.Add(str); + } + argvArr.Add(NULL); + + char** argv = NULL; + + //pid_t pid = 0; + //int status = posix_spawn(&pid, targetPath, NULL, NULL, &argvArr[0], environ); + + Beefy::Array envArr; + if (env != NULL) + { + char* envPtr = (char*)env; + while (true) + { + if (*envPtr == 0) + break; + + envArr.Add(envPtr); + envPtr += strlen(envPtr) + 1; + } + } + envArr.Add(NULL); + + int stdInFD[2]; + int stdOutFD[2]; + int stdErrFD[2]; + + bool failed = false; + if ((flags & BfpSpawnFlag_RedirectStdInput) != 0) + if (pipe(stdInFD) != 0) + failed = true; + if ((flags & BfpSpawnFlag_RedirectStdOutput) != 0) + if (pipe(stdOutFD) != 0) + failed = true; + if ((flags & BfpSpawnFlag_RedirectStdError) != 0) + if (pipe(stdErrFD) != 0) + failed = true; + if (failed) + { + //printf("Pipe failed\n"); + OUTRESULT(BfpSpawnResult_UnknownError); + return NULL; + } + + BfpSpawn* spawn; + pid_t pid = fork(); + if (pid == -1) // Error + { + OUTRESULT(BfpSpawnResult_UnknownError); + return NULL; + } + else if (pid == 0) // Child + { + if ((flags & BfpSpawnFlag_RedirectStdInput) != 0) + while ((dup2(stdInFD[0], STDIN_FILENO) == -1) && (errno == EINTR)) {} + if ((flags & BfpSpawnFlag_RedirectStdOutput) != 0) + while ((dup2(stdOutFD[1], STDOUT_FILENO) == -1) && (errno == EINTR)) {} + if ((flags & BfpSpawnFlag_RedirectStdError) != 0) + while ((dup2(stdErrFD[1], STDERR_FILENO) == -1) && (errno == EINTR)) {} + + // If successful then this shouldn't return at all: + int result; + + if (env != NULL) + result = execve(targetPath.c_str(), (char* const*)&argvArr[0], (char* const*)&envArr[0]); + else + result = execv(targetPath.c_str(), (char* const*)&argvArr[0]); + + printf("Couldn't execute %s\n", targetPath.c_str()); + + exit(-1); + } + else // Parent + { + spawn = new BfpSpawn(); + + if ((flags & BfpSpawnFlag_RedirectStdInput) != 0) + { + spawn->mStdInFD = stdInFD[1]; + close(stdInFD[0]); + } + else + spawn->mStdInFD = 0; + + if ((flags & BfpSpawnFlag_RedirectStdOutput) != 0) + { + spawn->mStdOutFD = stdOutFD[0]; + close(stdOutFD[1]); + } + else + spawn->mStdOutFD = 0; + + if ((flags & BfpSpawnFlag_RedirectStdError) != 0) + { + spawn->mStdErrFD = stdErrFD[0]; + close(stdErrFD[1]); + } + else + spawn->mStdErrFD = 0; + } + + for (auto val : argvArr) + free(val); + + //printf("Spawn pid:%d status:%d\n", pid, status); + spawn->mPid = pid; + spawn->mExited = false; + spawn->mStatus = 0; + + return spawn; +} + +void BfpSpawn_Release(BfpSpawn* spawn) +{ + // We don't support 'detaching' currently- this can create zombie processes since we + // don't have a reaper strategy + BfpSpawn_WaitFor(spawn, -1, NULL, NULL); + + delete spawn; +} + +BFP_EXPORT void BFP_CALLTYPE BfpSpawn_GetStdHandles(BfpSpawn* spawn, BfpFile** outStdIn, BfpFile** outStdOut, BfpFile** outStdErr) +{ + if (outStdIn != NULL) + { + *outStdIn = new BfpFile(spawn->mStdInFD); + spawn->mStdInFD = 0; + } + + if (outStdOut != NULL) + { + *outStdOut = new BfpFile(spawn->mStdOutFD); + spawn->mStdOutFD = 0; + } + + if (outStdErr != NULL) + { + *outStdErr = new BfpFile(spawn->mStdErrFD); + spawn->mStdErrFD = 0; + } +} + +bool BfpSpawn_WaitFor(BfpSpawn* spawn, int waitMS, int* outExitCode, BfpSpawnResult* outResult) +{ + OUTRESULT(BfpSpawnResult_Ok); + if (!spawn->mExited) + { + int flags = 0; + if (waitMS != -1) + { + flags = WNOHANG; + } + //TODO: Implement values other than 0 or -1 for waitMS? + + pid_t result = waitpid(spawn->mPid, &spawn->mStatus, flags); + if (result != spawn->mPid) + return false; + + spawn->mExited = true; + } + + if (!WIFEXITED(spawn->mStatus) && !WIFSIGNALED(spawn->mStatus)) + return false; + + if (outExitCode != NULL) + *outExitCode = WEXITSTATUS(spawn->mStatus); + return true; +} + +// BfpFileWatcher + +BFP_EXPORT BfpFileWatcher* BFP_CALLTYPE BfpFileWatcher_WatchDirectory(const char* path, BfpDirectoryChangeFunc callback, BfpFileWatcherFlags flags, void* userData, BfpFileResult* outResult) +{ + NOT_IMPL; + return NULL; +} + +BFP_EXPORT void BFP_CALLTYPE BfpFileWatcher_Release(BfpFileWatcher* fileWatcher) +{ + NOT_IMPL; +} + +// BfpThread + +struct BfpThread +{ + bool mPThreadReleased; + BfpThreadStartProc mStartProc; + void* mThreadParam; + BfpEvent* mDoneEvent; + + pthread_t mPThread; + int mRefCount; + int mPriority; + + BfpThread() + { + } + + void Release() + { + int refCount = __sync_fetch_and_sub(&mRefCount, 1) - 1; + if (refCount == 0) + delete this; + } +}; + +struct BfpThreadInfo +{ + intptr mStackBase; + int mStackLimit; +}; + +static __thread BfpThread* gCurrentThread; +static __thread BfpThreadInfo gCurrentThreadInfo; + +void* ThreadFunc(void* threadParam) +{ + BfpThread* thread = (BfpThread*)threadParam; + gCurrentThread = thread; + thread->mStartProc(thread->mThreadParam); + BfpEvent_Set(thread->mDoneEvent, true); + thread->Release(); + return NULL; +} + +BFP_EXPORT BfpThread* BFP_CALLTYPE BfpThread_Create(BfpThreadStartProc startProc, void* threadParam, intptr stackSize, BfpThreadCreateFlags flags, BfpThreadId* outThreadId) +{ + BfpThread* thread = new BfpThread(); + thread->mPThreadReleased = false; + thread->mStartProc = startProc; + thread->mThreadParam = threadParam; + thread->mRefCount = 2; + thread->mPriority = 0; + thread->mDoneEvent = BfpEvent_Create(BfpEventFlag_None); + + BF_ASSERT(sizeof(pthread_t) <= sizeof(void*)); + pthread_attr_t params; + pthread_attr_init(¶ms); + pthread_attr_setstacksize(¶ms, stackSize); + //pthread_attr_setdetachstate(¶ms,PTHREAD_CREATE_DETACHED); + + pthread_create(&thread->mPThread, ¶ms, ThreadFunc, (void*)thread); + + pthread_attr_destroy(¶ms); + + if (outThreadId != NULL) + *outThreadId = (BfpThreadId)thread->mPThread; + + return thread; +} + +#define FIXTHREAD() \ + pthread_t pt; \ + if (((intptr)thread & 1) != 0) \ + { \ + pt = (pthread_t)((intptr)thread & ~3); \ + thread = NULL; \ + } else \ + pt = thread->mPThread + +BFP_EXPORT void BFP_CALLTYPE BfpThread_Release(BfpThread* thread) +{ + FIXTHREAD(); + if (thread == NULL) + return; + + BfpEvent_Release(thread->mDoneEvent); + if (!thread->mPThreadReleased) + { + pthread_detach(thread->mPThread); + thread->mPThreadReleased = true; + } + thread->Release(); +} + +BFP_EXPORT void BFP_CALLTYPE BfpThread_SetName(BfpThread* thread, const char* name, BfpThreadResult* outResult) +{ + OUTRESULT(BfpThreadResult_Ok); +} + +BFP_EXPORT void BFP_CALLTYPE BfpThread_GetName(BfpThread* thread, char* outName, int* inOutNameSize, BfpThreadResult* outResult) +{ + String str = ""; + TryStringOut(str, outName, inOutNameSize, (BfpResult*)outResult); +} + +BFP_EXPORT BfpThread* BFP_CALLTYPE BfpThread_GetCurrent() +{ + if (gCurrentThread == NULL) + { + // Not a "true" BfpThread, this is either the main thread or a thread we didn't create + return (BfpThread*)((intptr)pthread_self() | 1); + } + return gCurrentThread; +} + +BFP_EXPORT BfpThreadId BFP_CALLTYPE BfpThread_GetCurrentId() +{ + if (gCurrentThread == NULL) + { + return (BfpThreadId)((intptr)pthread_self()); + } + return (BfpThreadId)gCurrentThread->mPThread; +} + +BFP_EXPORT bool BFP_CALLTYPE BfpThread_WaitFor(BfpThread* thread, int waitMS) +{ + FIXTHREAD(); + + if (waitMS == -1) + { + pthread_join(pt, NULL); + thread->mPThreadReleased = true; + return true; + } + + return BfpEvent_WaitFor(thread->mDoneEvent, waitMS); +} + +BFP_EXPORT void BFP_CALLTYPE BfpSpawn_Kill(BfpSpawn* spawn, int exitCode, BfpKillFlags killFlags, BfpSpawnResult* outResult) +{ + //TODO: Implement + OUTRESULT(BfpSpawnResult_UnknownError); +} + +BFP_EXPORT BfpThreadPriority BFP_CALLTYPE BfpThread_GetPriority(BfpThread* thread, BfpThreadResult* outResult) +{ + FIXTHREAD(); + + OUTRESULT(BfpThreadResult_Ok); + if (thread == NULL) + return (BfpThreadPriority)0; + + return (BfpThreadPriority)thread->mPriority; +} + +BFP_EXPORT void BFP_CALLTYPE BfpThread_SetPriority(BfpThread* thread, BfpThreadPriority threadPriority, BfpThreadResult* outResult) +{ + // In effect, we have two 'nice' settings: 0 (normal) or 10 (low) + // High-priority settings just don't do anything + //pid_t tid = syscall(SYS_gettid); + //int ret = setpriority(PRIO_PROCESS, tid, -std::min(nPriority, 0) * 10); + OUTRESULT(BfpThreadResult_Ok); +} + +BFP_EXPORT void BFP_CALLTYPE BfpThread_Suspend(BfpThread* thread, BfpThreadResult* outResult) +{ + NOT_IMPL; +} + +BFP_EXPORT void BFP_CALLTYPE BfpThread_Resume(BfpThread* thread, BfpThreadResult* outResult) +{ + NOT_IMPL; +} + +BFP_EXPORT void BFP_CALLTYPE BfpThread_GetIntRegisters(BfpThread* thread, intptr* outStackPtr, intptr* outIntRegs, int* inOutIntRegCount, BfpThreadResult* outResult) +{ + NOT_IMPL; +} + +BFP_EXPORT void BFP_CALLTYPE BfpThread_GetStackInfo(BfpThread* thread, intptr* outStackBase, int* outStackLimit, BfpThreadResult* outResult) +{ + // USE mach_vm_region_info ?? + // https://github.com/dmlloyd/openjdk/blob/2f680fec58a8ffb818a48f542e493306d1113c69/src/hotspot/os_cpu/bsd_x86/os_bsd_x86.cpp#L902-L961 + + /*if (gCurrentThreadInfo.mStackBase == 0) + { + void* stackBase = 0; + size_t stackLimit = 0; + + pthread_attr_t attr; + pthread_getattr_np(pthread_self(), &attr); + pthread_attr_getstack(&attr, &stackBase, &stackLimit); + + gCurrentThreadInfo.mStackBase = (intptr)stackBase + stackLimit; + gCurrentThreadInfo.mStackLimit = (int)stackLimit; + pthread_attr_destroy(&attr); + } + + *outStackBase = gCurrentThreadInfo.mStackBase; + *outStackLimit = gCurrentThreadInfo.mStackLimit; + + OUTRESULT(BfpThreadResult_Ok);*/ + OUTRESULT(BfpThreadResult_UnknownError); +} + +BFP_EXPORT void BFP_CALLTYPE BfpThread_Sleep(int sleepMS) +{ + usleep(sleepMS * 1000); +} + +BFP_EXPORT bool BFP_CALLTYPE BfpThread_Yield() +{ + return sched_yield() == 0; +} + +struct BfpCritSect +{ + pthread_mutex_t mPMutex; +}; + +BFP_EXPORT BfpCritSect* BFP_CALLTYPE BfpCritSect_Create() +{ + BfpCritSect* critSect = new BfpCritSect(); + + pthread_mutexattr_t attributes; + pthread_mutexattr_init(&attributes); + pthread_mutexattr_settype(&attributes, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&critSect->mPMutex, &attributes); + pthread_mutexattr_destroy(&attributes); + + return critSect; +} + +BFP_EXPORT void BFP_CALLTYPE BfpCritSect_Release(BfpCritSect* critSect) +{ + pthread_mutex_destroy(&critSect->mPMutex); +} + +BFP_EXPORT void BFP_CALLTYPE BfpCritSect_Enter(BfpCritSect* critSect) +{ + pthread_mutex_lock(&critSect->mPMutex); +} + +BFP_EXPORT bool BFP_CALLTYPE BfpCritSect_TryEnter(BfpCritSect* critSect, int waitMS) +{ + if (waitMS == -1) + { + BfpCritSect_Enter(critSect); + return true; + } + else if (waitMS == 0) + { + return pthread_mutex_trylock(&critSect->mPMutex) == 0; + } + + uint32 start = Beefy::BFTickCount(); + while ((int)(Beefy::BFTickCount() - start) < waitMS) + { + if (pthread_mutex_trylock(&critSect->mPMutex) == 0) + { + return true; + } + } + return false; +} + +BFP_EXPORT void BFP_CALLTYPE BfpCritSect_Leave(BfpCritSect* critSect) +{ + pthread_mutex_unlock(&critSect->mPMutex); +} + +BFP_EXPORT BfpTLS* BFP_CALLTYPE BfpTLS_Create() +{ + pthread_key_t key = 0; + pthread_key_create(&key, NULL); + return (BfpTLS*)(intptr)key; +} + +BFP_EXPORT void BFP_CALLTYPE BfpTLS_Release(BfpTLS* tls) +{ + pthread_key_delete((pthread_key_t)(intptr)tls); +} + +BFP_EXPORT void BFP_CALLTYPE BfpTLS_SetValue(BfpTLS* tls, void* value) +{ + pthread_setspecific((pthread_key_t)(intptr)tls, value); +} + +BFP_EXPORT void* BFP_CALLTYPE BfpTLS_GetValue(BfpTLS* tls) +{ + return pthread_getspecific((pthread_key_t)(intptr)tls); +} + +struct BfpEvent +{ + pthread_mutex_t mMutex; + pthread_cond_t mCondVariable; + bool mSet; + bool mManualReset; +}; + +BFP_EXPORT BfpEvent* BFP_CALLTYPE BfpEvent_Create(BfpEventFlags flags) +{ + BfpEvent* event = new BfpEvent(); + pthread_mutex_init(&event->mMutex, NULL); + pthread_cond_init(&event->mCondVariable, NULL); + event->mSet = (flags & (BfpEventFlag_InitiallySet_Auto | BfpEventFlag_InitiallySet_Manual)) != 0; + event->mManualReset = (flags & BfpEventFlag_InitiallySet_Manual) != 0; + return event; +} + +BFP_EXPORT void BFP_CALLTYPE BfpEvent_Release(BfpEvent* event) +{ + pthread_cond_destroy(&event->mCondVariable); + pthread_mutex_destroy(&event->mMutex); +} + +BFP_EXPORT void BFP_CALLTYPE BfpEvent_Set(BfpEvent* event, bool requireManualReset) +{ + pthread_mutex_lock(&event->mMutex); + event->mSet = true; + if (requireManualReset) + event->mManualReset = true; + if (event->mManualReset) + pthread_cond_broadcast(&event->mCondVariable); + else + pthread_cond_signal(&event->mCondVariable); + pthread_mutex_unlock(&event->mMutex); +} + +BFP_EXPORT void BFP_CALLTYPE BfpEvent_Reset(BfpEvent* event, BfpEventResult* outResult) +{ + event->mSet = false; + event->mManualReset = false; +} + +BFP_EXPORT bool BFP_CALLTYPE BfpEvent_WaitFor(BfpEvent* event, int waitMS) +{ + int result = pthread_mutex_lock(&event->mMutex); + BF_ASSERT(result == 0); + while (!event->mSet) + { + if (waitMS == -1) + { + pthread_cond_wait(&event->mCondVariable, &event->mMutex); + } + else + { + timespec ts; + clock_gettime(CLOCK_REALTIME, &ts); + ts.tv_sec += waitMS / 1000; + ts.tv_nsec += (waitMS % 1000) * 1000000; + + result = pthread_cond_timedwait(&event->mCondVariable, &event->mMutex, &ts); + + if (waitMS == (uint32)-1) + BF_ASSERT(result == 0); + + if (result != 0) + { + // Timeout + pthread_mutex_unlock(&event->mMutex); + return false; + } + } + } + if (!event->mManualReset) + event->mSet = false; + pthread_mutex_unlock(&event->mMutex); + return true; +} + +BFP_EXPORT BfpDynLib* BFP_CALLTYPE BfpDynLib_Load(const char* fileName) +{ + BfpDynLib* mod = NULL; + + static const char* prefixes[] = {NULL, "lib"}; + static const char* suffixes[] = {NULL, ".so", ".dylib"}; + + for (int prefixIdx = 0; prefixIdx < sizeof(prefixes)/sizeof(prefixes[0]); prefixIdx++) + { + for (int suffixIdx = 0; suffixIdx < sizeof(suffixes)/sizeof(suffixes[0]); suffixIdx++) + { + const char* prefix = prefixes[prefixIdx]; + const char* suffix = suffixes[suffixIdx]; + + Beefy::String checkName = fileName; + if (prefix != NULL) + checkName = Beefy::String(prefix) + checkName; + if (suffix != NULL) + { + int dotPos = checkName.LastIndexOf('.'); + if (dotPos != -1) + checkName.RemoveToEnd(dotPos); + checkName += suffix; + } + + mod = (BfpDynLib*)dlopen(checkName.c_str(), RTLD_LAZY); + if (mod != NULL) + return mod; + } + } + + /*mod = (BfpDynLib*)dlopen("/var/Beef/qt-build/Debug/bin/libIDEHelper.so", RTLD_LAZY);; + if (mod == NULL) + { + printf("Err: %s\n", dlerror()); + fflush(stdout); + }*/ + + return NULL; +} + +BFP_EXPORT void BFP_CALLTYPE BfpDynLib_Release(BfpDynLib* lib) +{ + dlclose((void*)lib); +} + +BFP_EXPORT void BFP_CALLTYPE BfpDynLib_GetFilePath(BfpDynLib* lib, char* outPath, int* inOutPathSize, BfpLibResult* outResult) +{ + Beefy::String path; + + + Dl_info info; + if (dladdr((void*)lib, &info) == 0) + { + OUTRESULT(BfpLibResult_UnknownError); + return; + } + + path = info.dli_fname; + TryStringOut(path, outPath, inOutPathSize, (BfpResult*)outResult); +} + +BFP_EXPORT void* BFP_CALLTYPE BfpDynLib_GetProcAddress(BfpDynLib* lib, const char* name) +{ + return dlsym((void*)lib, name); +} + +BFP_EXPORT void BFP_CALLTYPE BfpDirectory_Create(const char* path, BfpFileResult* outResult) +{ + if (mkdir(path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0) + { + switch (errno) + { + case EEXIST: + OUTRESULT(BfpFileResult_AlreadyExists); + break; + case ENOENT: + OUTRESULT(BfpFileResult_NotFound); + break; + default: + OUTRESULT(BfpFileResult_UnknownError); + break; + } + } + else + OUTRESULT(BfpFileResult_Ok); +} + +BFP_EXPORT void BFP_CALLTYPE BfpDirectory_Rename(const char* oldName, const char* newName, BfpFileResult* outResult) +{ + NOT_IMPL; +} + +BFP_EXPORT void BFP_CALLTYPE BfpDirectory_Delete(const char* path, BfpFileResult* outResult) +{ + if (rmdir(path) != 0) + { + switch (errno) + { + case ENOENT: + OUTRESULT(BfpFileResult_NotFound); + break; + default: + OUTRESULT(BfpFileResult_UnknownError); + break; + } + } + else + OUTRESULT(BfpFileResult_Ok); +} + +BFP_EXPORT void BFP_CALLTYPE BfpDirectory_GetCurrent(char* outPath, int* inOutPathSize, BfpFileResult* outResult) +{ + char* str = getcwd(NULL, 0); + Beefy::String path = str; + free(str); + TryStringOut(path, outPath, inOutPathSize, (BfpResult*)outResult); +} + +BFP_EXPORT void BFP_CALLTYPE BfpDirectory_SetCurrent(const char* path, BfpFileResult* outResult) +{ + if (chdir(path) != 0) + OUTRESULT(BfpFileResult_NotFound); + else + OUTRESULT(BfpFileResult_Ok); +} + +BFP_EXPORT bool BFP_CALLTYPE BfpDirectory_Exists(const char* path) +{ + struct stat statbuf = {0}; + int result = stat(path, &statbuf); + if (result != 0) + return false; + return S_ISDIR(statbuf.st_mode); +} + +BFP_EXPORT void BFP_CALLTYPE BfpDirectory_GetSysDirectory(BfpSysDirectoryKind sysDirKind, char* outPath, int* inOutPathLen, BfpFileResult* outResult) +{ + String path = "~"; + TryStringOut(path, outPath, inOutPathLen, (BfpResult*)outResult); +} + +BFP_EXPORT BfpFile* BFP_CALLTYPE BfpFile_Create(const char* inName, BfpFileCreateKind createKind, BfpFileCreateFlags createFlags, BfpFileAttributes createdFileAttrs, BfpFileResult* outResult) +{ + auto _DoCreate = [&](String& name) + { + int flags = 0; + int mode = 0; + int pipePairHandle = -1; + + if ((createFlags & (BfpFileCreateFlag_Read | BfpFileCreateFlag_Write)) == (BfpFileCreateFlag_Read | BfpFileCreateFlag_Write)) + flags |= O_RDWR; + else if ((createFlags & BfpFileCreateFlag_Read) != 0) + flags |= O_RDONLY; + else if ((createFlags & BfpFileCreateFlag_Write) != 0) + flags |= O_WRONLY; + + if ((createFlags & BfpFileCreateFlag_Append) != 0) + flags |= O_APPEND; + if ((createFlags & BfpFileCreateFlag_Truncate) != 0) + flags |= O_TRUNC; + if ((createFlags & (BfpFileCreateFlag_NonBlocking | BfpFileCreateFlag_AllowTimeouts)) != 0) + flags |= O_NONBLOCK; + + if ((createFlags & BfpFileCreateFlag_Pipe) != 0) + { + name = "/tmp/" + name; + if ((createKind == BfpFileCreateKind_CreateAlways) || + (createKind == BfpFileCreateKind_CreateIfNotExists)) + { + for (int pass = 0; pass < 2; pass++) + { + int result = mknod(name.c_str(), S_IFIFO | ALLPERMS, 0); + if (result == 0) + break; + + int err = errno; + if (err == EEXIST) + { + err = remove(name.c_str()); + if (err == 0) + continue; + OUTRESULT(BfpFileResult_AlreadyExists); + return -1; + } + + OUTRESULT(BfpFileResult_UnknownError); + return -1; + } + } + } + else + { + if (createKind == BfpFileCreateKind_CreateAlways) + flags |= O_CREAT; + else if (createKind == BfpFileCreateKind_CreateIfNotExists) + flags |= O_CREAT | O_EXCL; + } + + mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; + + int result = open(name.c_str(), flags, mode); + //printf("BfpFile_Create %s %d %d %d\n", name.c_str(), result, flags, mode); + + if (result <= 0) + { + switch (errno) + { + case EEXIST: + OUTRESULT(BfpFileResult_AlreadyExists); + break; + case ENOENT: + OUTRESULT(BfpFileResult_NotFound); + break; + case EACCES: + OUTRESULT(BfpFileResult_AccessError); + break; + default: + OUTRESULT(BfpFileResult_UnknownError); + break; + } + return -1; + } + return result; + }; + + BfpFile* bfpFile = NULL; + + int result; + if ((createFlags & BfpFileCreateFlag_Pipe) != 0) + { + int readHandle; + int writeHandle; + + String name = inName; + String altName = name + "__"; + + bool isCreating = false; + if ((createKind == BfpFileCreateKind_CreateAlways) || + (createKind == BfpFileCreateKind_CreateIfNotExists)) + { + readHandle = _DoCreate(name); + writeHandle = _DoCreate(altName); + isCreating = true; + } + else + { + readHandle = _DoCreate(altName); + writeHandle = _DoCreate(name); + } + + if ((readHandle != -1) && (writeHandle != -1)) + { + OUTRESULT(BfpFileResult_Ok); + + BfpPipeInfo* pipeInfo = new BfpPipeInfo(); + pipeInfo->mWriteHandle = writeHandle; + if (isCreating) + pipeInfo->mPipePath = name; + bfpFile = new BfpFile(); + bfpFile->mHandle = readHandle; + bfpFile->mPipeInfo = pipeInfo; + } + else + { + if (readHandle != -1) + close(readHandle); + if (writeHandle != -1) + close(writeHandle); + + return NULL; + } + } + else + { + String name = inName; + int handle = _DoCreate(name); + if (handle == -1) + return NULL; + + OUTRESULT(BfpFileResult_Ok); + bfpFile = new BfpFile(); + bfpFile->mHandle = handle; + } + + OUTRESULT(BfpFileResult_Ok); + if ((createFlags & (BfpFileCreateFlag_NonBlocking | BfpFileCreateFlag_AllowTimeouts)) != 0) + bfpFile->mNonBlocking = true; + if ((createFlags & BfpFileCreateFlag_AllowTimeouts) != 0) + bfpFile->mAllowTimeout = true; + return bfpFile; +} + +BFP_EXPORT BfpFile* BFP_CALLTYPE BfpFile_GetStd(BfpFileStdKind kind, BfpFileResult* outResult) +{ + int h = -1; + switch (kind) + { + case BfpFileStdKind_StdOut: + h = STDOUT_FILENO; + break; + case BfpFileStdKind_StdError: + h = STDERR_FILENO; + break; + case BfpFileStdKind_StdIn: + h = STDIN_FILENO; + break; + } + if (h == -1) + { + OUTRESULT(BfpFileResult_NotFound); + return NULL; + } + + BfpFile* bfpFile = new BfpFile(); + bfpFile->mHandle = h; + bfpFile->mIsStd = true; + + return bfpFile; +} + +BFP_EXPORT void BFP_CALLTYPE BfpFile_Release(BfpFile* file) +{ + if ((file->mHandle != -1) && (!file->mIsStd)) + close(file->mHandle); + if (file->mPipeInfo != NULL) + { + if (file->mPipeInfo->mWriteHandle != -1) + close(file->mPipeInfo->mWriteHandle); + + if (!file->mPipeInfo->mPipePath.IsEmpty()) + { + int worked = remove(file->mPipeInfo->mPipePath.c_str()); + remove((file->mPipeInfo->mPipePath + "__").c_str()); + //printf("Removing %s %d\n", file->mPipeInfo->mPipePath.c_str(), worked); + } + } + + delete file; +} + +BFP_EXPORT void BFP_CALLTYPE BfpFile_Close(BfpFile* file, BfpFileResult* outResult) +{ + if (file->mHandle != -1) + { + close(file->mHandle); + file->mHandle = -1; + if (file->mPipeInfo != NULL) + { + close(file->mPipeInfo->mWriteHandle); + file->mPipeInfo->mWriteHandle = -1; + } + + OUTRESULT(BfpFileResult_Ok); + } + else + OUTRESULT(BfpFileResult_UnknownError); +} + +BFP_EXPORT intptr BFP_CALLTYPE BfpFile_Write(BfpFile* file, const void* buffer, intptr size, int timeoutMS, BfpFileResult* outResult) +{ + int writeHandle = file->mHandle; + if (file->mPipeInfo != NULL) + writeHandle = file->mPipeInfo->mWriteHandle; + + intptr writeCount = ::write(writeHandle, buffer, size); +// if ((writeCount > 0) && (file->mIsPipe)) +// { +// ::fsync(file->mHandle); +// } + + if (writeCount < 0) + OUTRESULT(BfpFileResult_UnknownError); + else if (writeCount != size) + OUTRESULT(BfpFileResult_PartialData); + else + OUTRESULT(BfpFileResult_Ok); + return writeCount; +} + +BFP_EXPORT intptr BFP_CALLTYPE BfpFile_Read(BfpFile* file, void* buffer, intptr size, int timeoutMS, BfpFileResult* outResult) +{ + if (file->mNonBlocking) + { + if (!file->mAllowTimeout) + timeoutMS = -1; + + timeval timeout; + timeout.tv_sec = 0; + timeout.tv_usec = timeoutMS * 1000; + + fd_set readFDSet; + FD_ZERO(&readFDSet); + FD_SET(file->mHandle, &readFDSet); + + fd_set errorFDSet; + FD_ZERO(&errorFDSet); + FD_SET(file->mHandle, &errorFDSet); + + if (select(file->mHandle + 1, &readFDSet, NULL, &errorFDSet, (timeoutMS == -1) ? NULL : &timeout) < 0) + { + OUTRESULT(BfpFileResult_Timeout); + return 0; + } + } + + intptr readCount = ::read(file->mHandle, buffer, size); + if (readCount < 0) + OUTRESULT(BfpFileResult_UnknownError); + else if (readCount != size) + OUTRESULT(BfpFileResult_PartialData); + else + OUTRESULT(BfpFileResult_Ok); + return readCount; +} + +BFP_EXPORT void BFP_CALLTYPE BfpFile_Flush(BfpFile* file) +{ + ::fsync(file->mHandle); +} + +BFP_EXPORT int64 BFP_CALLTYPE BfpFile_GetFileSize(BfpFile* file) +{ + int64 oldPos = (int64)lseek(file->mHandle, 0, SEEK_CUR); + int64 size = (int64)lseek(file->mHandle, 0, SEEK_END); + lseek(file->mHandle, oldPos, SEEK_SET); + return (intptr)size; +} + +BFP_EXPORT int64 BFP_CALLTYPE BfpFile_Seek(BfpFile* file, int64 offset, BfpFileSeekKind seekKind) +{ + int whence; + if (seekKind == BfpFileSeekKind_Absolute) + whence = SEEK_SET; + else if (seekKind == BfpFileSeekKind_Relative) + whence = SEEK_CUR; + else + whence = SEEK_END; + return lseek(file->mHandle, offset, whence); +} + +BFP_EXPORT void BFP_CALLTYPE BfpFile_Truncate(BfpFile* file) +{ + int64 curPos = (int64)lseek(file->mHandle, 0, SEEK_CUR); + if (ftruncate(file->mHandle, curPos) != 0) + { + //TODO: Report error? + } +} + +BFP_EXPORT BfpTimeStamp BFP_CALLTYPE BfpFile_GetTime_LastWrite(const char* path) +{ + struct stat statbuf = {0}; + int result = stat(path, &statbuf); + if (result != 0) + return 0; + return statbuf.st_mtime; +} + +BFP_EXPORT BfpFileAttributes BFP_CALLTYPE BfpFile_GetAttributes(const char* path, BfpFileResult* outResult) +{ + NOT_IMPL; + return (BfpFileAttributes)0; +} + +BFP_EXPORT void BFP_CALLTYPE BfpFile_SetAttributes(const char* path, BfpFileAttributes attribs, BfpFileResult* outResult) +{ + NOT_IMPL; +} + +BFP_EXPORT void BFP_CALLTYPE BfpFile_Copy(const char* oldPath, const char* newPath, BfpFileCopyKind copyKind, BfpFileResult* outResult) +{ + int fd_to, fd_from; + char buf[4096]; + ssize_t nread; + + fd_from = open(oldPath, O_RDONLY); + if (fd_from < 0) + { + OUTRESULT(BfpFileResult_NotFound); + return; + } + + fd_to = open(newPath, O_WRONLY | O_CREAT | O_EXCL, 0666); + if (fd_to < 0) + { + OUTRESULT(BfpFileResult_AlreadyExists); + goto out_error; + } + + while (nread = read(fd_from, buf, sizeof buf), nread > 0) + { + char *out_ptr = buf; + ssize_t nwritten; + + do { + nwritten = write(fd_to, out_ptr, nread); + + if (nwritten >= 0) + { + nread -= nwritten; + out_ptr += nwritten; + } + else if (errno != EINTR) + { + OUTRESULT(BfpFileResult_UnknownError); + goto out_error; + } + } while (nread > 0); + } + + if (nread == 0) + { + if (close(fd_to) < 0) + { + fd_to = -1; + OUTRESULT(BfpFileResult_UnknownError); + goto out_error; + } + close(fd_from); + + /* Success! */ + OUTRESULT(BfpFileResult_Ok); + return; + } + +out_error: + close(fd_from); + if (fd_to >= 0) + close(fd_to); +} + +BFP_EXPORT void BFP_CALLTYPE BfpFile_Rename(const char* oldPath, const char* newPath, BfpFileResult* outResult) +{ + NOT_IMPL; +} + +BFP_EXPORT void BFP_CALLTYPE BfpFile_Delete(const char* path, BfpFileResult* outResult) +{ + if (remove(path) != 0) + { + switch (errno) + { + case ENOENT: + OUTRESULT(BfpFileResult_NotFound); + break; + default: + OUTRESULT(BfpFileResult_UnknownError); + break; + } + } + else + OUTRESULT(BfpFileResult_Ok); +} + +BFP_EXPORT bool BFP_CALLTYPE BfpFile_Exists(const char* path) +{ + struct stat statbuf = {0}; + int result = stat(path, &statbuf); + if (result != 0) + return false; + return !S_ISDIR(statbuf.st_mode); +} + +BFP_EXPORT void BFP_CALLTYPE BfpFile_GetTempPath(char* outPath, int* inOutPathSize, BfpFileResult* outResult) +{ + NOT_IMPL; +} + +static const char cHash64bToChar[] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', + 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', + 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', + 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '_' }; +static void HashEncode64(StringImpl& outStr, uint64 val) +{ + for (int i = 0; i < 10; i++) + { + int charIdx = (int)((val >> (i * 6)) & 0x3F) - 1; + if (charIdx != -1) + outStr.Append(cHash64bToChar[charIdx]); + } +} + +BFP_EXPORT void BFP_CALLTYPE BfpFile_GetTempFileName(char* outName, int* inOutNameSize, BfpFileResult* outResult) +{ + static uint32 uniqueIdx = 0; + BfpSystem_InterlockedExchangeAdd32(&uniqueIdx, 1); + + Beefy::HashContext ctx; + ctx.Mixin(uniqueIdx); + ctx.Mixin(getpid()); + ctx.Mixin(Beefy::BFGetTickCountMicro()); + + uint64 hash = ctx.Finish64(); + + String str = "/tmp/bftmp_"; + HashEncode64(str, hash); + + TryStringOut(str, outName, inOutNameSize, (BfpResult*)outResult); +} + +BFP_EXPORT void BFP_CALLTYPE BfpFile_GetFullPath(const char* inPath, char* outPath, int* inOutPathSize, BfpFileResult* outResult) +{ + String str; + + if (inPath[0] == '/') + { + str = inPath; + } + else + { + char* cwdPtr = getcwd(NULL, 0); + Beefy::String cwdPath = cwdPtr; + free(cwdPtr); + str = GetAbsPath(inPath, cwdPath); + } + TryStringOut(str, outPath, inOutPathSize, (BfpResult*)outResult); +} + +BFP_EXPORT void BFP_CALLTYPE BfpFile_GetActualPath(const char* inPath, char* outPath, int* inOutPathSize, BfpFileResult* outResult) +{ + NOT_IMPL; +} + +// BfpFindFileData + +struct BfpFindFileData +{ + BfpFindFileFlags mFlags; + DIR* mDirStruct; + Beefy::String mWildcard; + Beefy::String mDirPath; + + dirent* mDirEnt; + bool mHasStat; + struct stat mStat; +}; + +BFP_EXPORT BfpFindFileData* BFP_CALLTYPE BfpFindFileData_FindFirstFile(const char* path, BfpFindFileFlags flags, BfpFileResult* outResult) +{ + Beefy::String findStr = path; + Beefy::String wildcard; + + int lastSlashPos = std::max((int)findStr.LastIndexOf('/'), (int)findStr.LastIndexOf('\\')); + if (lastSlashPos != -1) + { + wildcard = findStr.Substring(lastSlashPos + 1); + findStr = findStr.Substring(0, lastSlashPos); + } + if (wildcard == "*.*") + wildcard = "*"; + + DIR* dir = opendir(findStr.c_str()); + if (dir == NULL) + { + OUTRESULT(BfpFileResult_NotFound); + return NULL; + } + + BfpFindFileData* findData = new BfpFindFileData(); + findData->mFlags = flags; + findData->mDirPath = findStr; + findData->mDirStruct = dir; + findData->mWildcard = wildcard; + findData->mHasStat = false; + findData->mDirEnt = NULL; + + if (!BfpFindFileData_FindNextFile(findData)) + { + OUTRESULT(BfpFileResult_NoResults); + delete findData; + return NULL; + } + + OUTRESULT(BfpFileResult_Ok); + return findData; +} + +static void GetStat(BfpFindFileData* findData) +{ + if (findData->mHasStat) + return; + + Beefy::String filePath = findData->mDirPath + "/" + findData->mDirEnt->d_name; + + findData->mStat = { 0 }; + int result = stat(filePath.c_str(), &findData->mStat); + + findData->mHasStat = true; +} + +static bool BfpFindFileData_CheckFilter(BfpFindFileData* findData) +{ + bool isDir = false; + if (findData->mDirEnt->d_type == DT_DIR) + isDir = true; + if (findData->mDirEnt->d_type == DT_LNK) + { + GetStat(findData); + isDir = S_ISDIR(findData->mStat.st_mode); + } + + if (isDir) + { + if ((findData->mFlags & BfpFindFileFlag_Directories) == 0) + return false; + + if ((strcmp(findData->mDirEnt->d_name, ".") == 0) || (strcmp(findData->mDirEnt->d_name, "..") == 0)) + return false; + } + else + { + if ((findData->mFlags & BfpFindFileFlag_Files) == 0) + return false; + } + + //TODO: Check actual wildcards. + + return true; +} + +BFP_EXPORT bool BFP_CALLTYPE BfpFindFileData_FindNextFile(BfpFindFileData* findData) +{ + while (true) + { + findData->mHasStat = false; + findData->mDirEnt = readdir(findData->mDirStruct); + if (findData->mDirEnt == NULL) + return false; + + if (BfpFindFileData_CheckFilter(findData)) + break; + } + + return true; +} + +BFP_EXPORT void BFP_CALLTYPE BfpFindFileData_GetFileName(BfpFindFileData* findData, char* outName, int* inOutNameSize, BfpFileResult* outResult) +{ + Beefy::String name = findData->mDirEnt->d_name; + TryStringOut(name, outName, inOutNameSize, (BfpResult*)outResult); +} + +BFP_EXPORT BfpTimeStamp BFP_CALLTYPE BfpFindFileData_GetTime_LastWrite(BfpFindFileData* findData) +{ + GetStat(findData); + return BfpToTimeStamp(findData->mStat.st_mtimespec); +} + +BFP_EXPORT BfpTimeStamp BFP_CALLTYPE BfpFindFileData_GetTime_Created(BfpFindFileData* findData) +{ + GetStat(findData); + return BfpToTimeStamp(findData->mStat.st_ctimespec); +} + +BFP_EXPORT BfpTimeStamp BFP_CALLTYPE BfpFindFileData_GetTime_Access(BfpFindFileData* findData) +{ + GetStat(findData); + return BfpToTimeStamp(findData->mStat.st_atimespec); +} + +BFP_EXPORT BfpFileAttributes BFP_CALLTYPE BfpFindFileData_GetFileAttributes(BfpFindFileData* findData) +{ + BfpFileAttributes flags = BfpFileAttribute_None; + if (S_ISDIR(findData->mStat.st_mode)) + flags = (BfpFileAttributes)(flags | BfpFileAttribute_Directory); + if (S_ISREG(findData->mStat.st_mode)) + flags = (BfpFileAttributes)(flags | BfpFileAttribute_Normal); + else if (!S_ISLNK(findData->mStat.st_mode)) + flags = (BfpFileAttributes)(flags | BfpFileAttribute_Device); + if ((findData->mStat.st_mode & S_IRUSR) == 0) + flags = (BfpFileAttributes)(flags | BfpFileAttribute_ReadOnly); + return flags; +} + +BFP_EXPORT void BFP_CALLTYPE BfpFindFileData_Release(BfpFindFileData* findData) +{ + delete findData; +} + +BFP_EXPORT int BFP_CALLTYPE BfpStack_CaptureBackTrace(int framesToSkip, intptr* outFrames, int wantFrameCount) +{ + // + return 0; +} + +BFP_EXPORT void BFP_CALLTYPE BfpOutput_DebugString(const char* str) +{ + fputs(str, stdout); + fflush(stdout); +} + +////////////////////////////////////////////////////////////////////////// + +void Beefy::BFFatalError(const StringImpl& message, const StringImpl& file, int line) +{ + String error; + error += "ERROR: "; + error += message; + error += " in "; + error += file; + error += StrFormat(" line %d", line); + BfpSystem_FatalError(error.c_str(), "FATAL ERROR"); +} + +#if 0 + #include "Common.h" #include "BFPlatform.h" #include @@ -1069,4 +3216,6 @@ int64 abs(int64 val) void mkdir(const char* path) { mkdir(path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); -} \ No newline at end of file +} + +#endif \ No newline at end of file diff --git a/BeefySysLib/platform/darwin/DarwinCommon.h b/BeefySysLib/platform/darwin/DarwinCommon.h index e1db94bb..433f32f5 100644 --- a/BeefySysLib/platform/darwin/DarwinCommon.h +++ b/BeefySysLib/platform/darwin/DarwinCommon.h @@ -8,6 +8,220 @@ #define BOOST_DETAIL_NO_CONTAINER_FWD +#include +#include +#include +#include +#include +#include +#include +//#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//#define errno (*__error()) + +//#define offsetof(type, member) __builtin_offsetof (type, member) + +extern "C" +{ +//#define FFI_BUILDING +//#include "third_party/libffi/x86_64-apple-darwin12.5.0/include/ffi.h" +} + +#define BF_ENDIAN_LITTLE + +#define _NOEXCEPT noexcept +#define NTAPI + +#define FFI_STDCALL FFI_DEFAULT_ABI +#define FFI_THISCALL FFI_DEFAULT_ABI +#define FFI_FASTCALL FFI_DEFAULT_ABI + +#define INVALID_SOCKET -1 + +typedef uint64_t uint64; +typedef uint32_t uint32; +typedef uint16_t uint16; +typedef uint8_t uint8; +typedef int64_t int64; +typedef int32_t int32; +typedef int16_t int16; +typedef int8_t int8; +typedef unsigned int uint; + +#define BF_PLATFORM_LINUX +#define BF_PLATFORM_NAME "BF_PLATFORM_LINUX" +//#define BF_PLATFORM_SDL + +#define NOP +//#define BF_NOTHROW throw () +//#define BF_NOTHROW noexcept +#define BF_NOTHROW + +#ifdef BF64 +typedef int64 intptr; +typedef uint64 uintptr; +#else +typedef int32 intptr; +typedef uint32 uintptr; +#endif + +typedef wchar_t* BSTR; +typedef int HRESULT; +typedef uint8 BYTE; +typedef uint16 WORD; +typedef uint32 DWORD; +typedef int32 LONG; + +typedef pthread_key_t BFTlsKey; +typedef pthread_t BF_THREADID; +typedef pthread_t BF_THREADHANDLE; +#define BF_TLS_DECLSPEC thread_local + +//:int64 abs(int64 val); + +#define _stricmp stricmp +#define strnicmp strncasecmp + +struct IID +{ + unsigned long Data1; + unsigned short Data2; + unsigned short Data3; + unsigned char Data4[ 8 ]; +}; + +typedef void* HANDLE; +typedef void* HMODULE; + +// We only need the stdcall attribute for x32? +//#define BFSTDCALL __attribute__((stdcall)) + +//#include "../notwin/NotWin.h" + +#ifdef DEBUG +#define _DEBUG +#endif + +#define NOT_IMPL throw "Unimplemented"; + +//ARM + +#if defined(__x86_64__) || defined(__i386__) +#define BF_FULL_MEMORY_FENCE() __asm__ __volatile__("mfence": : :"memory") +#define BF_SPINWAIT_NOP() __asm__ volatile ("pause\n" : : : "memory" ); +#else +#define BF_FULL_MEMORY_FENCE() __sync_synchronize() +#define BF_SPINWAIT_NOP() ((void) 0) +#endif + +#define BF_COMPILER_FENCE() __asm__ __volatile__("": : :"memory") +#define BF_THREAD_YIELD() sched_yield() + +#if defined _DEBUG || defined BF_DEBUG_ASSERTS +#define BF_ASSERT(_Expression) (void)( (!!(_Expression)) || (Beefy::BFFatalError(#_Expression, __FILE__, __LINE__), 0) ) +#else +#define BF_ASSERT(_Expression) (void)(0) +#endif + +#define BF_ASSERT_REL(_Expression) (void)( (!!(_Expression)) || (Beefy::BFFatalError(#_Expression, __FILE__, __LINE__), 0) ) +#define BF_FATAL(msg) (void) ((Beefy::BFFatalError(msg, __FILE__, __LINE__), 0) ) + +#if defined _DEBUG || defined BF_DEBUG_ASSERTS +#define BF_DBG_FATAL(msg) (void) ((Beefy::BFFatalError(msg, __FILE__, __LINE__), 0) ) +#else +#define BF_DBG_FATAL(msg) +#endif + +#define BF_NOINLINE __attribute__ ((noinline)) +#define BF_NAKED + +#define stricmp strcasecmp +#define _alloca alloca + +#define DIR_SEP_CHAR '/' +#define DIR_SEP_CHAR_ALT '\\' + +static char* itoa(int value, char* str, int base) +{ + if (base == 16) + sprintf(str, "%X", value); + else + sprintf(str, "%d", value); + return str; +} + +inline uint32 InterlockedCompareExchange(volatile uint32* dest, uint32 exch, uint32 comp) +{ + return __sync_val_compare_and_swap(dest, comp, exch); +} + +inline uint64 InterlockedCompareExchange64(volatile int64* dest, int64 exch, int64 comp) +{ + return __sync_val_compare_and_swap(dest, comp, exch); +} + +inline void* InterlockedCompareExchangePointer(void* volatile* dest, void* exch, void* comp) +{ + return __sync_val_compare_and_swap(dest, comp, exch); +} + +inline uint32 InterlockedExchange(volatile uint32* dest, uint32 val) +{ + return __sync_lock_test_and_set(dest, val); +} + +inline uint64 InterlockedExchange64(volatile int64* dest, int64 val) +{ + return __sync_lock_test_and_set(dest, val); +} + +inline uint32 InterlockedExchangeAdd(volatile uint32* dest, uint32 val) +{ + return __sync_add_and_fetch(dest, val); +} + +inline int32 InterlockedIncrement(volatile uint32* val) +{ + return __sync_add_and_fetch(val, 1); +} + +inline int64 InterlockedIncrement64(volatile int64* val) +{ + return __sync_add_and_fetch(val, 1); +} + +inline int32 InterlockedDecrement(volatile uint32* val) +{ + return __sync_add_and_fetch(val, -1); +} + +inline int64 InterlockedDecrement64(volatile int64* val) +{ + return __sync_add_and_fetch(val, -1); +} + +#if 0 + +#pragma once + +#ifdef __LP64__ +#define BF64 +#else +#define BF32 +#endif + +#define BOOST_DETAIL_NO_CONTAINER_FWD + #include #include #include @@ -64,7 +278,7 @@ typedef int32 LONG; typedef pthread_key_t BFTlsKey; typedef pthread_t BF_THREADID; -int64 abs(int64 val); +int64 abs(int64 val) noexcept; struct IID { @@ -320,3 +534,5 @@ inline int64 InterlockedDecrement64(volatile int64* val) { return OSAtomicDecrement64Barrier(val); } + +#endif \ No newline at end of file diff --git a/BeefySysLib/platform/darwin/PlatformApp.h b/BeefySysLib/platform/darwin/PlatformApp.h index 9bdc8ed9..e6b97f11 100644 --- a/BeefySysLib/platform/darwin/PlatformApp.h +++ b/BeefySysLib/platform/darwin/PlatformApp.h @@ -1,9 +1,11 @@ #pragma once -#include "../sdl/SdlBFApp.h" +//include "../sdl/SdlBFApp.h" +#include "../../HeadlessApp.h" NS_BF_BEGIN; -typedef SdlBFApp PlatformBFApp; +//typedef SdlBFApp PlatformBFApp; +typedef HeadlessApp PlatformBFApp; NS_BF_END; \ No newline at end of file diff --git a/BeefySysLib/platform/linux/LinuxCommon.cpp b/BeefySysLib/platform/linux/LinuxCommon.cpp index b55635bc..08e396a6 100644 --- a/BeefySysLib/platform/linux/LinuxCommon.cpp +++ b/BeefySysLib/platform/linux/LinuxCommon.cpp @@ -1233,7 +1233,7 @@ BFP_EXPORT void BFP_CALLTYPE BfpThread_Sleep(int sleepMS) BFP_EXPORT bool BFP_CALLTYPE BfpThread_Yield() { - sched_yield(); + return sched_yield() == 0; } struct BfpCritSect @@ -1814,24 +1814,24 @@ BFP_EXPORT void BFP_CALLTYPE BfpFile_Flush(BfpFile* file) ::fsync(file->mHandle); } -BFP_EXPORT intptr BFP_CALLTYPE BfpFile_GetFileSize(BfpFile* file) +BFP_EXPORT int64 BFP_CALLTYPE BfpFile_GetFileSize(BfpFile* file) { int64 oldPos = (int64)lseek64(file->mHandle, 0, SEEK_CUR); int64 size = (int64)lseek64(file->mHandle, 0, SEEK_END); lseek64(file->mHandle, oldPos, SEEK_SET); - return (intptr)size; + return (int64)size; } -BFP_EXPORT intptr BFP_CALLTYPE BfpFile_Seek(BfpFile* file, intptr offset, BfpFileSeekKind seekKind) +BFP_EXPORT int64 BFP_CALLTYPE BfpFile_Seek(BfpFile* file, int64 offset, BfpFileSeekKind seekKind) { int whence; - if (seekKind = BfpFileSeekKind_Absolute) + if (seekKind == BfpFileSeekKind_Absolute) whence = SEEK_SET; - else if (seekKind = BfpFileSeekKind_Relative) + else if (seekKind == BfpFileSeekKind_Relative) whence = SEEK_CUR; else whence = SEEK_END; - lseek64(file->mHandle, offset, whence); + return seek64(file->mHandle, offset, whence); } BFP_EXPORT void BFP_CALLTYPE BfpFile_Truncate(BfpFile* file) diff --git a/BeefySysLib/platform/osx/BFPlatform.h b/BeefySysLib/platform/osx/BFPlatform.h index 24cae231..a166db8e 100644 --- a/BeefySysLib/platform/osx/BFPlatform.h +++ b/BeefySysLib/platform/osx/BFPlatform.h @@ -1,13 +1,16 @@ #pragma once -#define BFSTDCALL __stdcall +#define BFSTDCALL #include "../darwin/DarwinCommon.h" +#include #define BF_PLATFORM_OSX +#define BF_IMPORT extern "C" + #ifdef BFSYSLIB_DYNAMIC -#define BF_EXPORT extern "C" __declspec(dllexport) +#define BF_EXPORT extern "C" #define BF_CALLTYPE #else #define BF_EXPORT extern "C" @@ -21,3 +24,6 @@ #define BF_REGISTER_COUNT 15 #endif +#define BF_DEBUG_BREAK() + +#include "../PlatformInterface.h" \ No newline at end of file diff --git a/BeefySysLib/platform/sdl/SdlBFApp.cpp b/BeefySysLib/platform/sdl/SdlBFApp.cpp index b0ad2cf8..7a448340 100644 --- a/BeefySysLib/platform/sdl/SdlBFApp.cpp +++ b/BeefySysLib/platform/sdl/SdlBFApp.cpp @@ -711,3 +711,18 @@ DrawLayer* SdlBFApp::CreateDrawLayer(BFWindow* window) } return drawLayer; } + + +void SdlBFApp::GetDesktopResolution(int& width, int& height) override +{ + width = 1024; + height = 768; +} + +void SdlBFApp::GetWorkspaceRect(int& x, int& y, int& width, int& height) override +{ + x = 0; + y = 0; + width = 1024; + height = 768; +} diff --git a/BeefySysLib/platform/sdl/SdlBFApp.h b/BeefySysLib/platform/sdl/SdlBFApp.h index d782131e..0265ab59 100644 --- a/BeefySysLib/platform/sdl/SdlBFApp.h +++ b/BeefySysLib/platform/sdl/SdlBFApp.h @@ -2,6 +2,7 @@ #include "BFApp.h" #include "BFWindow.h" +#include struct SDL_Window; @@ -56,13 +57,15 @@ public: virtual void Run() override; virtual BFWindow* CreateNewWindow(BFWindow* parent, const StringImpl& title, int x, int y, int width, int height, int windowFlags) override; - virtual DrawLayer* CreateDrawLayer(BFWindow* window); + virtual DrawLayer* CreateDrawLayer(BFWindow* window) override; virtual void* GetClipboardData(const StringImpl& format, int* size) override; virtual void ReleaseClipboardData(void* ptr) override; virtual void SetClipboardData(const StringImpl& format, const void* ptr, int size, bool resetClipboard) override; virtual BFSysBitmap* LoadSysBitmap(const wchar_t* fileName) override; + virtual void GetDesktopResolution(int& width, int& height) override; + virtual void GetWorkspaceRect(int& x, int& y, int& width, int& height) override; }; NS_BF_END; \ No newline at end of file diff --git a/BeefySysLib/util/Array.h b/BeefySysLib/util/Array.h index e59a62a2..437e32fc 100644 --- a/BeefySysLib/util/Array.h +++ b/BeefySysLib/util/Array.h @@ -137,6 +137,21 @@ public: { return mPtr < val2.mPtr; } + + bool operator>(const iterator& val2) const + { + return mPtr > val2.mPtr; + } + + bool operator<=(const iterator& val2) const + { + return mPtr <= val2.mPtr; + } + + bool operator>=(const iterator& val2) const + { + return mPtr >= val2.mPtr; + } }; struct const_iterator @@ -1041,7 +1056,7 @@ class Array : public ArrayImpl::value> public: typedef ArrayImpl::value> _ArrayImpl; - using _ArrayImpl::ArrayImpl; + using ArrayImpl::value>::ArrayImpl; using _ArrayImpl::operator=; using _ArrayImpl::operator==; using _ArrayImpl::operator!=; diff --git a/BeefySysLib/util/BeefPerf.cpp b/BeefySysLib/util/BeefPerf.cpp index 98beab18..6f8192f3 100644 --- a/BeefySysLib/util/BeefPerf.cpp +++ b/BeefySysLib/util/BeefPerf.cpp @@ -17,6 +17,14 @@ typedef fd_set FD_SET; #define closesocket close #endif +#ifdef BF_PLATFORM_OSX +#include +#include +#include +#include +//#define errno (*__error()) +#endif + //#include #pragma comment(lib,"wsock32.lib") diff --git a/BeefySysLib/util/Deque.h b/BeefySysLib/util/Deque.h index 9a9b9e2f..096bb671 100644 --- a/BeefySysLib/util/Deque.h +++ b/BeefySysLib/util/Deque.h @@ -1049,7 +1049,7 @@ class Deque : public DequeImpl::value> public: typedef DequeImpl::value> _DequeImpl; - using _DequeImpl::DequeImpl; + using DequeImpl::value>::DequeImpl; using _DequeImpl::operator=; using _DequeImpl::operator==; using _DequeImpl::operator!=; diff --git a/BeefySysLib/util/PolySpline.cpp b/BeefySysLib/util/PolySpline.cpp index 0dd8f53a..8c862cc9 100644 --- a/BeefySysLib/util/PolySpline.cpp +++ b/BeefySysLib/util/PolySpline.cpp @@ -44,7 +44,7 @@ void PolySpline2D::Calculate() for (int i=0; i::SizedArrayImpl; using _Base::operator=; using _Base::operator==; using _Base::operator!=; diff --git a/BeefySysLib/util/String.cpp b/BeefySysLib/util/String.cpp index d3fa592e..b3c9dc11 100644 --- a/BeefySysLib/util/String.cpp +++ b/BeefySysLib/util/String.cpp @@ -723,7 +723,7 @@ bool StringImpl::HasMultibyteChars() { auto ptr = GetPtr(); for (int i = 0; i < (int)mLength; i++) - if (ptr[i] >= 0x80) + if ((uint8)ptr[i] >= (uint8)0x80) return true; return false; } diff --git a/IDEHelper/CMakeLists.txt b/IDEHelper/CMakeLists.txt index 8f91cb90..db011e1e 100644 --- a/IDEHelper/CMakeLists.txt +++ b/IDEHelper/CMakeLists.txt @@ -33,16 +33,31 @@ add_definitions( -DBFSYSLIB_DYNAMIC ) -include_directories( - . - ../BeefySysLib/ - ../BeefySysLib/platform/linux - ../BeefySysLib/third_party - ../BeefySysLib/third_party/freetype/include - ../ - ../extern/llvm-project_8_0_0/llvm/include - ../extern/llvm-project_8_0_0/llvm/lib/Target -) +if (${APPLE}) + include_directories( + . + ../ + ../BeefySysLib/ + ../BeefySysLib/third_party + ../BeefySysLib/third_party/freetype/include + ../extern/llvm-project_8_0_0/llvm/include + ../extern/llvm-project_8_0_0/llvm/lib/Target + + ../BeefySysLib/platform/osx + ) +else() + include_directories( + . + ../ + ../BeefySysLib/ + ../BeefySysLib/third_party + ../BeefySysLib/third_party/freetype/include + ../extern/llvm-project_8_0_0/llvm/include + ../extern/llvm-project_8_0_0/llvm/lib/Target + + ../BeefySysLib/platform/linux + ) +endif() ############## Artefacts Output ################# # Defines outputs , depending Debug or Release. # @@ -161,11 +176,17 @@ add_library(${PROJECT_NAME} SHARED ${SRC_FILES} ) +if (${APPLE}) + set(TARGET_LIBS_OS "ncurses") +else() + set(TARGET_LIBS_OS "backtrace") +endif() + # Link with other dependencies. if(MSVC) target_link_libraries(${PROJECT_NAME} BeefySysLib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib LLVMX86Disassembler.lib LLVMMCDisassembler.lib LLVMSupport.lib LLVMX86Info.lib LLVMX86Utils.lib LLVMX86AsmPrinter.lib LLVMX86Desc.lib %(AdditionalDependencies) LLVMMC.lib LLVMObject.lib LLVMCore.lib LLVMBitReader.lib LLVMAsmParser.lib LLVMMCParser.lib LLVMCodeGen.lib LLVMTarget.lib LLVMX86CodeGen.lib LLVMScalarOpts.lib LLVMInstCombine.lib LLVMSelectionDAG.lib LLVMProfileData.lib LLVMTransformUtils.lib LLVMAnalysis.lib LLVMX86AsmParser.lib LLVMAsmPrinter.lib LLVMBitWriter.lib LLVMVectorize.lib LLVMipo.lib LLVMInstrumentation.lib LLVMDebugInfoDWARF.lib LLVMDebugInfoPDB.lib LLVMDebugInfoCodeView.lib LLVMGlobalISel.lib LLVMBinaryFormat.lib LLVMAggressiveInstCombine.lib libcurl_a.lib) else() - target_link_libraries(${PROJECT_NAME} BeefySysLib hunspell pthread dl backtrace + target_link_libraries(${PROJECT_NAME} BeefySysLib hunspell pthread dl ${TARGET_LIBS_OS} ${LLVM_LIB}/libLLVMCore.a ${LLVM_LIB}/libLLVMMC.a ${LLVM_LIB}/libLLVMMCParser.a diff --git a/IDEHelper/Compiler/BfAst.cpp b/IDEHelper/Compiler/BfAst.cpp index 4bce720d..67cad91d 100644 --- a/IDEHelper/Compiler/BfAst.cpp +++ b/IDEHelper/Compiler/BfAst.cpp @@ -1506,6 +1506,8 @@ int Beefy::BfGetBinaryOpPrecendence(BfBinaryOp binOp) return 2; case BfBinaryOp_NullCoalesce: return 1; + default: + break; } return 0; diff --git a/IDEHelper/Compiler/BfAst.h b/IDEHelper/Compiler/BfAst.h index d75755ef..50f592fd 100644 --- a/IDEHelper/Compiler/BfAst.h +++ b/IDEHelper/Compiler/BfAst.h @@ -655,6 +655,8 @@ public: case BfTypedValueKind_ParamsSplat: case BfTypedValueKind_Params: return true; + default: + return false; } return false; diff --git a/IDEHelper/Compiler/BfAutoComplete.cpp b/IDEHelper/Compiler/BfAutoComplete.cpp index 5f176c58..5aa9641b 100644 --- a/IDEHelper/Compiler/BfAutoComplete.cpp +++ b/IDEHelper/Compiler/BfAutoComplete.cpp @@ -364,7 +364,7 @@ BfTypedValue BfAutoComplete::LookupTypeRefOrIdentifier(BfAstNode* node, bool* is if (auto identifier = BfNodeDynCast(node)) { BfExprEvaluator exprEvaluator(mModule); - auto identifierResult = exprEvaluator.LookupIdentifier(identifier, NULL); + auto identifierResult = exprEvaluator.LookupIdentifier(identifier, false, NULL); if (!identifierResult) identifierResult = exprEvaluator.GetResult(); if (identifierResult) @@ -1435,7 +1435,7 @@ bool BfAutoComplete::CheckMemberReference(BfAstNode* target, BfAstNode* dotToken { BfAttributedIdentifierNode* attrIdentifier = NULL; bool isAutocompletingName = false; - if (attrIdentifier = BfNodeDynCast(memberName)) + if ((attrIdentifier = BfNodeDynCast(memberName))) { memberName = attrIdentifier->mIdentifier; if ((memberName == NULL) && (IsAutocompleteNode(attrIdentifier->mAttributes))) diff --git a/IDEHelper/Compiler/BfCompiler.cpp b/IDEHelper/Compiler/BfCompiler.cpp index 9b0b2aef..06fd325d 100644 --- a/IDEHelper/Compiler/BfCompiler.cpp +++ b/IDEHelper/Compiler/BfCompiler.cpp @@ -1074,7 +1074,7 @@ void BfCompiler::CreateVData(BfVDataModule* bfModule) for (auto type : orderedTypes) { - if ((type == NULL) /*|| (type->IsUnspecializedType()*/) + if (type == NULL) continue; if (type->IsTemporary()) diff --git a/IDEHelper/Compiler/BfDefBuilder.cpp b/IDEHelper/Compiler/BfDefBuilder.cpp index 0672d90b..e6197634 100644 --- a/IDEHelper/Compiler/BfDefBuilder.cpp +++ b/IDEHelper/Compiler/BfDefBuilder.cpp @@ -1840,7 +1840,7 @@ void BfDefBuilder::FinishTypeDef(bool wantsToString) } bool isPayloadEnum = false; - if ((mCurTypeDef->mTypeCode == BfTypeCode_Enum) /*&& (mCurTypeDef->mGenericParams.size() == 0)*/) + if (mCurTypeDef->mTypeCode == BfTypeCode_Enum) { for (auto fieldDef : mCurTypeDef->mFields) { diff --git a/IDEHelper/Compiler/BfExprEvaluator.cpp b/IDEHelper/Compiler/BfExprEvaluator.cpp index 6316d82b..375369fe 100644 --- a/IDEHelper/Compiler/BfExprEvaluator.cpp +++ b/IDEHelper/Compiler/BfExprEvaluator.cpp @@ -42,6 +42,7 @@ static BfBinaryOp GetOppositeBinaryOp(BfBinaryOp origOp) return BfBinaryOp_LessThanOrEqual; case BfBinaryOp_GreaterThanOrEqual: return BfBinaryOp_LessThan; + default: break; } return BfBinaryOp_None; @@ -63,6 +64,7 @@ static BfBinaryOp GetFlippedBinaryOp(BfBinaryOp origOp) return BfBinaryOp_LessThan; case BfBinaryOp_GreaterThanOrEqual: return BfBinaryOp_LessThanOrEqual; + default: break; } return BfBinaryOp_None; @@ -7708,6 +7710,7 @@ bool BfExprEvaluator::LookupTypeProp(BfTypeOfExpression* typeOfExpr, BfIdentifie case BfTypeCode_UInt64: mResult = BfTypedValue(mModule->mBfIRBuilder->CreateConst(primType->mTypeDef->mTypeCode, isMin ? 0 : (uint64)0xFFFFFFFFFFFFFFFFLL), typeInstance); return true; + default: break; } } } @@ -7754,6 +7757,7 @@ void BfExprEvaluator::DoTypeIntAttr(BfTypeReference* typeRef, BfToken token) case BfToken_SizeOf: attrVal = type->mSize; break; case BfToken_AlignOf: attrVal = type->mAlign; break; case BfToken_StrideOf: attrVal = type->GetStride(); break; + default: break; } bool isUndefVal = false; @@ -16481,6 +16485,7 @@ bool BfExprEvaluator::CheckConstCompare(BfBinaryOp binaryOp, BfAstNode* opToken, if (rightConst->mInt64 < minValue) constResult = 0; break; + default: break; } return false; } @@ -16524,6 +16529,7 @@ bool BfExprEvaluator::CheckConstCompare(BfBinaryOp binaryOp, BfAstNode* opToken, else if (rightConst->mInt64 <= minValue) constResult = 1; break; + default: break; } } @@ -16591,7 +16597,8 @@ void BfExprEvaluator::PerformBinaryOperation(BfAstNode* leftExpression, BfAstNod } else { - mModule->Fail(StrFormat("Operator '??' cannot be applied to operands of type '%s' and '%s'", + // Note: Annoying trigraph split for '??' + mModule->Fail(StrFormat("Operator '?" "?' cannot be applied to operands of type '%s' and '%s'", mModule->TypeToString(leftValue.mType).c_str(), mModule->TypeToString(rightValue.mType).c_str()), opToken); leftValue = mModule->GetDefaultTypedValue(rightValue.mType); } @@ -16971,6 +16978,7 @@ void BfExprEvaluator::PerformBinaryOperation(BfAstNode* leftExpression, BfAstNod case BfBinaryOp_LessThanOrEqual: mResult = BfTypedValue(mModule->mBfIRBuilder->CreateCmpLTE(mResult.mValue, zeroVal, true), boolType); break; + default: break; } } @@ -17653,6 +17661,7 @@ void BfExprEvaluator::Visit(BfBinaryOperatorExpression* binOpExpr) case BfBinaryOp_Subtract: unaryOp = BfUnaryOp_Negate; break; case BfBinaryOp_Multiply: unaryOp = BfUnaryOp_Dereference; break; case BfBinaryOp_BitwiseAnd: unaryOp = BfUnaryOp_AddressOf; break; + default: break; } if (unaryOp != BfUnaryOp_None) diff --git a/IDEHelper/Compiler/BfIRBuilder.cpp b/IDEHelper/Compiler/BfIRBuilder.cpp index 4d96dab4..96e54103 100644 --- a/IDEHelper/Compiler/BfIRBuilder.cpp +++ b/IDEHelper/Compiler/BfIRBuilder.cpp @@ -70,6 +70,7 @@ USING_NS_BF; case BfTypeCode_Single: \ case BfTypeCode_Double: \ return CreateConst(constLHS->mTypeCode, OP(constLHS->mDouble, constRHS->mDouble)); break; \ + default: break; \ } \ return CreateConst(constLHS->mTypeCode, val); @@ -94,6 +95,7 @@ USING_NS_BF; case BfTypeCode_Char32: val = OP(constLHS->mUInt32, constRHS->mUInt32); break; \ case BfTypeCode_Int64: val = OP(constLHS->mInt64, constRHS->mInt64); break; \ case BfTypeCode_UInt64: val = OP(constLHS->mUInt64, constRHS->mUInt64); break; \ + default: break; \ } \ return CreateConst(constLHS->mTypeCode, val); @@ -122,6 +124,7 @@ USING_NS_BF; case BfTypeCode_Single: \ case BfTypeCode_Double: \ return CreateConst(constLHS->mTypeCode, constLHS->mDouble OP constRHS->mDouble); break; \ + default: break; \ } \ return CreateConst(constLHS->mTypeCode, val); @@ -143,6 +146,7 @@ USING_NS_BF; case BfTypeCode_Char32: val = constLHS->mUInt32 OP constRHS->mUInt32; break; \ case BfTypeCode_Int64: val = constLHS->mInt64 OP constRHS->mInt64; break; \ case BfTypeCode_UInt64: val = constLHS->mUInt64 OP constRHS->mUInt64; break; \ + default: break; \ } \ return CreateConst(constLHS->mTypeCode, val); @@ -166,6 +170,7 @@ USING_NS_BF; case BfTypeCode_Single: \ case BfTypeCode_Double: \ return CreateConst(constVal->mTypeCode, OP constVal->mDouble); break; \ + default: break; \ } \ return CreateConst(constVal->mTypeCode, val); @@ -195,6 +200,7 @@ USING_NS_BF; case BfTypeCode_UInt64: val = constLHS->mUInt64 OP constRHS->mUInt64; break; \ case BfTypeCode_Single: val = constLHS->mDouble OP constRHS->mDouble; break; \ case BfTypeCode_Double: val = constLHS->mDouble OP constRHS->mDouble; break; \ + default: break; \ } \ return CreateConst(BfTypeCode_Boolean, val ? (uint64)1 : (uint64)0); \ } @@ -1481,54 +1487,54 @@ void BfIRBuilder::Write(const BfIRValue& irValue) mStream.Write(BfIRParamType_Const); mStream.Write((uint8)constant->mTypeCode); - switch (constant->mTypeCode) + switch ((int)constant->mTypeCode) { - case BfTypeCode_Single: + case (int)BfTypeCode_Single: { float f = (float)constant->mDouble; mStream.Write(&f, sizeof(float)); } break; - case BfTypeCode_Double: + case (int)BfTypeCode_Double: { mStream.Write(&constant->mDouble, sizeof(double)); } break; - case BfTypeCode_Int8: - case BfTypeCode_UInt8: - case BfTypeCode_Int16: - case BfTypeCode_UInt16: - case BfTypeCode_Int32: - case BfTypeCode_UInt32: - case BfTypeCode_Int64: - case BfTypeCode_UInt64: - case BfTypeCode_IntPtr: - case BfTypeCode_UIntPtr: - case BfTypeCode_IntUnknown: - case BfTypeCode_UIntUnknown: - case BfTypeCode_Char8: - case BfTypeCode_Char16: - case BfTypeCode_Char32: + case (int)BfTypeCode_Int8: + case (int)BfTypeCode_UInt8: + case (int)BfTypeCode_Int16: + case (int)BfTypeCode_UInt16: + case (int)BfTypeCode_Int32: + case (int)BfTypeCode_UInt32: + case (int)BfTypeCode_Int64: + case (int)BfTypeCode_UInt64: + case (int)BfTypeCode_IntPtr: + case (int)BfTypeCode_UIntPtr: + case (int)BfTypeCode_IntUnknown: + case (int)BfTypeCode_UIntUnknown: + case (int)BfTypeCode_Char8: + case (int)BfTypeCode_Char16: + case (int)BfTypeCode_Char32: { WriteSLEB128(constant->mInt64); } break; - case BfTypeCode_Boolean: + case (int)BfTypeCode_Boolean: { Write(constant->mBool); } break; - case BfTypeCode_NullPtr: + case (int)BfTypeCode_NullPtr: { Write(constant->mIRType); } break; - case BfTypeCode_None: + case (int)BfTypeCode_None: { // No param needed } break; - case BfConstType_GlobalVar: + case (int)BfConstType_GlobalVar: { auto gvConst = (BfGlobalVar*)constant; WriteSLEB128(gvConst->mStreamId); @@ -1546,8 +1552,8 @@ void BfIRBuilder::Write(const BfIRValue& irValue) } } break; - case BfConstType_BitCast: - case BfConstType_BitCastNull: + case (int)BfConstType_BitCast: + case (int)BfConstType_BitCastNull: { auto bitcast = (BfConstantBitCast*)constant; BfIRValue targetConst(BfIRValueFlags_Const, bitcast->mTarget); @@ -1555,7 +1561,7 @@ void BfIRBuilder::Write(const BfIRValue& irValue) Write(bitcast->mToType); } break; - case BfConstType_GEP32_2: + case (int)BfConstType_GEP32_2: { auto gepConst = (BfConstantGEP32_2*)constant; BfIRValue targetConst(BfIRValueFlags_Const, gepConst->mTarget); @@ -1564,7 +1570,7 @@ void BfIRBuilder::Write(const BfIRValue& irValue) Write(gepConst->mIdx1); } break; - case BfConstType_PtrToInt: + case (int)BfConstType_PtrToInt: { auto ptrToIntConst = (BfConstantPtrToInt*)constant; BfIRValue targetConst(BfIRValueFlags_Const, ptrToIntConst->mTarget); @@ -1572,12 +1578,12 @@ void BfIRBuilder::Write(const BfIRValue& irValue) Write(ptrToIntConst->mToTypeCode); } break; - case BfConstType_AggZero: + case (int)BfConstType_AggZero: { Write(constant->mIRType); } break; - case BfConstType_Array: + case (int)BfConstType_Array: { auto arrayConst = (BfConstantArray*)constant; Write(arrayConst->mType); @@ -3230,6 +3236,7 @@ BfIRValue BfIRBuilder::CreateNumericCast(BfIRValue val, bool valIsSigned, BfType case BfTypeCode_UInt32: val = (uint32)constVal->mInt64; break; case BfTypeCode_Int64: val = (uint64)(int64)constVal->mInt64; break; case BfTypeCode_UInt64: val = (uint64)constVal->mUInt64; break; + default: break; } } else // Float -> Int @@ -3247,6 +3254,7 @@ BfIRValue BfIRBuilder::CreateNumericCast(BfIRValue val, bool valIsSigned, BfType case BfTypeCode_UInt32: val = (uint32)constVal->mDouble; break; case BfTypeCode_Int64: val = (uint64)(int64)constVal->mDouble; break; case BfTypeCode_UInt64: val = (uint64)constVal->mDouble; break; + default: break; } } diff --git a/IDEHelper/Compiler/BfIRCodeGen.cpp b/IDEHelper/Compiler/BfIRCodeGen.cpp index 04ca959a..a64fd209 100644 --- a/IDEHelper/Compiler/BfIRCodeGen.cpp +++ b/IDEHelper/Compiler/BfIRCodeGen.cpp @@ -201,6 +201,7 @@ static llvm::Attribute::AttrKind LLVMMapAttribute(BfIRAttribute attr) case BFIRAttribute_NoUnwind: return llvm::Attribute::NoUnwind; case BFIRAttribute_UWTable: return llvm::Attribute::UWTable; case BFIRAttribute_AlwaysInline: return llvm::Attribute::AlwaysInline; + default: break; } return llvm::Attribute::None; } @@ -307,6 +308,7 @@ llvm::Type* BfIRCodeGen::GetLLVMType(BfTypeCode typeCode, bool& isSigned) return llvm::Type::getFloatTy(*mLLVMContext); case BfTypeCode_Double: return llvm::Type::getDoubleTy(*mLLVMContext); + default: break; } return NULL; } @@ -2236,6 +2238,7 @@ void BfIRCodeGen::HandleNextCmd() case BfIRIntrinsic_AtomicXor: op = llvm::AtomicRMWInst::BinOp::Xor; break; + default: break; } auto memoryKindConst = llvm::dyn_cast(args[2]); @@ -2312,6 +2315,7 @@ void BfIRCodeGen::HandleNextCmd() case BfIRIntrinsic_AtomicUMin: cmpVal = mIRBuilder->CreateICmpULE(atomicRMW, args[1]); break; + default: break; } result = mIRBuilder->CreateSelect(cmpVal, atomicRMW, args[1]); } @@ -2335,6 +2339,7 @@ void BfIRCodeGen::HandleNextCmd() case BfIRIntrinsic_AtomicXChg: result = args[1]; break; + default: break; } } SetResult(curId, result); diff --git a/IDEHelper/Compiler/BfMangler.cpp b/IDEHelper/Compiler/BfMangler.cpp index 2f1243ba..35f2afe4 100644 --- a/IDEHelper/Compiler/BfMangler.cpp +++ b/IDEHelper/Compiler/BfMangler.cpp @@ -489,6 +489,7 @@ void BfGNUMangler::Mangle(MangleContext& mangleContext, StringImpl& name, BfType name += "f"; return; case BfTypeCode_Double: name += "d"; return; + default: break; } name += "?"; return; @@ -761,6 +762,7 @@ String BfGNUMangler::Mangle(BfMethodInstance* methodInst) case BfBinaryOp_As: methodName = "2as"; break; + default: break; } switch (operatorDef->mOperatorDeclaration->mUnaryOp) @@ -804,6 +806,7 @@ String BfGNUMangler::Mangle(BfMethodInstance* methodInst) case BfUnaryOp_Out: methodName = "3out"; break; + default: break; } } } @@ -1520,6 +1523,7 @@ void BfMSMangler::Mangle(MangleContext& mangleContext, StringImpl& name, BfType* break; case BfTypeCode_Char32: name += "_U"; break; + default: break; } } else if (type->IsTypeInstance()) @@ -1825,6 +1829,7 @@ void BfMSMangler::Mangle(StringImpl& name, bool is64Bit, BfMethodInstance* metho case BfBinaryOp_As: methodName = "__as__"; break; + default: break; } switch (operatorDef->mOperatorDeclaration->mUnaryOp) @@ -1865,6 +1870,7 @@ void BfMSMangler::Mangle(StringImpl& name, bool is64Bit, BfMethodInstance* metho case BfUnaryOp_Out: methodName = "__out__"; break; + default: break; } switch (operatorDef->mOperatorDeclaration->mAssignOp) @@ -1902,6 +1908,7 @@ void BfMSMangler::Mangle(StringImpl& name, bool is64Bit, BfMethodInstance* metho case BfAssignmentOp_ExclusiveOr: methodName += "__a_xor__"; break; + default: break; } } diff --git a/IDEHelper/Compiler/BfModule.cpp b/IDEHelper/Compiler/BfModule.cpp index fd8a9c1d..2369c976 100644 --- a/IDEHelper/Compiler/BfModule.cpp +++ b/IDEHelper/Compiler/BfModule.cpp @@ -408,7 +408,7 @@ public: mModule->EmitAppendAlign(align, sizeMultiple); } - void Visit(BfAstNode* astNode) + void Visit(BfAstNode* astNode) override { mModule->VisitChild(astNode); } @@ -6181,6 +6181,7 @@ BfIRFunction BfModule::GetBuiltInFunc(BfBuiltInFuncType funcTypeId) funcType = mBfIRBuilder->CreateFunctionType(voidType, paramTypes); func = mBfIRBuilder->CreateFunction(funcType, BfIRLinkageType_External, "BfLoadSharedLibraries"); break; + default: break; } mBuiltInFuncs[(int)funcTypeId] = func; @@ -6264,6 +6265,7 @@ void BfModule::ResolveGenericParamConstraints(BfGenericParamInstance* genericPar case BfTypeCode_Char32: isValidTypeCode = true; break; + default: break; } if (isValidTypeCode) @@ -9134,6 +9136,7 @@ BfTypedValue BfModule::GetTypedValueFromConstant(BfConstant* constant, BfIRConst return castedTypedValue; } break; + default: break; } } BfIRValue irValue = ConstantToCurrent(constant, constHolder, wantType); @@ -15687,11 +15690,13 @@ void BfModule::ProcessMethod(BfMethodInstance* methodInstance, bool isInlineDup) // This is 'inner' (probably a closure) - use binding from outer function methodState.mGenericTypeBindings = prevMethodState.mPrevVal->mGenericTypeBindings; } - else if ((methodInstance->mIsUnspecialized) || (mCurTypeInstance->IsUnspecializedType()) && (!isGenericVariation)) + else if ((methodInstance->mIsUnspecialized) || + ((mCurTypeInstance->IsUnspecializedType()) && (!isGenericVariation))) { methodState.mGenericTypeBindings = &methodInstance->GetMethodInfoEx()->mGenericTypeBindings; } - else if ((((methodInstance->mMethodInfoEx != NULL) && ((int)methodInstance->mMethodInfoEx->mMethodGenericArguments.size() > dependentGenericStartIdx)) || ((mCurTypeInstance->IsGenericTypeInstance())) && (!isGenericVariation))) + else if ((((methodInstance->mMethodInfoEx != NULL) && ((int)methodInstance->mMethodInfoEx->mMethodGenericArguments.size() > dependentGenericStartIdx)) || + ((mCurTypeInstance->IsGenericTypeInstance()) && (!isGenericVariation)))) { unspecializedMethodInstance = GetUnspecializedMethodInstance(methodInstance); diff --git a/IDEHelper/Compiler/BfModule.h b/IDEHelper/Compiler/BfModule.h index d8c25731..e2ee2497 100644 --- a/IDEHelper/Compiler/BfModule.h +++ b/IDEHelper/Compiler/BfModule.h @@ -1528,7 +1528,7 @@ public: virtual void Visit(BfForEachStatement* forEachStmt) override; virtual void Visit(BfDeferStatement* deferStmt) override; virtual void Visit(BfBlock* block) override; - virtual void Visit(BfLabeledBlock* labeledBlock); + virtual void Visit(BfLabeledBlock* labeledBlock) override; virtual void Visit(BfRootNode* rootNode) override; virtual void Visit(BfInlineAsmStatement* asmStmt) override; diff --git a/IDEHelper/Compiler/BfModuleTypeUtils.cpp b/IDEHelper/Compiler/BfModuleTypeUtils.cpp index 4b2736b1..857dcae2 100644 --- a/IDEHelper/Compiler/BfModuleTypeUtils.cpp +++ b/IDEHelper/Compiler/BfModuleTypeUtils.cpp @@ -4407,6 +4407,7 @@ BfPrimitiveType* BfModule::GetPrimitiveType(BfTypeCode typeCode) case BfTypeCode_UIntUnknown: primType = (BfPrimitiveType*)ResolveTypeDef(mSystem->mTypeUIntUnknown); break; + default: break; } mContext->mPrimitiveTypes[typeCode] = primType; } @@ -4900,16 +4901,16 @@ BfType* BfModule::ResolveInnerType(BfType* outerType, BfTypeReference* typeRef, BfNamedTypeReference* namedTypeRef = NULL; BfGenericInstanceTypeRef* genericTypeRef = NULL; BfDirectStrTypeReference* directStrTypeRef = NULL; - if (namedTypeRef = BfNodeDynCast(typeRef)) + if ((namedTypeRef = BfNodeDynCast(typeRef))) { //TYPEDEF nestedTypeDef = namedTypeRef->mTypeDef; } - else if (genericTypeRef = BfNodeDynCast(typeRef)) + else if ((genericTypeRef = BfNodeDynCast(typeRef))) { namedTypeRef = BfNodeDynCast(genericTypeRef->mElementType); //TYPEDEF nestedTypeDef = namedTypeRef->mTypeDef; } - else if (directStrTypeRef = BfNodeDynCast(typeRef)) + else if ((directStrTypeRef = BfNodeDynCast(typeRef))) { // } @@ -5545,10 +5546,7 @@ BfType* BfModule::ResolveTypeResult(BfTypeReference* typeRef, BfType* resolvedTy //TODO: By only breaking out for "mIgnoreErrors", we classified elements (below) even when a resolvedTypeRef was not found! //Why did we have this mIgnoreErrors check in there? // if ((resolvedTypeRef == NULL) && (mIgnoreErrors)) -// { -// return NULL; -// } - if ((resolvedTypeRef == NULL) /*&& (mIgnoreErrors)*/) + if (resolvedTypeRef == NULL) { return NULL; } @@ -6637,7 +6635,7 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula { if (auto parentQualifiedTypeRef = BfNodeDynCast(mParentNodeEntry->mNode)) { - if (typeRef = parentQualifiedTypeRef->mLeft) + if (typeRef == parentQualifiedTypeRef->mLeft) { if ((resolveFlags & BfResolveTypeRefFlag_IgnoreLookupError) == 0) TypeRefNotFound(typeRef); @@ -6926,7 +6924,7 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula BfPrimitiveType* primType = new BfPrimitiveType(); primType->mTypeDef = typeDef; resolvedEntry->mValue = primType; - BF_ASSERT(BfResolvedTypeSet::Hash(primType, &lookupCtx, NULL) == resolvedEntry->mHash); + BF_ASSERT(BfResolvedTypeSet::Hash(primType, &lookupCtx, false) == resolvedEntry->mHash); InitType(primType, populateType); return ResolveTypeResult(typeRef, primType, populateType, resolveFlags); } @@ -7688,7 +7686,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl { auto fromRefType = (BfRefType*)typedVal.mType; auto toRefType = (BfRefType*)toType; - if ((fromRefType->mRefKind == toRefType->mRefKind)) + if (fromRefType->mRefKind == toRefType->mRefKind) checkUnderlying = true; else if ((fromRefType->mRefKind == BfRefType::RefKind_Ref) && (toRefType->mRefKind == BfRefType::RefKind_Mut)) checkUnderlying = true; // Allow a ref-to-mut implicit conversion @@ -7757,8 +7755,8 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl if (toType->IsVoidPtr()) { if ((genericParamInst->mGenericParamFlags & (BfGenericParamFlag_Class | BfGenericParamFlag_StructPtr)) || - (genericParamInst->mTypeConstraint != NULL) && - ((genericParamInst->mTypeConstraint->IsPointer()) || (genericParamInst->mTypeConstraint->IsObjectOrInterface()))) + ((genericParamInst->mTypeConstraint != NULL) && + ((genericParamInst->mTypeConstraint->IsPointer()) || (genericParamInst->mTypeConstraint->IsObjectOrInterface())))) { return true; } @@ -8068,6 +8066,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl { case BfTypeCode_UInt8: return true; + default: break; } break; case BfTypeCode_Char16: @@ -8075,6 +8074,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl { case BfTypeCode_Char8: return true; + default: break; } break; case BfTypeCode_Int16: @@ -8084,6 +8084,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl return true; case BfTypeCode_UInt8: return true; + default: break; } break; case BfTypeCode_UInt16: @@ -8091,6 +8092,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl { case BfTypeCode_UInt8: return true; + default: break; } break; case BfTypeCode_Int32: @@ -8106,6 +8108,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl case BfTypeCode_UInt8: case BfTypeCode_UInt16: return true; + default: break; } break; case BfTypeCode_Char32: @@ -8114,6 +8117,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl case BfTypeCode_Char8: case BfTypeCode_Char16: return true; + default: break; } break; case BfTypeCode_UInt32: @@ -8127,6 +8131,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl if (mCompiler->mSystem->mPtrSize == 4) return true; break; + default: break; } break; case BfTypeCode_Int64: @@ -8141,6 +8146,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl case BfTypeCode_UInt16: case BfTypeCode_UInt32: return true; + default: break; } break; case BfTypeCode_UInt64: @@ -8151,6 +8157,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl case BfTypeCode_UInt32: case BfTypeCode_UIntPtr: return true; + default: break; } break; case BfTypeCode_IntPtr: @@ -8168,6 +8175,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl if (mCompiler->mSystem->mPtrSize == 8) return true; break; + default: break; } break; case BfTypeCode_UIntPtr: @@ -8181,6 +8189,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl if (mCompiler->mSystem->mPtrSize == 8) return true; break; + default: break; } break; case BfTypeCode_Single: @@ -8200,6 +8209,7 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl case BfTypeCode_UIntPtr: case BfTypeCode_UIntUnknown: return true; + default: break; } break; case BfTypeCode_Double: @@ -8221,8 +8231,10 @@ bool BfModule::CanImplicitlyCast(BfTypedValue typedVal, BfType* toType, BfCastFl return true; case BfTypeCode_Single: return true; + default: break; } break; + default: break; } } @@ -8589,7 +8601,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp { auto fromRefType = (BfRefType*)typedVal.mType; auto toRefType = (BfRefType*)toType; - if ((fromRefType->mRefKind == toRefType->mRefKind)) + if (fromRefType->mRefKind == toRefType->mRefKind) checkUnderlying = true; else if ((fromRefType->mRefKind == BfRefType::RefKind_Ref) && (toRefType->mRefKind == BfRefType::RefKind_Mut)) checkUnderlying = true; // Allow a ref-to-mut implicit conversion @@ -8738,8 +8750,8 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp if (toType->IsVoidPtr()) { if ((genericParamInst->mGenericParamFlags & (BfGenericParamFlag_Class | BfGenericParamFlag_StructPtr)) || - (genericParamInst->mTypeConstraint != NULL) && - ((genericParamInst->mTypeConstraint->IsPointer()) || (genericParamInst->mTypeConstraint->IsObjectOrInterface()))) + ((genericParamInst->mTypeConstraint != NULL) && + ((genericParamInst->mTypeConstraint->IsPointer()) || (genericParamInst->mTypeConstraint->IsObjectOrInterface())))) { return GetDefaultValue(toType); } @@ -9183,6 +9195,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp { case BfTypeCode_Char8: allowCast = true; break; + default: break; } break; case BfTypeCode_Int16: @@ -9192,6 +9205,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp allowCast = true; break; case BfTypeCode_UInt8: allowCast = true; break; + default: break; } break; case BfTypeCode_UInt16: @@ -9199,6 +9213,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp { case BfTypeCode_UInt8: allowCast = true; break; + default: break; } break; case BfTypeCode_Int32: @@ -9214,6 +9229,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp case BfTypeCode_UInt8: case BfTypeCode_UInt16: allowCast = true; break; + default: break; } break; case BfTypeCode_Char32: @@ -9222,6 +9238,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp case BfTypeCode_Char8: case BfTypeCode_Char16: allowCast = true; break; + default: break; } break; case BfTypeCode_UInt32: @@ -9235,6 +9252,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp if (mCompiler->mSystem->mPtrSize == 4) allowCast = true; break; + default: break; } break; case BfTypeCode_Int64: @@ -9249,6 +9267,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp case BfTypeCode_UInt16: case BfTypeCode_UInt32: allowCast = true; break; + default: break; } break; case BfTypeCode_UInt64: @@ -9259,6 +9278,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp case BfTypeCode_UInt32: case BfTypeCode_UIntPtr: allowCast = true; break; + default: break; } break; case BfTypeCode_IntPtr: @@ -9281,6 +9301,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp if (mCompiler->mSystem->mPtrSize == 8) allowCast = true; break; + default: break; } break; case BfTypeCode_UIntPtr: @@ -9294,6 +9315,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp if (mCompiler->mSystem->mPtrSize == 8) allowCast = true; break; + default: break; } break; case BfTypeCode_Single: @@ -9313,6 +9335,7 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp case BfTypeCode_UIntPtr: case BfTypeCode_UIntUnknown: allowCast = true; break; + default: break; } break; case BfTypeCode_Double: @@ -9334,8 +9357,10 @@ BfIRValue BfModule::CastToValue(BfAstNode* srcNode, BfTypedValue typedVal, BfTyp allowCast = true; break; case BfTypeCode_Single: allowCast = true; break; + default: break; } break; + default: break; } if (explicitCast) @@ -10239,25 +10264,26 @@ void BfModule::VariantToString(StringImpl& str, const BfVariant& variant) str += StrFormat("%llu", variant.mInt64); break; case BfTypeCode_Single: - { - char cstr[64]; - ExactMinimalFloatToStr(variant.mSingle, cstr); - str += cstr; - if (strchr(cstr, '.') == NULL) - str += ".0f"; - else - str += "f"; - } - break; + { + char cstr[64]; + ExactMinimalFloatToStr(variant.mSingle, cstr); + str += cstr; + if (strchr(cstr, '.') == NULL) + str += ".0f"; + else + str += "f"; + } + break; case BfTypeCode_Double: - { - char cstr[64]; - ExactMinimalDoubleToStr(variant.mDouble, cstr); - str += cstr; - if (strchr(cstr, '.') == NULL) - str += ".0"; - } - break; + { + char cstr[64]; + ExactMinimalDoubleToStr(variant.mDouble, cstr); + str += cstr; + if (strchr(cstr, '.') == NULL) + str += ".0"; + } + break; + default: break; } } diff --git a/IDEHelper/Compiler/BfParser.cpp b/IDEHelper/Compiler/BfParser.cpp index 0152bdb3..2cbe5643 100644 --- a/IDEHelper/Compiler/BfParser.cpp +++ b/IDEHelper/Compiler/BfParser.cpp @@ -653,6 +653,7 @@ bool BfParser::EvaluatePreprocessor(BfExpression* expr) return EvaluatePreprocessor(binaryOp->mLeft) || EvaluatePreprocessor(binaryOp->mRight); case BfBinaryOp_ConditionalAnd: return EvaluatePreprocessor(binaryOp->mLeft) && EvaluatePreprocessor(binaryOp->mRight); + default: break; } } @@ -662,6 +663,7 @@ bool BfParser::EvaluatePreprocessor(BfExpression* expr) { case BfUnaryOp_Not: return !EvaluatePreprocessor(unaryOp->mExpression); + default: break; } } @@ -2154,7 +2156,7 @@ void BfParser::NextToken(int endIdx) { bool prevIsDot = (mSrcIdx > 1) && (mSrc[mSrcIdx - 2] == '.'); - if ((c == '-') /*&& ((mSrc[mSrcIdx] < '0') || mSrc[mSrcIdx] > '9')*/) + if (c == '-') { // Not a number! if (mSrc[mSrcIdx] == '-') @@ -2258,7 +2260,7 @@ void BfParser::NextToken(int endIdx) } else { - if (expSign = -1) + if (expSign == -1) expVal = -expVal; mSrcIdx--; break; @@ -2938,6 +2940,7 @@ void BfParser::NextToken(int endIdx) case UTF8PROC_CATEGORY_LO: case UTF8PROC_CATEGORY_NL: allowChar = true; + default: break; } } @@ -2981,6 +2984,7 @@ void BfParser::NextToken(int endIdx) case UTF8PROC_CATEGORY_PC: case UTF8PROC_CATEGORY_CF: isValidChar = true; + default: break; } } @@ -3134,29 +3138,30 @@ BfAstNode* BfParser::CreateNode() { switch (mSyntaxToken) { - case BfSyntaxToken_Token: - { - auto bfTokenNode = mAlloc->Alloc(); - bfTokenNode->Init(this); - bfTokenNode->SetToken(mToken); - return bfTokenNode; - } + case BfSyntaxToken_Token: + { + auto bfTokenNode = mAlloc->Alloc(); + bfTokenNode->Init(this); + bfTokenNode->SetToken(mToken); + return bfTokenNode; + } case BfSyntaxToken_Identifier: - { - //auto bfIdentifierNode = new BfIdentifierNode(); - auto bfIdentifierNode = mAlloc->Alloc(); - bfIdentifierNode->Init(this); - return bfIdentifierNode; - } + { + //auto bfIdentifierNode = new BfIdentifierNode(); + auto bfIdentifierNode = mAlloc->Alloc(); + bfIdentifierNode->Init(this); + return bfIdentifierNode; + } case BfSyntaxToken_Literal: - { - auto bfLiteralExpression = mAlloc->Alloc(); - bfLiteralExpression->Init(this); - bfLiteralExpression->mValue = mLiteral; - mLiteral.mTypeCode = BfTypeCode_None; - mLiteral.mWarnType = 0; - return bfLiteralExpression; - } + { + auto bfLiteralExpression = mAlloc->Alloc(); + bfLiteralExpression->Init(this); + bfLiteralExpression->mValue = mLiteral; + mLiteral.mTypeCode = BfTypeCode_None; + mLiteral.mWarnType = 0; + return bfLiteralExpression; + } + default: break; } return NULL; diff --git a/IDEHelper/Compiler/BfPrinter.h b/IDEHelper/Compiler/BfPrinter.h index fa2ea4eb..ce42cb2d 100644 --- a/IDEHelper/Compiler/BfPrinter.h +++ b/IDEHelper/Compiler/BfPrinter.h @@ -150,7 +150,7 @@ public: virtual void Visit(BfDynamicCastExpression* dynCastExpr) override; virtual void Visit(BfCastExpression* castExpr) override; virtual void Visit(BfDelegateBindExpression* invocationExpr) override; - virtual void Visit(BfLambdaBindExpression* lambdaBindExpr); + virtual void Visit(BfLambdaBindExpression* lambdaBindExpr) override; virtual void Visit(BfObjectCreateExpression* invocationExpr) override; virtual void Visit(BfBoxExpression* boxExpr) override; virtual void Visit(BfInvocationExpression* invocationExpr) override; diff --git a/IDEHelper/Compiler/BfReducer.cpp b/IDEHelper/Compiler/BfReducer.cpp index a063532b..f42ea741 100644 --- a/IDEHelper/Compiler/BfReducer.cpp +++ b/IDEHelper/Compiler/BfReducer.cpp @@ -439,6 +439,7 @@ bool BfReducer::IsTypeReference(BfAstNode* checkNode, BfToken successToken, int* // Failed done = true; break; + default: break; } if (done) @@ -1001,6 +1002,7 @@ bool BfReducer::IsLocalMethod(BfAstNode* nameNode) return false; case BfToken_Where: // Always denotes a local method return true; + default: break; } } } @@ -1889,6 +1891,7 @@ BfExpression* BfReducer::CreateExpression(BfAstNode* node, CreateExprFlags creat case BfToken_StrideOf: typeAttrExpr = mAlloc->Alloc(); break; + default: break; } ReplaceNode(tokenNode, typeAttrExpr); @@ -2013,7 +2016,7 @@ BfExpression* BfReducer::CreateExpression(BfAstNode* node, CreateExprFlags creat MEMBER_SET_CHECKED(delegateBindExpr, mTarget, expr); auto nextNode = mVisitorPos.GetNext(); - if (tokenNode = BfNodeDynCast(nextNode)) + if ((tokenNode = BfNodeDynCast(nextNode))) { if (tokenNode->GetToken() == BfToken_LChevron) { @@ -3313,7 +3316,8 @@ BfSwitchStatement* BfReducer::CreateSwitchStatement(BfTokenNode* tokenNode) BfToken token = BfToken_None; if (tokenNode != NULL) token = tokenNode->GetToken(); - if ((tokenNode == NULL) || (token != BfToken_Case) && (token != BfToken_When) && (token != BfToken_Default)) + if ((tokenNode == NULL) || + ((token != BfToken_Case) && (token != BfToken_When) && (token != BfToken_Default))) { Fail("Expected 'case'", child); return switchStatement; @@ -3618,7 +3622,7 @@ BfAstNode* BfReducer::DoCreateStatement(BfAstNode* node, CreateStmtFlags createS MEMBER_SET(deleteStmt, mDeleteToken, tokenNode); auto nextNode = mVisitorPos.GetNext(); - if (tokenNode = BfNodeDynCast(nextNode)) + if ((tokenNode = BfNodeDynCast(nextNode))) { if (tokenNode->GetToken() == BfToken_Append) { @@ -3869,7 +3873,7 @@ BfAstNode* BfReducer::DoCreateStatement(BfAstNode* node, CreateStmtFlags createS MEMBER_SET(methodDecl, mNameNode, nameNode); auto nextNode = mVisitorPos.GetNext(); - if (tokenNode = BfNodeDynCast(nextNode)) + if ((tokenNode = BfNodeDynCast(nextNode))) { if (tokenNode->GetToken() == BfToken_LChevron) { @@ -4087,7 +4091,7 @@ BfAstNode* BfReducer::DoCreateStatement(BfAstNode* node, CreateStmtFlags createS bool isValidFinish = false; BfTokenNode* tokenNode; - if (tokenNode = BfNodeDynCast(mVisitorPos.GetNext())) + if ((tokenNode = BfNodeDynCast(mVisitorPos.GetNext()))) { int token = tokenNode->GetToken(); if ((token == BfToken_AssignEquals) || (token == BfToken_Semicolon) || (token == BfToken_Comma)) @@ -4352,7 +4356,7 @@ BfAstNode* BfReducer::CreateStatement(BfAstNode* node, CreateStmtFlags createStm mPrevStmtHadError = false; // Must be an expression. Always set CreateExprFlags_NoCaseExpr, to keep ending statements in a switch case to look like case expressions - auto expr = CreateExpression(node, (CreateExprFlags)(createStmtFlags & CreateStmtFlags_To_CreateExprFlags_Mask | CreateExprFlags_NoCaseExpr)); + auto expr = CreateExpression(node, (CreateExprFlags)((createStmtFlags & CreateStmtFlags_To_CreateExprFlags_Mask) | CreateExprFlags_NoCaseExpr)); auto nextNode = mVisitorPos.GetNext(); if (nextNode != NULL) @@ -4821,7 +4825,7 @@ BfTypeReference* BfReducer::DoCreateTypeRef(BfAstNode* firstNode, bool parseArra MEMBER_SET(qualifiedTypeRef, mRight, typeRef); nextNode = mVisitorPos.GetNext(); - if (tokenNode = BfNodeDynCast(nextNode)) + if ((tokenNode = BfNodeDynCast(nextNode))) { if (tokenNode->GetToken() == BfToken_Dot) { @@ -5727,7 +5731,7 @@ BfAstNode* BfReducer::ReadTypeMember(BfTokenNode* tokenNode, int depth) MEMBER_SET(methodDecl, mNameNode, nameNode); auto nextNode = mVisitorPos.GetNext(); - if (tokenNode = BfNodeDynCast(nextNode)) + if ((tokenNode = BfNodeDynCast(nextNode))) { if (tokenNode->GetToken() == BfToken_LChevron) { @@ -6903,7 +6907,7 @@ BfDelegateBindExpression* BfReducer::CreateDelegateBindExpression(BfAstNode* all MEMBER_SET_CHECKED(delegateBindExpr, mTarget, expr); auto nextNode = mVisitorPos.GetNext(); - if (tokenNode = BfNodeDynCast(nextNode)) + if ((tokenNode = BfNodeDynCast(nextNode))) { if (tokenNode->GetToken() == BfToken_LChevron) { @@ -7446,7 +7450,7 @@ BfMemberReferenceExpression* BfReducer::CreateMemberReferenceExpression(BfAstNod } } - if (tokenNode = BfNodeDynCast(mVisitorPos.GetNext())) + if ((tokenNode = BfNodeDynCast(mVisitorPos.GetNext()))) { if (tokenNode->GetToken() == BfToken_LBracket) { @@ -7507,7 +7511,7 @@ BfTupleExpression* BfReducer::CreateTupleExpression(BfTokenNode* node, BfExpress { // Failed, but can we pull in the closing rparen? auto nextNode = mVisitorPos.GetNext(); - if (closeParenToken = BfNodeDynCast(nextNode)) + if ((closeParenToken = BfNodeDynCast(nextNode))) { if (closeParenToken->GetToken() == BfToken_RParen) { @@ -7691,7 +7695,7 @@ BfAstNode* BfReducer::CreateTopLevelObject(BfTokenNode* tokenNode, BfAttributeDi { // Failure, but eat any following dot for autocompletion purposes auto nextNode = mVisitorPos.GetNext(); - if (tokenNode = BfNodeDynCast(nextNode)) + if ((tokenNode = BfNodeDynCast(nextNode))) { if (tokenNode->GetToken() == BfToken_Dot) { @@ -7916,7 +7920,7 @@ BfAstNode* BfReducer::CreateTopLevelObject(BfTokenNode* tokenNode, BfAttributeDi MEMBER_SET_CHECKED(typeDeclaration, mNameNode, name); auto nextNode = mVisitorPos.GetNext(); - if (tokenNode = BfNodeDynCast(nextNode)) + if ((tokenNode = BfNodeDynCast(nextNode))) { if (tokenNode->GetToken() == BfToken_LChevron) { @@ -8100,9 +8104,10 @@ BfAstNode* BfReducer::CreateTopLevelObject(BfTokenNode* tokenNode, BfAttributeDi HandleTypeDeclaration(typeDeclaration, attributes); } - return typeDeclaration; + return typeDeclaration; } break; + default: break; } if (isSimpleEnum) @@ -8807,7 +8812,7 @@ bool BfReducer::ParseMethod(BfMethodDeclaration* methodDeclaration, SizedArrayIm auto typeDecl = mCurTypeDecl; auto nextNode = mVisitorPos.GetNext(); - if (tokenNode = BfNodeDynCast(nextNode)) + if ((tokenNode = BfNodeDynCast(nextNode))) { if (tokenNode->GetToken() == BfToken_Mut) { @@ -8822,7 +8827,7 @@ bool BfReducer::ParseMethod(BfMethodDeclaration* methodDeclaration, SizedArrayIm } } - if (tokenNode = BfNodeDynCast(nextNode)) + if ((tokenNode = BfNodeDynCast(nextNode))) { if (tokenNode->GetToken() == BfToken_Where) { @@ -9102,6 +9107,7 @@ BfGenericConstraintsDeclaration* BfReducer::CreateGenericConstraintsDeclaration( case BfToken_Var: addToConstraint = true; break; + default: break; } if (addToConstraint) @@ -9115,7 +9121,7 @@ BfGenericConstraintsDeclaration* BfReducer::CreateGenericConstraintsDeclaration( { addToConstraint = true; nextNode = mVisitorPos.GetNext(); - if (tokenNode = BfNodeDynCast(nextNode)) + if ((tokenNode = BfNodeDynCast(nextNode))) { if (tokenNode->GetToken() == BfToken_Star) { diff --git a/IDEHelper/Compiler/BfResolvedTypeUtils.h b/IDEHelper/Compiler/BfResolvedTypeUtils.h index 65434704..cbdbaf94 100644 --- a/IDEHelper/Compiler/BfResolvedTypeUtils.h +++ b/IDEHelper/Compiler/BfResolvedTypeUtils.h @@ -538,11 +538,11 @@ public: (mTypeDef->mTypeCode == BfTypeCode_Int32) || (mTypeDef->mTypeCode == BfTypeCode_Int64) || (mTypeDef->mTypeCode == BfTypeCode_IntPtr) || (mTypeDef->mTypeCode == BfTypeCode_IntUnknown); } virtual bool IsIntUnknown() override { return (mTypeDef->mTypeCode == BfTypeCode_IntUnknown) || (mTypeDef->mTypeCode == BfTypeCode_UIntUnknown); } - virtual bool IsChar() { return (mTypeDef->mTypeCode == BfTypeCode_Char8) || (mTypeDef->mTypeCode == BfTypeCode_Char16) || (mTypeDef->mTypeCode == BfTypeCode_Char32); } + virtual bool IsChar() override { return (mTypeDef->mTypeCode == BfTypeCode_Char8) || (mTypeDef->mTypeCode == BfTypeCode_Char16) || (mTypeDef->mTypeCode == BfTypeCode_Char32); } virtual bool IsFloat() override { return (mTypeDef->mTypeCode == BfTypeCode_Single) || (mTypeDef->mTypeCode == BfTypeCode_Double); } virtual bool IsNull() override { return mTypeDef->mTypeCode == BfTypeCode_NullPtr; } virtual bool IsVoid() override { return mTypeDef->mTypeCode == BfTypeCode_None; } - virtual bool CanBeValuelessType() { return mTypeDef->mTypeCode == BfTypeCode_None; } + virtual bool CanBeValuelessType() override { return mTypeDef->mTypeCode == BfTypeCode_None; } virtual bool IsValuelessType() override { return mTypeDef->mTypeCode == BfTypeCode_None; } virtual bool IsSelf() override { return mTypeDef->mTypeCode == BfTypeCode_Self; } virtual bool IsDot() override { return mTypeDef->mTypeCode == BfTypeCode_Dot; } @@ -921,7 +921,7 @@ public: BfType* mElementType; virtual bool IsRetTypeType() override { return true; } - virtual bool CanBeValuelessType() { return true; } + virtual bool CanBeValuelessType() override { return true; } virtual bool IsValuelessType() override { return true; } virtual bool IsUnspecializedType() override { return mElementType->IsUnspecializedType(); } @@ -1581,16 +1581,16 @@ public: ~BfTypeInstance(); - virtual BfModule* GetModule() { return mModule; } + virtual BfModule* GetModule() override { return mModule; } virtual BfTypeInstance* ToTypeInstance() override { return this; } virtual bool IsDependentOnUnderlyingType() override { return true; } virtual BfPrimitiveType* ToPrimitiveType() override { return GetUnderlyingType()->ToPrimitiveType(); } - virtual bool HasWrappedRepresentation() { return IsTypedPrimitive(); } + virtual bool HasWrappedRepresentation() override { return IsTypedPrimitive(); } int GetEndingInstanceAlignment() { if (mInstSize % mInstAlign == 0) return mInstAlign; return mInstSize % mInstAlign; } virtual bool HasTypeFailed() override { return mTypeFailed; } virtual bool IsReified() override { return mIsReified; } - virtual bool NeedsExplicitAlignment() { return !IsSizeAligned() || mIsPacked; } + virtual bool NeedsExplicitAlignment() override { return !IsSizeAligned() || mIsPacked; } virtual bool IsDataIncomplete() override { return ((mTypeIncomplete) || (mBaseTypeMayBeIncomplete)) && (!mNeedsMethodProcessing); } virtual bool IsIncomplete() override { return (mTypeIncomplete) || (mBaseTypeMayBeIncomplete); } virtual bool IsSplattable() override { BF_ASSERT((mInstSize >= 0) || (!IsComposite())); return mIsSplattable; } @@ -1616,7 +1616,7 @@ public: //virtual bool IsValuelessType() override { return (mIsTypedPrimitive) && (mInstSize == 0); } virtual bool CanBeValuelessType() override { return (mTypeDef->mTypeCode == BfTypeCode_Struct) || (mTypeDef->mTypeCode == BfTypeCode_Enum); } virtual bool IsValuelessType() override; - virtual bool HasPackingHoles() { return mHasPackingHoles; } + virtual bool HasPackingHoles() override { return mHasPackingHoles; } virtual bool IsTypeMemberAccessible(BfTypeDef* declaringTypeDef, BfTypeDef* activeTypeDef) override; virtual bool IsTypeMemberAccessible(BfTypeDef* declaringTypeDef, BfProject* curProject) override; virtual bool WantsGCMarking() override; @@ -1684,7 +1684,7 @@ public: virtual bool IsUnspecializedType() override { return mElementType->IsUnspecializedType(); } virtual bool IsUnspecializedTypeVariation() override { return mElementType->IsUnspecializedTypeVariation(); } - virtual BfTypeInstance* GetImplBaseType() { return (mBoxedBaseType != NULL) ? mBoxedBaseType : mBaseType; } + virtual BfTypeInstance* GetImplBaseType() override { return (mBoxedBaseType != NULL) ? mBoxedBaseType : mBaseType; } bool IsBoxedStructPtr() { @@ -1906,7 +1906,7 @@ public: public: virtual bool IsWrappableType() override { return true; } - virtual bool IsReified() { return mElementType->IsReified(); } + virtual bool IsReified() override { return mElementType->IsReified(); } virtual bool IsPointer() override { return true; } virtual bool IsIntPtrable() override { return true; } virtual bool IsStructPtr() override { return mElementType->IsStruct(); } @@ -1951,7 +1951,7 @@ public: virtual bool IsComposite() override { return true; } virtual bool IsMethodRef() override { return true; } virtual bool IsSplattable() override { return true; } - virtual int GetSplatCount() { return (int)mDataToParamIdx.mSize; } + virtual int GetSplatCount() override { return (int)mDataToParamIdx.mSize; } virtual bool IsOnDemand() override { return true; } virtual bool IsTemporary() override { return true; } @@ -1990,7 +1990,7 @@ public: virtual bool IsDataIncomplete() override { CheckElement(); return mDefineState < BfTypeDefineState_Defined; } virtual bool IsIncomplete() override { CheckElement(); return mDefineState < BfTypeDefineState_Defined; } - virtual bool IsReified() { return mElementType->IsReified(); } + virtual bool IsReified() override { return mElementType->IsReified(); } virtual bool IsRef() override { return true; } virtual bool IsDependentOnUnderlyingType() override { return true; } @@ -2027,17 +2027,17 @@ public: bool mWantsGCMarking; public: - virtual bool NeedsExplicitAlignment() { return mElementType->NeedsExplicitAlignment(); } + virtual bool NeedsExplicitAlignment() override { return mElementType->NeedsExplicitAlignment(); } virtual bool IsSizedArray() override { return true; } virtual bool IsWrappableType() override { return true; } virtual bool IsValueType() override { return true; } // Is a type of struct - virtual bool IsValueTypeOrValueTypePtr() { return true; } + virtual bool IsValueTypeOrValueTypePtr() override { return true; } virtual bool IsComposite() override { return true; } virtual bool IsStruct() override { return false; } // But IsStruct infers a definition, which it does not have virtual bool IsStructOrStructPtr() override { return false; } - virtual bool IsReified() { return mElementType->IsReified(); } + virtual bool IsReified() override { return mElementType->IsReified(); } virtual bool IsDependentOnUnderlyingType() override { return true; } virtual BfType* GetUnderlyingType() override { return mElementType; } @@ -2056,17 +2056,17 @@ public: BfType* mElementCountSource; public: - virtual bool NeedsExplicitAlignment() { return mElementType->NeedsExplicitAlignment(); } + virtual bool NeedsExplicitAlignment() override { return mElementType->NeedsExplicitAlignment(); } virtual bool IsUnknownSizedArray() override { return true; } virtual bool IsWrappableType() override { return true; } virtual bool IsValueType() override { return true; } // Is a type of struct - virtual bool IsValueTypeOrValueTypePtr() { return true; } + virtual bool IsValueTypeOrValueTypePtr() override { return true; } virtual bool IsComposite() override { return true; } virtual bool IsStruct() override { return false; } // But IsStruct infers a definition, which it does not have virtual bool IsStructOrStructPtr() override { return false; } - virtual bool IsReified() { return mElementType->IsReified(); } + virtual bool IsReified() override { return mElementType->IsReified(); } virtual bool IsDependentOnUnderlyingType() override { return true; } virtual BfType* GetUnderlyingType() override { return mElementType; } diff --git a/IDEHelper/Compiler/BfSourceClassifier.cpp b/IDEHelper/Compiler/BfSourceClassifier.cpp index afdcb2d3..b858e76e 100644 --- a/IDEHelper/Compiler/BfSourceClassifier.cpp +++ b/IDEHelper/Compiler/BfSourceClassifier.cpp @@ -382,7 +382,7 @@ void BfSourceClassifier::Visit(BfInvocationExpression* invocationExpr) VisitChild(qualifiedName->mDot); identifier = qualifiedName->mRight; } - else if (identifier = BfNodeDynCast(target)) + else if ((identifier = BfNodeDynCast(target))) { // Leave as BfAttributedIdentifierNode if that's the case identifier = target; diff --git a/IDEHelper/Compiler/BfSystem.cpp b/IDEHelper/Compiler/BfSystem.cpp index d6295a9c..a8248ea6 100644 --- a/IDEHelper/Compiler/BfSystem.cpp +++ b/IDEHelper/Compiler/BfSystem.cpp @@ -2043,6 +2043,7 @@ bool BfSystem::DoesLiteralFit(BfTypeCode typeCode, int64 value) return (value >= 0) && (value < 0x100000000LL); case BfTypeCode_UInt64: return (value >= 0); + default: break; } return false; diff --git a/IDEHelper/LinuxDebugger.cpp b/IDEHelper/LinuxDebugger.cpp index 431f6cf7..4c1ef527 100644 --- a/IDEHelper/LinuxDebugger.cpp +++ b/IDEHelper/LinuxDebugger.cpp @@ -1,29 +1,27 @@ -#include "BeefySysLib/Common.h" -#include "LinuxDebugger.h" -#include "Debugger.h" -#include "X86Target.h" - -namespace Beefy -{ - class DbgMiniDump; -} - -USING_NS_BF_DBG; -USING_NS_BF; - - -NS_BF_BEGIN - -Beefy::Debugger* CreateDebugger32(DebugManager* debugManager, DbgMiniDump* miniDump) -{ - return NULL; -} - -Beefy::Debugger* CreateDebugger64(DebugManager* debugManager, DbgMiniDump* miniDump) -{ - if (gX86Target == NULL) - gX86Target = new X86Target(); - return NULL; -} - +#include "BeefySysLib/Common.h" +#include "LinuxDebugger.h" +#include "Debugger.h" +#include "X86Target.h" + +namespace Beefy +{ + class DbgMiniDump; +} + +USING_NS_BF_DBG; +USING_NS_BF; +NS_BF_BEGIN + +Beefy::Debugger* CreateDebugger32(DebugManager* debugManager, DbgMiniDump* miniDump) +{ + return NULL; +} + +Beefy::Debugger* CreateDebugger64(DebugManager* debugManager, DbgMiniDump* miniDump) +{ + if (gX86Target == NULL) + gX86Target = new X86Target(); + return NULL; +} + NS_BF_END \ No newline at end of file diff --git a/bin/build.sh b/bin/build.sh index b857ea4c..204b9789 100755 --- a/bin/build.sh +++ b/bin/build.sh @@ -39,20 +39,29 @@ cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo ../ cmake --build . cd ../IDE/dist -if [ ! -L libBeefRT_d.so ]; then - ln -s ../../jbuild_d/Debug/bin/libBeefRT_d.so libBeefRT_d.so - ln -s ../../jbuild_d/Debug/bin/libBeefySysLib_d.so libBeefySysLib_d.so - ln -s ../../jbuild_d/Debug/bin/libIDEHelper_d.so libIDEHelper_d.so - ln -s ../../jbuild/Release/bin/libBeefRT.so libBeefRT.so - ln -s ../../jbuild/Release/bin/libBeefySysLib.so libBeefySysLib.so - ln -s ../../jbuild/Release/bin/libIDEHelper.so libIDEHelper.so +if [[ "$OSTYPE" == "darwin"* ]]; then + LIBEXT=dylib + LINKOPTS= +else + LIBEXT=so + LINKOPTS=-ltinfo +fi + +if [ ! -L libBeefRT_d.$LIBEXT ]; then + ln -s ../../jbuild_d/Debug/bin/libBeefRT_d.$LIBEXT libBeefRT_d.$LIBEXT + ln -s ../../jbuild_d/Debug/bin/libBeefySysLib_d.$LIBEXT libBeefySysLib_d.$LIBEXT + ln -s ../../jbuild_d/Debug/bin/libIDEHelper_d.$LIBEXT libIDEHelper_d.$LIBEXT + + ln -s ../../jbuild/Release/bin/libBeefRT.$LIBEXT libBeefRT.$LIBEXT + ln -s ../../jbuild/Release/bin/libBeefySysLib.$LIBEXT libBeefySysLib.$LIBEXT + ln -s ../../jbuild/Release/bin/libIDEHelper.$LIBEXT libIDEHelper.$LIBEXT fi ### DEBUG ### echo Building BeefBuild_bootd -../../jbuild_d/Debug/bin/BeefBoot --out="BeefBuild_bootd" --src=../src --src=../../BeefBuild/src --src=../../BeefLibs/corlib/src --src=../../BeefLibs/Beefy2D/src --define=CLI --define=DEBUG --startup=BeefBuild.Program --linkparams="./libBeefRT_d.so ./libIDEHelper_d.so ./libBeefySysLib_d.so ../../extern/llvm_linux_8_0_0/lib/libLLVMCore.a ../../extern/llvm_linux_8_0_0/lib/libLLVMMC.a ../../extern/llvm_linux_8_0_0/lib/libLLVMMCParser.a ../../extern/llvm_linux_8_0_0/lib/libLLVMCodeGen.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86Disassembler.a ../../extern/llvm_linux_8_0_0/lib/libLLVMMCDisassembler.a ../../extern/llvm_linux_8_0_0/lib/libLLVMSupport.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86Info.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86Utils.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86AsmPrinter.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86Desc.a ../../extern/llvm_linux_8_0_0/lib/libLLVMObject.a ../../extern/llvm_linux_8_0_0/lib/libLLVMBitReader.a ../../extern/llvm_linux_8_0_0/lib/libLLVMAsmParser.a ../../extern/llvm_linux_8_0_0/lib/libLLVMTarget.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86CodeGen.a ../../extern/llvm_linux_8_0_0/lib/libLLVMScalarOpts.a ../../extern/llvm_linux_8_0_0/lib/libLLVMInstCombine.a ../../extern/llvm_linux_8_0_0/lib/libLLVMSelectionDAG.a ../../extern/llvm_linux_8_0_0/lib/libLLVMProfileData.a ../../extern/llvm_linux_8_0_0/lib/libLLVMTransformUtils.a ../../extern/llvm_linux_8_0_0/lib/libLLVMAnalysis.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86AsmParser.a ../../extern/llvm_linux_8_0_0/lib/libLLVMAsmPrinter.a ../../extern/llvm_linux_8_0_0/lib/libLLVMBitWriter.a ../../extern/llvm_linux_8_0_0/lib/libLLVMVectorize.a ../../extern/llvm_linux_8_0_0/lib/libLLVMipo.a ../../extern/llvm_linux_8_0_0/lib/libLLVMInstrumentation.a ../../extern/llvm_linux_8_0_0/lib/libLLVMDebugInfoDWARF.a ../../extern/llvm_linux_8_0_0/lib/libLLVMDebugInfoPDB.a ../../extern/llvm_linux_8_0_0/lib/libLLVMDebugInfoCodeView.a ../../extern/llvm_linux_8_0_0/lib/libLLVMGlobalISel.a ../../extern/llvm_linux_8_0_0/lib/libLLVMBinaryFormat.a ../../extern/llvm_linux_8_0_0/lib/libLLVMDemangle.a -ltinfo -Wl,-rpath -Wl,\$ORIGIN" +../../jbuild_d/Debug/bin/BeefBoot --out="BeefBuild_bootd" --src=../src --src=../../BeefBuild/src --src=../../BeefLibs/corlib/src --src=../../BeefLibs/Beefy2D/src --define=CLI --define=DEBUG --startup=BeefBuild.Program --linkparams="./libBeefRT_d.$LIBEXT ./libIDEHelper_d.$LIBEXT ./libBeefySysLib_d.$LIBEXT ../../extern/llvm_linux_8_0_0/lib/libLLVMCore.a ../../extern/llvm_linux_8_0_0/lib/libLLVMMC.a ../../extern/llvm_linux_8_0_0/lib/libLLVMMCParser.a ../../extern/llvm_linux_8_0_0/lib/libLLVMCodeGen.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86Disassembler.a ../../extern/llvm_linux_8_0_0/lib/libLLVMMCDisassembler.a ../../extern/llvm_linux_8_0_0/lib/libLLVMSupport.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86Info.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86Utils.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86AsmPrinter.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86Desc.a ../../extern/llvm_linux_8_0_0/lib/libLLVMObject.a ../../extern/llvm_linux_8_0_0/lib/libLLVMBitReader.a ../../extern/llvm_linux_8_0_0/lib/libLLVMAsmParser.a ../../extern/llvm_linux_8_0_0/lib/libLLVMTarget.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86CodeGen.a ../../extern/llvm_linux_8_0_0/lib/libLLVMScalarOpts.a ../../extern/llvm_linux_8_0_0/lib/libLLVMInstCombine.a ../../extern/llvm_linux_8_0_0/lib/libLLVMSelectionDAG.a ../../extern/llvm_linux_8_0_0/lib/libLLVMProfileData.a ../../extern/llvm_linux_8_0_0/lib/libLLVMTransformUtils.a ../../extern/llvm_linux_8_0_0/lib/libLLVMAnalysis.a ../../extern/llvm_linux_8_0_0/lib/libLLVMX86AsmParser.a ../../extern/llvm_linux_8_0_0/lib/libLLVMAsmPrinter.a ../../extern/llvm_linux_8_0_0/lib/libLLVMBitWriter.a ../../extern/llvm_linux_8_0_0/lib/libLLVMVectorize.a ../../extern/llvm_linux_8_0_0/lib/libLLVMipo.a ../../extern/llvm_linux_8_0_0/lib/libLLVMInstrumentation.a ../../extern/llvm_linux_8_0_0/lib/libLLVMDebugInfoDWARF.a ../../extern/llvm_linux_8_0_0/lib/libLLVMDebugInfoPDB.a ../../extern/llvm_linux_8_0_0/lib/libLLVMDebugInfoCodeView.a ../../extern/llvm_linux_8_0_0/lib/libLLVMGlobalISel.a ../../extern/llvm_linux_8_0_0/lib/libLLVMBinaryFormat.a ../../extern/llvm_linux_8_0_0/lib/libLLVMDemangle.a $LINKOPTS -Wl,-rpath -Wl,\$ORIGIN" echo Building BeefBuild_d ./BeefBuild_bootd -clean -proddir=../../BeefBuild -config=Debug -platform=Linux64 #./BeefBuild_d -proddir=../../TestApp @@ -63,7 +72,7 @@ echo Testing IDEHelper/Tests in BeefBuild_d ### RELEASE ### echo Building BeefBuild_boot -../../jbuild/Release/bin/BeefBoot --out="BeefBuild_boot" --src=../src --src=../../BeefBuild/src --src=../../BeefLibs/corlib/src --src=../../BeefLibs/Beefy2D/src --define=CLI --define=DEBUG --startup=BeefBuild.Program --linkparams="./libBeefRT.so ./libIDEHelper.so ./libBeefySysLib.so ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMCore.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMMC.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMMCParser.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMCodeGen.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86Disassembler.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMMCDisassembler.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMSupport.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86Info.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86Utils.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86AsmPrinter.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86Desc.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMObject.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMBitReader.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMAsmParser.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMTarget.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86CodeGen.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMScalarOpts.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMInstCombine.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMSelectionDAG.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMProfileData.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMTransformUtils.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMAnalysis.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86AsmParser.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMAsmPrinter.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMBitWriter.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMVectorize.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMipo.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMInstrumentation.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMDebugInfoDWARF.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMDebugInfoPDB.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMDebugInfoCodeView.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMGlobalISel.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMBinaryFormat.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMDemangle.a -ltinfo -Wl,-rpath -Wl,\$ORIGIN" +../../jbuild/Release/bin/BeefBoot --out="BeefBuild_boot" --src=../src --src=../../BeefBuild/src --src=../../BeefLibs/corlib/src --src=../../BeefLibs/Beefy2D/src --define=CLI --define=DEBUG --startup=BeefBuild.Program --linkparams="./libBeefRT.$LIBEXT ./libIDEHelper.$LIBEXT ./libBeefySysLib.$LIBEXT ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMCore.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMMC.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMMCParser.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMCodeGen.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86Disassembler.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMMCDisassembler.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMSupport.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86Info.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86Utils.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86AsmPrinter.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86Desc.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMObject.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMBitReader.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMAsmParser.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMTarget.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86CodeGen.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMScalarOpts.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMInstCombine.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMSelectionDAG.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMProfileData.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMTransformUtils.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMAnalysis.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMX86AsmParser.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMAsmPrinter.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMBitWriter.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMVectorize.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMipo.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMInstrumentation.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMDebugInfoDWARF.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMDebugInfoPDB.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMDebugInfoCodeView.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMGlobalISel.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMBinaryFormat.a ../../extern/llvm_linux_rel_8_0_0/lib/libLLVMDemangle.a $LINKOPTS -Wl,-rpath -Wl,\$ORIGIN" echo Building BeedBuild ./BeefBuild_boot -clean -proddir=../../BeefBuild -config=Release -platform=Linux64 #./BeefBuild_d -proddir=../../TestApp diff --git a/extern/.DS_Store b/extern/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..8cb383c57b175c20eedebbb20fa9ab33c7a2ce99 GIT binary patch literal 6148 zcmeHK!AiqG5PegFL_{fG^q8X;MQ?(aQ0l?6A5fb_s1l7dt>;|)2Y=o+_Wm1kv@ajXlP{C@`Y z-9^Z;#u8=k{athJ^vj7$B*ub%FR1Z~2b2T<&z}F0`rr-EIAg>T6`mNEV}%*6s28e5 zotIfvmHdEk*apmyajQp;3!Jk*$Ey2qa@^bOU_)$;MKAKb7a8$^Dn4XCeNE@%NBSI^ z7z4(DF|ZvB=#fi__dQx`3>X8(K+Axh4+&K<4cK^eM+X~M0uUpbov`nI{fUVhh-tva zBP|s1p+p}lp~R3-IfxJEd>Z^4k3JmYcIG-^X9*RGgu+7-=MG6dT5Aj#16>Ao{BW%I z|IOz5zZ+yDW55{LDh4E)-c2V=Dcr4t