Binary option template - odysayelife.com

Powerful Binary Options 5M Template + Free Download Upto 90% Winnings

Powerful Binary Options 5M Template + Free Download Upto 90% Winnings submitted by BinaryOptionsForward to BinaryTrain [link] [comments]

The Perfect Indikators for Trading Binary Options in Metatrader as Templates

submitted by janni325 to ethtrader [link] [comments]

Best Practices for A C Programmer

Hi all,
Long time C programmer here, primarily working in the embedded industry (particularly involving safety-critical code). I've been a lurker on this sub for a while but I'm hoping to ask some questions regarding best practices. I've been trying to start using c++ on a lot of my work - particularly taking advantage of some of the code-reuse and power of C++ (particularly constexpr, some loose template programming, stronger type checking, RAII etc).
I would consider myself maybe an 8/10 C programmer but I would conservatively maybe rate myself as 3/10 in C++ (with 1/10 meaning the absolute minmum ability to write, google syntax errata, diagnose, and debug a program). Perhaps I should preface the post that I am more than aware that C is by no means a subset of C++ and there are many language constructs permitted in one that are not in the other.
In any case, I was hoping to get a few answers regarding best practices for c++. Keep in mind that the typical target device I work with does not have a heap of any sort and so a lot of the features that constitute "modern" C++ (non-initialization use of dynamic memory, STL meta-programming, hash-maps, lambdas (as I currently understand them) are a big no-no in terms of passing safety review.

When do I overload operators inside a class as opposed to outisde?

... And what are the arguments foagainst each paradigm? See below:
/* Overload example 1 (overloaded inside class) */ class myclass { private: unsigned int a; unsigned int b; public: myclass(void); unsigned int get_a(void) const; bool operator==(const myclass &rhs); }; bool myclass::operator==(const myclass &rhs) { if (this == &rhs) { return true; } else { if (this->a == rhs.a && this->b == rhs.b) { return true; } } return false; } 
As opposed to this:
/* Overload example 2 (overloaded outside of class) */ class CD { private: unsigned int c; unsigned int d; public: CD(unsigned int _c, unsigned int _d) : d(_d), c(_c) {}; /* CTOR */ unsigned int get_c(void) const; /* trival getters */ unsigned int get_d(void) const; /* trival getters */ }; /* In this implementation, If I don't make the getters (get_c, get_d) constant, * it won't compile despite their access specifiers being public. * * It seems like the const keyword in C++ really should be interpretted as * "read-only AND no side effects" rather than just read only as in C. * But my current understanding may just be flawed... * * My confusion is as follows: The function args are constant references * so why do I have to promise that the function methods have no side-effects on * the private object members? Is this something specific to the == operator? */ bool operator==(const CD & lhs, const CD & rhs) { if(&lhs == &rhs) return true; else if((lhs.get_c() == rhs.get_c()) && (lhs.get_d() == rhs.get_d())) return true; return false; } 
When should I use the example 1 style over the example 2 style? What are the pros and cons of 1 vs 2?

What's the deal with const member functions?

This is more of a subtle confusion but it seems like in C++ the const keyword means different things base on the context in which it is used. I'm trying to develop a relatively nuanced understanding of what's happening under the hood and I most certainly have misunderstood many language features, especially because C++ has likely changed greatly in the last ~6-8 years.

When should I use enum classes versus plain old enum?

To be honest I'm not entirely certain I fully understand the implications of using enum versus enum class in C++.
This is made more confusing by the fact that there are subtle differences between the way C and C++ treat or permit various language constructs (const, enum, typedef, struct, void*, pointer aliasing, type puning, tentative declarations).
In C, enums decay to integer values at compile time. But in C++, the way I currently understand it, enums are their own type. Thus, in C, the following code would be valid, but a C++ compiler would generate a warning (or an error, haven't actually tested it)
/* Example 3: (enums : Valid in C, invalid in C++ ) */ enum COLOR { RED, BLUE, GREY }; enum PET { CAT, DOG, FROG }; /* This is compatible with a C-style enum conception but not C++ */ enum SHAPE { BALL = RED, /* In C, these work because int = int is valid */ CUBE = DOG, }; 
If my understanding is indeed the case, do enums have an implicit namespace (language construct, not the C++ keyword) as in C? As an add-on to that, in C++, you can also declare enums as a sort of inherited type (below). What am I supposed to make of this? Should I just be using it to reduce code size when possible (similar to gcc option -fuse-packed-enums)? Since most processors are word based, would it be more performant to use the processor's word type than the syntax specified above?
/* Example 4: (Purely C++ style enums, use of enum class/ enum struct) */ /* C++ permits forward enum declaration with type specified */ enum FRUIT : int; enum VEGGIE : short; enum FRUIT /* As I understand it, these are ints */ { APPLE, ORANGE, }; enum VEGGIE /* As I understand it, these are shorts */ { CARROT, TURNIP, }; 
Complicating things even further, I've also seen the following syntax:
/* What the heck is an enum class anyway? When should I use them */ enum class THING { THING1, THING2, THING3 }; /* And if classes and structs are interchangable (minus assumptions * about default access specifiers), what does that mean for * the following definition? */ enum struct FOO /* Is this even valid syntax? */ { FOO1, FOO2, FOO3 }; 
Given that enumerated types greatly improve code readability, I've been trying to wrap my head around all this. When should I be using the various language constructs? Are there any pitfalls in a given method?

When to use POD structs (a-la C style) versus a class implementation?

If I had to take a stab at answering this question, my intuition would be to use POD structs for passing aggregate types (as in function arguments) and using classes for interface abstractions / object abstractions as in the example below:
struct aggregate { unsigned int related_stuff1; unsigned int related_stuff2; char name_of_the_related_stuff[20]; }; class abstraction { private: unsigned int private_member1; unsigned int private_member2; protected: unsigned int stuff_for_child_classes; public: /* big 3 */ abstraction(void); abstraction(const abstraction &other); ~abstraction(void); /* COPY semantic ( I have a better grasp on this abstraction than MOVE) */ abstraction &operator=(const abstraction &rhs); /* MOVE semantic (subtle semantics of which I don't full grasp yet) */ abstraction &operator=(abstraction &&rhs); /* * I've seen implentations of this that use a copy + swap design pattern * but that relies on std::move and I realllllly don't get what is * happening under the hood in std::move */ abstraction &operator=(abstraction rhs); void do_some_stuff(void); /* member function */ }; 
Is there an accepted best practice for thsi or is it entirely preference? Are there arguments for only using classes? What about vtables (where byte-wise alignment such as device register overlays and I have to guarantee placement of precise members)

Is there a best practice for integrating C code?

Typically (and up to this point), I've just done the following:
/* Example 5 : Linking a C library */ /* Disable name-mangling, and then give the C++ linker / * toolchain the compiled * binaries */ #ifdef __cplusplus extern "C" { #endif /* C linkage */ #include "device_driver_header_or_a_c_library.h" #ifdef __cplusplus } #endif /* C linkage */ /* C++ code goes here */ 
As far as I know, this is the only way to prevent the C++ compiler from generating different object symbols than those in the C header file. Again, this may just be ignorance of C++ standards on my part.

What is the proper way to selectively incorporate RTTI without code size bloat?

Is there even a way? I'm relatively fluent in CMake but I guess the underlying question is if binaries that incorporate RTTI are compatible with those that dont (and the pitfalls that may ensue when mixing the two).

What about compile time string formatting?

One of my biggest gripes about C (particularly regarding string manipulation) frequently (especially on embedded targets) variadic arguments get handled at runtime. This makes string manipulation via the C standard library (printf-style format strings) uncomputable at compile time in C.
This is sadly the case even when the ranges and values of paramers and formatting outputs is entirely known beforehand. C++ template programming seems to be a big thing in "modern" C++ and I've seen a few projects on this sub that use the turing-completeness of the template system to do some crazy things at compile time. Is there a way to bypass this ABI limitation using C++ features like constexpr, templates, and lambdas? My (somewhat pessimistic) suspicion is that since the generated assembly must be ABI-compliant this isn't possible. Is there a way around this? What about the std::format stuff I've been seeing on this sub periodically?

Is there a standard practice for namespaces and when to start incorporating them?

Is it from the start? Is it when the boundaries of a module become clearly defined? Or is it just personal preference / based on project scale and modularity?
If I had to make a guess it would be at the point that you get a "build group" for a project (group of source files that should be compiled together) as that would loosely define the boundaries of a series of abstractions APIs you may provide to other parts of a project.
--EDIT-- markdown formatting
submitted by aWildElectron to cpp [link] [comments]

What is the difference between Gentoo and Void Linux?

So I am considering either installing Gentoo or Void Linux. I know for a fact that Void Linux comes with a default binary whereas with Gentoo you have to build everything by yourself. And Void Linux gives users the option to compile everything from source if they so desire to, I believe the user can do this through the package manager, just like with Gentoo.
I know Void Linux uses runit but I believe Gentoo can also use runit if the user desires to use it over OpenRC.
So like I don't get the huge difference between Void Linux and Gentoo. Is Void Linux less customisable than Gentoo (in terms of what components you want)? Can the user specify what flags they want to use to custom build and tailor make it for their PC? Can the user specify which specific packages they want to be installed on their system?
submitted by unix21311 to voidlinux [link] [comments]

C++ Best Practices For a C Programmer

Hi all,
Long time C programmer here, primarily working in the embedded industry (particularly involving safety-critical code). I've been a lurker on this sub for a while but I'm hoping to ask some questions regarding best practices. I've been trying to start using c++ on a lot of my work - particularly taking advantage of some of the code-reuse and power of C++ (particularly constexpr, some loose template programming, stronger type checking, RAII etc).
I would consider myself maybe an 8/10 C programmer but I would conservatively maybe rate myself as 3/10 in C++ (with 1/10 meaning the absolute minmum ability to write, google syntax errata, diagnose, and debug a program). Perhaps I should preface the post that I am more than aware that C is by no means a subset of C++ and there are many language constructs permitted in one that are not in the other.
In any case, I was hoping to get a few answers regarding best practices for c++. Keep in mind that the typical target device I work with does not have a heap of any sort and so a lot of the features that constitute "modern" C++ (non-initialization use of dynamic memory, STL meta-programming, hash-maps, lambdas (as I currently understand them) are a big no-no in terms of passing safety review.

When do I overload operators inside a class as opposed to outisde?


... And what are the arguments foagainst each paradigm? See below:
/* Overload example 1 (overloaded inside class) */ class myclass { private: unsigned int a; unsigned int b; public: myclass(void); unsigned int get_a(void) const; bool operator==(const myclass &rhs); }; bool myclass::operator==(const myclass &rhs) { if (this == &rhs) { return true; } else { if (this->a == rhs.a && this->b == rhs.b) { return true; } } return false; } 
As opposed to this:

/* Overload example 2 (overloaded outside of class) */ class CD { private: unsigned int c; unsigned int d; public: CD(unsigned int _c, unsigned int _d) : d(_d), c(_c) {}; /* CTOR */ unsigned int get_c(void) const; /* trival getters */ unsigned int get_d(void) const; /* trival getters */ }; /* In this implementation, If I don't make the getters (get_c, get_d) constant, * it won't compile despite their access specifiers being public. * * It seems like the const keyword in C++ really should be interpretted as * "read-only AND no side effects" rather than just read only as in C. * But my current understanding may just be flawed... * * My confusion is as follows: The function args are constant references * so why do I have to promise that the function methods have no side-effects on * the private object members? Is this something specific to the == operator? */ bool operator==(const CD & lhs, const CD & rhs) { if(&lhs == &rhs) return true; else if((lhs.get_c() == rhs.get_c()) && (lhs.get_d() == rhs.get_d())) return true; return false; } 
When should I use the example 1 style over the example 2 style? What are the pros and cons of 1 vs 2?

What's the deal with const member functions?

This is more of a subtle confusion but it seems like in C++ the const keyword means different things base on the context in which it is used. I'm trying to develop a relatively nuanced understanding of what's happening under the hood and I most certainly have misunderstood many language features, especially because C++ has likely changed greatly in the last ~6-8 years.

When should I use enum classes versus plain old enum?


To be honest I'm not entirely certain I fully understand the implications of using enum versus enum class in C++.
This is made more confusing by the fact that there are subtle differences between the way C and C++ treat or permit various language constructs (const, enum, typedef, struct, void*, pointer aliasing, type puning, tentative declarations).
In C, enums decay to integer values at compile time. But in C++, the way I currently understand it, enums are their own type. Thus, in C, the following code would be valid, but a C++ compiler would generate a warning (or an error, haven't actually tested it)
/* Example 3: (enums : Valid in C, invalid in C++ ) */ enum COLOR { RED, BLUE, GREY }; enum PET { CAT, DOG, FROG }; /* This is compatible with a C-style enum conception but not C++ */ enum SHAPE { BALL = RED, /* In C, these work because int = int is valid */ CUBE = DOG, }; 
If my understanding is indeed the case, do enums have an implicit namespace (language construct, not the C++ keyword) as in C? As an add-on to that, in C++, you can also declare enums as a sort of inherited type (below). What am I supposed to make of this? Should I just be using it to reduce code size when possible (similar to gcc option -fuse-packed-enums)? Since most processors are word based, would it be more performant to use the processor's word type than the syntax specified above?
/* Example 4: (Purely C++ style enums, use of enum class/ enum struct) */ /* C++ permits forward enum declaration with type specified */ enum FRUIT : int; enum VEGGIE : short; enum FRUIT /* As I understand it, these are ints */ { APPLE, ORANGE, }; enum VEGGIE /* As I understand it, these are shorts */ { CARROT, TURNIP, }; 
Complicating things even further, I've also seen the following syntax:
/* What the heck is an enum class anyway? When should I use them */ enum class THING { THING1, THING2, THING3 }; /* And if classes and structs are interchangable (minus assumptions * about default access specifiers), what does that mean for * the following definition? */ enum struct FOO /* Is this even valid syntax? */ { FOO1, FOO2, FOO3 }; 
Given that enumerated types greatly improve code readability, I've been trying to wrap my head around all this. When should I be using the various language constructs? Are there any pitfalls in a given method?

When to use POD structs (a-la C style) versus a class implementation?


If I had to take a stab at answering this question, my intuition would be to use POD structs for passing aggregate types (as in function arguments) and using classes for interface abstractions / object abstractions as in the example below:
struct aggregate { unsigned int related_stuff1; unsigned int related_stuff2; char name_of_the_related_stuff[20]; }; class abstraction { private: unsigned int private_member1; unsigned int private_member2; protected: unsigned int stuff_for_child_classes; public: /* big 3 */ abstraction(void); abstraction(const abstraction &other); ~abstraction(void); /* COPY semantic ( I have a better grasp on this abstraction than MOVE) */ abstraction &operator=(const abstraction &rhs); /* MOVE semantic (subtle semantics of which I don't full grasp yet) */ abstraction &operator=(abstraction &&rhs); /* * I've seen implentations of this that use a copy + swap design pattern * but that relies on std::move and I realllllly don't get what is * happening under the hood in std::move */ abstraction &operator=(abstraction rhs); void do_some_stuff(void); /* member function */ }; 
Is there an accepted best practice for thsi or is it entirely preference? Are there arguments for only using classes? What about vtables (where byte-wise alignment such as device register overlays and I have to guarantee placement of precise members)

Is there a best practice for integrating C code?


Typically (and up to this point), I've just done the following:
/* Example 5 : Linking a C library */ /* Disable name-mangling, and then give the C++ linker / * toolchain the compiled * binaries */ #ifdef __cplusplus extern "C" { #endif /* C linkage */ #include "device_driver_header_or_a_c_library.h" #ifdef __cplusplus } #endif /* C linkage */ /* C++ code goes here */ 
As far as I know, this is the only way to prevent the C++ compiler from generating different object symbols than those in the C header file. Again, this may just be ignorance of C++ standards on my part.

What is the proper way to selectively incorporate RTTI without code size bloat?

Is there even a way? I'm relatively fluent in CMake but I guess the underlying question is if binaries that incorporate RTTI are compatible with those that dont (and the pitfalls that may ensue when mixing the two).

What about compile time string formatting?


One of my biggest gripes about C (particularly regarding string manipulation) frequently (especially on embedded targets) variadic arguments get handled at runtime. This makes string manipulation via the C standard library (printf-style format strings) uncomputable at compile time in C.
This is sadly the case even when the ranges and values of paramers and formatting outputs is entirely known beforehand. C++ template programming seems to be a big thing in "modern" C++ and I've seen a few projects on this sub that use the turing-completeness of the template system to do some crazy things at compile time. Is there a way to bypass this ABI limitation using C++ features like constexpr, templates, and lambdas? My (somewhat pessimistic) suspicion is that since the generated assembly must be ABI-compliant this isn't possible. Is there a way around this? What about the std::format stuff I've been seeing on this sub periodically?

Is there a standard practice for namespaces and when to start incorporating them?

Is it from the start? Is it when the boundaries of a module become clearly defined? Or is it just personal preference / based on project scale and modularity?
If I had to make a guess it would be at the point that you get a "build group" for a project (group of source files that should be compiled together) as that would loosely define the boundaries of a series of abstractions APIs you may provide to other parts of a project.
--EDIT-- markdown formatting
submitted by aWildElectron to cpp_questions [link] [comments]

Todoist vs Other Task Trackers

I'm currently subscribed to Todoist for another 5 months and mostly happy with it, but the recent unannounced removal of features and subsequent lack of guidance from Doist's support when asked about this makes me question if Todoist will still be the tool I need once the sub runs out.
I use Todoist to keep track on practically everything and heavily lean on recurring items, templates and filtering to make sure I'm focusing at the right things at the right time.
The only things Todoist doesn't do that I would really like native support for (not workarounds) are task start dates, task durations and non-binary task status (e.g. not just open / complete)
I've used OmniFocus (comprehensive, but felt like I was spending more time planning than doing), Trello (was hard to maintain an overview of what I was doing) and Evernote (I couldn't adapt my working style to make the most of it)
I would be really interested to know what other apps people have used, what they liked and didn't like about them and how they compared to Todoist.
I'd definitely prefer to stay with Todoist and bear them no ill will if the product develops into something that no longer suits my needs, just feels like it's time to start considering options
submitted by Triffids_In_Space to todoist [link] [comments]

Step-by-Step Guide for Adding a Stack, Expanding Control Lines, and Building an Assembler

After the positive response to my first tutorial on expanding the RAM, I thought I'd continue the fun by expanding the capabilities of Ben's 8-bit CPU even further. That said, you'll need to have done the work in the previous post to be able to do this. You can get a sense for what we'll do in this Imgur gallery.
In this tutorial, we'll balance software and hardware improvements to make this a pretty capable machine:

Parts List

To only update the hardware, you'll need:
If you want to update the toolchain, you'll need:
  1. Arduino Mega 2560 (Amazon) to create the programmer.
  2. Ribbon Jumper Cables (Amazon) to connect the Arduino to the breadboard.
  3. TL866 II Plus EEPROM Programmer (Amazon) to program the ROM.
Bonus Clock Improvement: One additional thing I did is replace the 74LS04 inverter in Ben's clock circuit with a 74LS14 inverting Schmitt trigger (datasheet, Jameco). The pinouts are identical! Just drop it in, wire the existing lines, and then run the clock output through it twice (since it's inverting) to get a squeaky clean clock signal. Useful if you want to go even faster with the CPU.

Step 1: Program with an Arduino and Assembler (Image 1, Image 2)

There's a certain delight in the physical programming of a computer with switches. This is how Bill Gates and Paul Allen famously programmed the Altair 8800 and started Microsoft. But at some point, the hardware becomes limited by how effectively you can input the software. After upgrading the RAM, I quickly felt constrained by how long it took to program everything.
You can continue to program the computer physically if you want and even after upgrading that option is still available, so this step is optional. There's probably many ways to approach the programming, but this way felt simple and in the spirit of the build. We'll use an Arduino Mega 2560, like the one in Ben's 6502 build, to program the RAM. We'll start with a homemade assembler then switch to something more robust.
Preparing the Physical Interface
The first thing to do is prepare the CPU to be programmed by the Arduino. We already did the hard work on this in the RAM upgrade tutorial by using the bus to write to the RAM and disconnecting the control ROM while in program mode. Now we just need to route the appropriate lines to a convenient spot on the board to plug the Arduino into.
  1. This is optional, but I rewired all the DIP switches to have ground on one side, rather than alternating sides like Ben's build. This just makes it easier to route wires.
  2. Wire the 8 address lines from the DIP switch, connecting the side opposite to ground (the one going to the chips) to a convenient point on the board. I put them on the far left, next to the address LEDs and above the write button circuit.
  3. Wire the 8 data lines from the DIP switch, connecting the side opposite to ground (the one going to the chips) directly below the address lines. Make sure they're separated by the gutter so they're not connected.
  4. Wire a line from the write button to your input area. You want to connect the side of the button that's not connected to ground (the one going to the chip).
So now you have one convenient spot with 8 address lines, 8 data lines, and a write line. If you want to get fancy, you can wire them into some kind of connector, but I found that ribbon jumper cables work nicely and keep things tidy.
The way we'll program the RAM is to enter program mode and set all the DIP switches to the high position (e.g., 11111111). Since the switches are upside-down, this means they'll all be disconnected and not driving to ground. The address and write lines will simply be floating and the data lines will be weakly pulled up by 1k resistors. Either way, the Arduino can now drive the signals going into the chips using its outputs.
Creating the Arduino Programmer
Now that we can interface with an Arduino, we need to write some software. If you follow Ben's 6502 video, you'll have all the knowledge you need to get this working. If you want some hints and code, see below (source code):
  1. Create arrays for your data and address lines. For example: const char ADDRESS_LINES[] = {39, 41, 43, 45, 47, 49, 51, 53};. Create your write line with #define RAM_WRITE 3.
  2. Create functions to enable and disable your address and data lines. You want to enable them before writing. Make sure to disable them afterward so that you can still manually program using DIP switches without disconnecting the Arduino. The code looks like this (just change INPUT to OUTPUT accordingly): for(int n = 0; n < 8; n += 1) { pinMode(ADDRESS_LINES[n], OUTPUT); }
  3. Create a function to write to an address. It'll look like void writeData(byte writeAddress, byte writeData) and basically use two loops, one for address and one for data, followed by toggling the write.
  4. Create a char array that contains your program and data. You can use #define to create opcodes like #define LDA 0x01.
  5. In your main function, loop through the program array and send it through writeData.
With this setup, you can now load multi-line programs in a fraction of a second! This can really come in handy with debugging by stress testing your CPU with software. Make sure to test your setup with existing programs you know run reliably. Now that you have your basic setup working, you can add 8 additional lines to read the bus and expand the program to let you read memory locations or even monitor the running of your CPU.
Making an Assembler
The above will serve us well but it's missing a key feature: labels. Labels are invaluable in assembly because they're so versatile. Jumps, subroutines, variables all use labels. The problem is that labels require parsing. Parsing is a fun project on the road to a compiler but not something I wanted to delve into right now--if you're interested, you can learn about Flex and Bison. Instead, I found a custom assembler that lets you define your CPU's instruction set and it'll do everything else for you. Let's get it setup:
  1. If you're on Windows, you can use the pre-built binaries. Otherwise, you'll need to install Rust and compile via cargo build.
  2. Create a file called 8bit.cpu and define your CPU instructions (source code). For example, LDA would be lda {address} -> 0x01 @ address[7:0]. What's cool is you can also now create the instruction's immediate variant instead of having to call it LDI: lda #{value} -> 0x05 @ value[7:0].
  3. You can now write assembly by adding #include "8bit.cpu" to the top of your code. There's a lot of neat features so make sure to read the documentation!
  4. Once you've written some assembly, you can generate the machine code using ./customasm yourprogram.s -f hexc -p. This prints out a char array just like our Arduino program used!
  5. Copy the char array into your Arduino program and send it to your CPU.
At this stage, you can start creating some pretty complex programs with ease. I would definitely play around with writing some larger programs. I actually found a bug in my hardware that was hidden for a while because my programs were never very complex!

Step 2: Expand the Control Lines (Image)

Before we can expand the CPU any further, we have to address the fact we're running out of control lines. An easy way to do this is to add a 3rd 28C16 ROM and be on your way. If you want something a little more involved but satisfying, read on.
Right now the control lines are one hot encoded. This means that if you have 4 lines, you can encode 4 states. But we know that a 4-bit binary number can encode 16 states. We'll use this principle via 74LS138 decoders, just like Ben used for the step counter.
Choosing the Control Line Combinations
Everything comes with trade-offs. In the case of combining control lines, it means the two control lines we choose to combine can never be activated at the same time. We can ensure this by encoding all the inputs together in the first 74LS138 and all the outputs together in a second 74LS138. We'll keep the remaining control lines directly connected.
Rewiring the Control Lines
If your build is anything like mine, the control lines are a bit of a mess. You'll need to be careful when rewiring to ensure it all comes back together correctly. Let's get to it:
  1. Place the two 74LS138 decoders on the far right side of the breadboard with the ROMs. Connect them to power and ground.
  2. You'll likely run out of inverters, so place a 74LS04 on the breadboard above your decoders. Connect it to power and ground.
  3. Carefully take your inputs (MI, RI, II, AI, BI, J) and wire them to the outputs of the left 74LS138. Do not wire anything to O0 because that's activated by 000 which won't work for us!
  4. Carefully take your outputs (RO, CO, AO, EO) and wire them to the outputs of the right 74LS138. Remember, do not wire anything to O0!
  5. Now, the 74LS138 outputs are active low, but the ROM outputs were active high. This means you need to swap the wiring on all your existing 74LS04 inverters for the LEDs and control lines to work. Make sure you track which control lines are supposed to be active high vs. active low!
  6. Wire E3 to power and E2 to ground. Connect the E1 on both 138s together, then connect it to the same line as OE on your ROMs. This will ensure that the outputs are disabled when you're in program mode. You can actually take off the 1k pull-up resistors from the previous tutorial at this stage, because the 138s actively drive the lines going to the 74LS04 inverters rather than floating like the ROMs.
At this point, you really need to ensure that the massive rewiring job was successful. Connect 3 jumper wires to A0-A2 and test all the combinations manually. Make sure the correct LED lights up and check with a multimeteoscilloscope that you're getting the right signal at each chip. Catching mistakes at this point will save you a lot of headaches! Now that everything is working, let's finish up:
  1. Connect A0-A2 of the left 74LS138 to the left ROM's A0-A2.
  2. Connect A0-A2 of the right 74LS138 to the right ROM's A0-A2.
  3. Distribute the rest of the control signals across the two ROMs.
Changing the ROM Code
This part is easy. We just need to update all of our #define with the new addresses and program the ROMs again. For clarity that we're not using one-hot encoding anymore, I recommend using hex instead of binary. So instead of #define MI 0b0000000100000000, we can use #define MI 0x0100, #define RI 0x0200, and so on.
Testing
Expanding the control lines required physically rewiring a lot of critical stuff, so small mistakes can creep up and make mysterious errors down the road. Write a program that activates each control line at least once and make sure it works properly! With your assembler and Arduino programmer, this should be trivial.
Bonus: Adding B Register Output
With the additional control lines, don't forget you can now add a BO signal easily which lets you fully use the B register.

Step 3: Add a Stack (Image 1, Image 2)

Adding a stack significantly expands the capability of the CPU. It enables subroutines, recursion, and handling interrupts (with some additional logic). We'll create our stack with an 8-bit stack pointer hard-coded from $0100 to $01FF, just like the 6502.
Wiring up the Stack Pointer
A stack pointer is conceptually similar to a program counter. It stores an address, you can read it and write to it, and it increments. The only difference between a stack pointer and a program counter is that the stack pointer must also decrement. To create our stack pointer, we'll use two 74LS193 4-bit up/down binary counters:
  1. Place a 74LS00 NAND gate, 74LS245 transceiver, and two 74LS193 counters in a row next to your output register. Wire up power and ground.
  2. Wire the the Carry output of the right 193 to the Count Up input of the left 193. Do the same for the Borrow output and Count Down input.
  3. Connect the Clear input between the two 193s and with an active high reset line. The B register has one you can use on its 74LS173s.
  4. Connect the Load input between the two 193s and to a new active low control line called SI on your 74LS138 decoder.
  5. Connect the QA-QD outputs of the lower counter to A8-A5 and the upper counter to A4-A1. Pay special attention because the output are in a weird order (BACD) and you want to make sure the lower A is connected to A8 and the upper A is connected to A4.
  6. Connect the A-D inputs of the lower counter to B8-B5 and the upper counter to B4-B1. Again, the inputs are in a weird order and on both sides of the chip so pay special attention.
  7. Connect the B1-B8 outputs of the 74LS245 transceiver to the bus.
  8. On the 74LS245 transceiver, connect DIR to power (high) and connect OE to a new active low control line called SO on your 74LS138 decoder.
  9. Add 8 LEDs and resistors to the lower part of the 74LS245 transceiver (A1-A8) so you can see what's going on with the stack pointer.
Enabling Increment & Decrement
We've now connected everything but the Count Up and Count Down inputs. The way the 74LS193 works is that if nothing is counting, both inputs are high. If you want to increment, you keep Count Down high and pulse Count Up. To decrement, you do the opposite. We'll use a 74LS00 NAND gate for this:
  1. Take the clock from the 74LS08 AND gate and make it an input into two different NAND gates on the 74LS00.
  2. Take the output from one NAND gate and wire it to the Count Up input on the lower 74LS193 counter. Take the other output and wire it to the Count Down input.
  3. Wire up a new active high control line called SP from your ROM to the NAND gate going into Count Up.
  4. Wire up a new active high control line called SM from your ROM to the NAND gate going into Count Down.
At this point, everything should be working. Your counter should be able to reset, input a value, output a value, and increment/decrement. But the issue is it'll be writing to $0000 to $00FF in the RAM! Let's fix that.
Accessing Higher Memory Addresses
We need the stack to be in a different place in memory than our regular program. The problem is, we only have an 8-bit bus, so how do we tell the RAM we want a higher address? We'll use a special control line to do this:
  1. Wire up an active high line called SA from the 28C16 ROM to A8 on the Cypress CY7C199 RAM.
  2. Add an LED and resistor so you can see when the stack is active.
That's it! Now, whenever we need the stack we can use a combination of the control line and stack pointer to access $0100 to $01FF.
Updating the Instruction Set
All that's left now is to create some instructions that utilize the stack. We'll need to settle some conventions before we begin:
If you want to add a little personal flair to your design, you can change the convention fairly easily. Let's implement push and pop (source code):
  1. Define all your new control lines, such as #define SI 0x0700 and #define SO 0x0005.
  2. Create two new instructions: PSH (1011) and POP (1100).
  3. PSH starts the same as any other for the first two steps: MI|CO and RO|II|CE. The next step is to put the contents of the stack pointer into the address register via MI|SO|SA. Recall that SA is the special control line that tells the memory to access the $01XX bank rather than $00XX.
  4. We then take the contents of AO and write it into the RAM. We can also increment the stack pointer at this stage. All of this is done via: AO|RI|SP|SA, followed by TR.
  5. POP is pretty similar. Start off with MI|CO and RO|II|CE. We then need to take a cycle and decrement the stack pointer with SM. Like with PSH, we then set the address register with MI|SO|SA.
  6. We now just need to output the RAM into our A register with RO|AI|SA and then end the instruction with TR.
  7. Updating the assembler is easy since neither instruction has operands. For example, push is just psh -> 0x0B.
And that's it! Write some programs that take advantage of your new 256 byte stack to make sure everything works as expected.

Step 4: Add Subroutine Instructions (Image)

The last step to complete our stack is to add subroutine instructions. This allows us to write complex programs and paves the way for things like interrupt handling.
Subroutines are like a blend of push/pop instructions and a jump. Basically, when you want to call a subroutine, you save your spot in the program by pushing the program counter onto the stack, then jumping to the subroutine's location in memory. When you're done with the subroutine, you simply pop the program counter value from the stack and jump back into it.
We'll follow 6502 conventions and only save and restore the program counter for subroutines. Other CPUs may choose to save more state, but it's generally left up to the programmer to ensure they're not wiping out states in their subroutines (e.g., push the A register at the start of your subroutine if you're messing with it and restore it before you leave).
Adding an Extra Opcode Line
I've started running low on opcodes at this point. Luckily, we still have two free address lines we can use. To enable 5-bit opcodes, simply wire up the 4Q output of your upper 74LS173 register to A7 of your 28C16 ROM (this assumes your opcodes are at A3-A6).
Updating the ROM Writer
At this point, you simply need to update the Arduino writer to support 32 instructions vs. the current 16. So, for example, UCODE_TEMPLATE[16][8] becomes UCODE_TEMPLATE[32][8] and you fill in the 16 new array elements with nop. The problem is that the Arduino only has so much memory and with the way Ben's code is written to support conditional jumps, it starts to get tight.
I bet the code can be re-written to handle this, but I had a TL866II Plus EEPROM programmer handy from the 6502 build and I felt it would be easier to start using that instead. Converting to a regular C program is really simple (source code):
  1. Copy all the #define, global const arrays (don't forget to expand them from 16 to 32), and void initUCode(). Add #include and #include to the top.
  2. In your traditional int main (void) C function, after initializing with initUCode(), make two arrays: char ucode_upper[2048] and char ucode_lower[2048].
  3. Take your existing loop code that loops through all addresses: for (int address = 0; address < 2048; address++).
  4. Modify instruction to be 5-bit with int instruction = (address & 0b00011111000) >> 3;.
  5. When writing, just write to the arrays like so: ucode_lower[address] = ucode[flags][instruction][step]; and ucode_upper[address] = ucode[flags][instruction][step] >> 8;.
  6. Open a new file with FILE *f = fopen("rom_upper.hex", "wb");, write to it with fwrite(ucode_upper, sizeof(char), sizeof(ucode_upper), f); and close it with fclose(f);. Repeat this with the lower ROM too.
  7. Compile your code using gcc (you can use any C compiler), like so: gcc -Wall makerom.c -o makerom.
Running your program will spit out two binary files with the full contents of each ROM. Writing the file via the TL866II Plus requires minipro and the following command: minipro -p CAT28C16A -w rom_upper.hex.
Adding Subroutine Instructions
At this point, I cleaned up my instruction set layout a bit. I made psh and pop 1000 and 1001, respectively. I then created two new instructions: jsr and rts. These allow us to jump to a subroutine and returns from a subroutine. They're relatively simple:
  1. For jsr, the first three steps are the same as psh: MI|CO, RO|II|CE, MI|SO|SA.
  2. On the next step, instead of AO we use CO to save the program counter to the stack: CO|RI|SP|SA.
  3. We then essentially read the 2nd byte to do a jump and terminate: MI|CO, RO|J.
  4. For rts, the first four steps are the same as pop: MI|CO, RO|II|CE, SM, MI|SO|SA.
  5. On the next step, instead of AI we use J to load the program counter with the contents in stack: RO|J|SA.
  6. We're not done! If we just left this as-is, we'd jump to the 2nd byte of jsr which is not an opcode, but a memory address. All hell would break loose! We need to add a CE step to increment the program counter and then terminate.
Once you update the ROM, you should have fully functioning subroutines with 5-bit opcodes. One great way to test them is to create a recursive program to calculate something--just don't go too deep or you'll end up with a stack overflow!

Conclusion

And that's it! Another successful upgrade of your 8-bit CPU. You now have a very capable machine and toolchain. At this point I would have a bunch of fun with the software aspects. In terms of hardware, there's a number of ways to go from here:
  1. Interrupts. Interrupts are just special subroutines triggered by an external line. You can make one similar to how Ben did conditional jumps. The only added complexity is the need to load/save the flags register since an interrupt can happen at any time and you don't want to destroy the state. Given this would take more than 8 steps, you'd also need to add another line for the step counter (see below).
  2. ROM expansion. At this point, address lines on the ROM are getting tight which limits any expansion possibilities. With the new approach to ROM programming, it's trivial to switch out the 28C16 for the 28C256 that Ben uses in the 6502. These give you 4 additional address lines for flags/interrupts, opcodes, and steps.
  3. LCD output. At this point, adding a 16x2 character LCD like Ben uses in the 6502 is very possible.
  4. Segment/bank register. It's essentially a 2nd memory address register that lets you access 256-byte segments/banks of RAM using bank switching. This lets you take full advantage of the 32K of RAM in the Cypress chip.
  5. Fast increment instructions. Add these to registers by replacing 74LS173s with 74LS193s, allowing you to more quickly increment without going through the ALU. This is used to speed up loops and array operations.
submitted by MironV to beneater [link] [comments]

[C++ 17 Code Review] STL compatible (?) Binary Search Tree with unique_ptr

I am trying to create a Binary Search Tree, which has STL support (iterators etc.). This is my first attempt. Everything is unit tested using Catch2. Could you please review what I missed and what I could do better?
This is not homework, I am trying to create a repository with unit tested C++ algorithms at https://gitlab.com/MartenBE/varia as a hobby and a way to teach myself C++.
Binary Search Tree:
#ifndef BINARY_SEARCH_TREE_H #define BINARY_SEARCH_TREE_H #include "nlohmann/json.hpp" using json = nlohmann::json; #include  #include  #include  #include  #include  template  class binary_search_tree { private: // Forward declarations class node; class const_iterator; public: binary_search_tree() = default; virtual ~binary_search_tree() = default; binary_search_tree(const binary_search_tree& other) { clear(); m_size = other.m_size; std::stack*, std::unique_ptr*, node*>> nodes_to_deep_copy; nodes_to_deep_copy.push({&(other.m_root), &m_root, nullptr}); while (!nodes_to_deep_copy.empty()) { auto [other_node_ptr, node_ptr, parent_ptr] = nodes_to_deep_copy.top(); nodes_to_deep_copy.pop(); if (*other_node_ptr) { *node_ptr = std::make_unique((*other_node_ptr)->m_key, (*other_node_ptr)->m_value, parent_ptr); nodes_to_deep_copy.push( {&((*other_node_ptr)->m_left_child), &((*node_ptr)->m_left_child), node_ptr->get()}); nodes_to_deep_copy.push( {&((*other_node_ptr)->m_right_child), &((*node_ptr)->m_right_child), node_ptr->get()}); } } } binary_search_tree& operator=(const binary_search_tree& other) { binary_search_tree temp{other}; swap(*this, temp); return *this; } binary_search_tree(binary_search_tree&& other) : m_root{std::move(other.m_root)}, m_size{other.m_size} { other.m_size = 0; } binary_search_tree& operator=(binary_search_tree&& other) { binary_search_tree temp{std::move(other)}; swap(*this, temp); return *this; } friend void swap(binary_search_tree& first, binary_search_tree& second) { using std::swap; swap(first.m_root, second.m_root); swap(first.m_size, second.m_size); } std::optional search(const K& key) { auto [node_ptr, parent_node_ptr] = search_node_ptr(key); if (!node_ptr) { return std::nullopt; } return node_ptr->m_value; } void add(const K& key, const V& value) { auto [node_ptr, parent_node_ptr] = search_node_ptr(key); assert(!node_ptr); std::unique_ptr* place_of_new_node = nullptr; if (!parent_node_ptr) { place_of_new_node = &m_root; } else { if (key < parent_node_ptr->m_key) { place_of_new_node = &(parent_node_ptr->m_left_child); } else { place_of_new_node = &(parent_node_ptr->m_right_child); } } *place_of_new_node = std::make_unique(key, value, parent_node_ptr); m_size++; } bool empty() const { return (size() == 0); } void clear() { m_root.reset(); m_size = 0; } const K& find_minimum() const { assert(!empty()); return find_minimum_node_ptr(*m_root)->m_key; } const K& find_maximum() const { assert(!empty()); return find_maximum_node_ptr(*m_root)->m_key; } std::optional find_predecessor(const K& key) const { assert(!empty()); auto [node_ptr, parent_node_ptr] = search_node_ptr(key); assert(node_ptr); node* predecessor_ptr = find_predecessor_node_ptr(*node_ptr); if (!predecessor_ptr) { return std::nullopt; } return predecessor_ptr->m_key; } std::optional find_successor(const K& key) const { assert(!empty()); auto [node_ptr, parent_node_ptr] = search_node_ptr(key); assert(node_ptr); node* successor_ptr = find_successor_node_ptr(*node_ptr); if (!successor_ptr) { return std::nullopt; } return successor_ptr->m_key; } void remove(const K& key) { assert(!empty()); auto [node_ptr, parent_node_ptr] = search_node_ptr(key); assert(node_ptr); remove(*node_ptr); m_size--; } int size() const { return m_size; } json to_json() const { if (empty()) { return json{}; } return m_root->to_json(); } friend bool operator==(const binary_search_tree& lhs, const binary_search_tree& rhs) { if (lhs.empty() && rhs.empty()) { return true; } if (lhs.size() != rhs.size()) { return false; } std::stack> nodes_to_check; nodes_to_check.push({lhs.m_root.get(), rhs.m_root.get()}); while (!nodes_to_check.empty()) { std::pair nodes = nodes_to_check.top(); nodes_to_check.pop(); node* node_lhs = nodes.first; node* node_rhs = nodes.second; if ((!node_lhs && node_rhs) || (node_lhs && !node_rhs)) { return false; } if (node_lhs && node_rhs) { if (node_lhs->m_key != node_rhs->m_key) { return false; } nodes_to_check.push({node_lhs->m_left_child.get(), node_rhs->m_left_child.get()}); nodes_to_check.push({node_lhs->m_right_child.get(), node_rhs->m_right_child.get()}); } } return true; } friend bool operator!=(const binary_search_tree& lhs, const binary_search_tree& rhs) { return !(lhs == rhs); } friend std::ostream& operator<<(std::ostream& os, const binary_search_tree& bt) { os << bt.to_json().dump(4); return os; } const_iterator begin() { if (empty()) { return end(); } return const_iterator{(*this), find_minimum_node_ptr(*m_root)}; } const_iterator end() { return const_iterator{(*this), nullptr}; } private: std::pair search_node_ptr(const K& key) const { node* current_node = m_root.get(); node* parent_node = nullptr; while (current_node && (current_node->m_key != key)) { parent_node = current_node; if (key < current_node->m_key) { current_node = (current_node->m_left_child).get(); } else { current_node = (current_node->m_right_child).get(); } } return std::pair{current_node, parent_node}; } node* find_minimum_node_ptr(node& root) const { node* current_node = &root; while (current_node->m_left_child) { current_node = (current_node->m_left_child).get(); } return current_node; } node* find_maximum_node_ptr(node& root) const { node* current_node = &root; while (current_node->m_right_child) { current_node = (current_node->m_right_child).get(); } return current_node; } node* find_predecessor_node_ptr(node& root) const { if (root.m_left_child) { return find_maximum_node_ptr(*(root.m_left_child)); } else { node* current_node_ptr = &root; node* parent_ptr = current_node_ptr->m_parent; while (parent_ptr && ((parent_ptr->m_left_child).get() == current_node_ptr)) { current_node_ptr = current_node_ptr->m_parent; parent_ptr = parent_ptr->m_parent; } return parent_ptr; } } node* find_successor_node_ptr(node& root) const { if (root.m_right_child) { return find_minimum_node_ptr(*(root.m_right_child)); } else { node* current_node_ptr = &root; node* parent_ptr = current_node_ptr->m_parent; while (parent_ptr && ((parent_ptr->m_right_child).get() == current_node_ptr)) { current_node_ptr = current_node_ptr->m_parent; parent_ptr = parent_ptr->m_parent; } return parent_ptr; } } void remove(node& root) { node* node_ptr = &root; std::unique_ptr* node_owner_ptr = get_owner_pointer(node_ptr); if (!(node_ptr->m_left_child) && !(node_ptr->m_right_child)) { node_owner_ptr->reset(); } else if ((node_ptr->m_left_child) && (node_ptr->m_right_child)) { node* replacement_ptr = find_successor_node_ptr(*node_ptr); node_ptr->m_key = std::move(replacement_ptr->m_key); node_ptr->m_value = std::move(replacement_ptr->m_value); remove(*replacement_ptr); } else { node* parent = node_ptr->m_parent; if (node_ptr->m_left_child) { *node_owner_ptr = std::move(node_ptr->m_left_child); } else { *node_owner_ptr = std::move(node_ptr->m_right_child); } (*node_owner_ptr)->m_parent = parent; } } std::unique_ptr* get_owner_pointer(node* node_ptr) { if (node_ptr == m_root.get()) { return &m_root; } if ((node_ptr->m_parent->m_left_child).get() == node_ptr) { return &(node_ptr->m_parent->m_left_child); } else { return &(node_ptr->m_parent->m_right_child); } } class node { public: node(const K& key, const V& value, node* parent) : m_key{key}, m_value{value}, m_parent{parent} { } node(const node& other) = delete; node& operator=(const node& other) = delete; node(node&& other) = default; node& operator=(node&& other) = default; virtual ~node() = default; friend void swap(node& first, node& second) { swap(first.m_key, second.m_key); swap(first.m_value, second.m_value); swap(first.m_left_child, second.m_left_child); swap(first.m_right_child, second.m_right_child); swap(first.m_parent, second.m_parent); } json to_json() const { json node_json; node_json["key"] = m_key; node_json["value"] = m_value; if (m_left_child) { node_json["left_child"] = m_left_child->to_json(); } else { node_json["left_child"] = ""; } if (m_right_child) { node_json["right_child"] = m_right_child->to_json(); } else { node_json["right_child"] = ""; } if (m_parent) { node_json["parent_key"] = m_parent->m_key; } else { node_json["parent_key"] = ""; } return node_json; } K m_key; V m_value; std::unique_ptr m_left_child = nullptr; std::unique_ptr m_right_child = nullptr; node* m_parent = nullptr; }; class const_iterator { public: using value_type = std::pair; using pointer = const value_type*; using reference = const value_type&; using difference_type = int; using iterator_category = std::bidirectional_iterator_tag; const_iterator(const binary_search_tree& bst, node* node_ptr) : bst{bst}, node_ptr{node_ptr} { } const_iterator(const const_iterator& other) = default; const_iterator(const_iterator&& other) = default; const_iterator& operator=(const const_iterator& other) = default; const_iterator& operator=(const_iterator&& other) = default; virtual ~const_iterator() = default; const_iterator& operator++() { assert(node_ptr); node_ptr = bst.find_successor_node_ptr(*node_ptr); return *this; } const_iterator operator++(int) { const_iterator temp{*this}; ++(*this); return temp; } const value_type operator*() const { assert(node_ptr); return value_type{node_ptr->m_key, node_ptr->m_value}; } friend bool operator==(const const_iterator& lhs, const const_iterator& rhs) { return (lhs.node_ptr == rhs.node_ptr); } friend bool operator!=(const const_iterator& lhs, const const_iterator& rhs) { return !(lhs == rhs); } private: const binary_search_tree& bst; node* node_ptr; }; std::unique_ptr m_root = nullptr; int m_size = 0; }; #endif 
submitted by MartenBE to cpp_questions [link] [comments]

Reverse Engineering Private iOS Frameworks in IDA Pro: A guide and troubleshooting reference that Hex-Rays didn't provide.

Note: * All discussion of resources that can be obtained from InternalUI builds should be regarded as hypothetical and purely educational. Obtaining these builds without the express permission of Apple is illegal, and doing so is discouraged. All information provided here is purely educational. * This guide was written for IDA 7.5. It should work on 7.3 and above. If you're using a cracked version, Scroll down to the "Pre 7.3" section. The rest doesn't apply to you at all.

Crucial Performance Tips

General tips regarding IDA usage for iOS RE: * If you are not patient, do not use IDA on the dyld_shared_cache. You will lose your mind. * Modern versions of IDA come with a dark mode included. Google "IDASkins" if you are on an older version and enable a dark mode. Your eyes will thank you if you work at night.
A majority of the information in this article details the process of reverse engineering using the dyld_shared_cache, as doing such is poorly documented in official documents.

Terms used

Analyzing the dyld_shared_cache in IDA Pro 7.3 or later.

IDA 7.3 and later includes a powerful, improved shared cache toolkit. It eliminates the need for simulator binaries, and makes analysis possible when you cant get access to simulator binaries (InternalUI builds, no macOS, no x64 decompiler, etc.)
The documentation is not great, and as such, I've made an attempt at documenting my own experience with the software.
Everything described here was performed on a licensed copy of IDA Pro 7.5. Older, especially unlicensed versions, may not be able to handle all of these features.

Analyzing a specific framework from the dyld_shared_cache.

Do not "Load module and dependencies" option on "high level" frameworks. In iOS 13, with SpringBoardHome this results in loading 720 modules. This takes upwards of 2 to 3 days on an 8-core 4GHz 32GB-of-ram PC. In newer versions, due to consolidation, that number is down to ~400. You'll still be unable to use your PC for a few days at best. I have loaded an entire shared cache a total of 3 times. I could write a separate article on the unfixable issues that happen. It's not worth your time, I promise. Utilize the tools described below.
IDA 7.3 introduced powerful new tools for dealing with the cache. You can now load a single module and selectively load only segments you need from other locations in the shared cache. It can be a pain, but the alternative is much, much worse.

Load the framework you're interested in

  1. Select the "Load single module" option. Ensure you do not select "with dependencies".
  2. Wait for the module you selected to load. It shouldn't take long.
For this example we'll be using FrontBoard.framework.
Loading is the easy part. Now we get to go through the process of correcting IDA's failures, as certain functions tend to fall apart in the dyld_shared_cache subsystem.

Troubleshooting missing data (red addresses, garbage variable names, etc)

The first thing you'll notice is that the assembly or pseudocode generated is absolute gibberish. If regular assembly is gibberish to you, this is advanced gibberish.
Swap to the IDA view for this. You may not be able to read assembly, but the pseudocode view doesn't properly handle the new features.

Red addresses

Swap to the "IDA View", as it doesn't work properly in the pseudocode view, and right-click a red address. We are going to assume that the one you clicked was a reference to libobjc.dylib, although it could be any library or framework in the cache.
You'll see an option to load "libobjc.A:__OBJC_RO" or something similar, or an option to load the entirety of "libobjc.A". If you don't need to reverse the contents of "libobjc.A" (you don't), you should simply load only the segment IDA suggests. This allows you to avoid absolutely destroying your RAM and CPU when working in the cache, while also allowing you to make sense of the code within it.

The address is still red :p

IDA likely failed to recognize any information in the segment. This can be caused by a damaged database, if IDA crashed while processing data.
Click the address and you'll be taken to the memory location, and if that assumption is correct and you can see vertical strings of letters:
Your address is probably still red. If so, you've damaged your database. I'd advise deleting the database and starting from scratch. This is the fastest option.

offxxxxxxxxx (random hex address prefixed by "off") in your assembly

What causes this?
These represent "refs". You're most likely looking at a class ref that failed to load.
Fix
  1. In the IDA View, double-click the off_x variable to be taken to the classrefs segment
  2. Right-click the red memory address and load the suggested module segment.
A name will appear. Good. Go back to your function.
  1. Edit -> Other -> Objective C -> Reload Objective C Info
If it changes from off_x to selRef, classRef, or something similar, you can move on.
If it does not change, see below
What causes this?
IDA improperly guessed the type of a struct it loaded due to a missing segment.
Fix
  1. Double click the pink text if you haven't yet to be taken to the class definition in __objc_data
  2. Click the _OBJC_CLASS... item to select that line
  3. Open Edit -> Struct Var
  4. Select objc_class and hit OK
  5. A red memory address will appear. Load that segment.
  6. Make your way back to your function that you're disassembling.
  7. Edit -> Other -> Objective C -> Reload Objective C Info
  8. Cry, because it's finally fixed.
Repeat this for any variables you feel are worth spending the time correcting.

Other issues

I'm likely forgetting some. I loaded a shared cache fresh and walked myself through fixing issues for the sake of this guide. I'll continue to add solutions as I encounter them.
Interesting Note: Sometimes, you'll see an address and click to load it in. "What on earth is 'GeoServices' doing in this function?" You might think. Upon loading, you'll see it was something like j__objc_retainAutoreleasedReturnValue_0. This is a byproduct of the shared_cache's optimizations, and as a result, you'll end up with several duplicate functions like this. A script to fix these needs to be written, eventually.
Typically loaded frameworks: libobjc Foundation CoreFoundation GeoServices ("trampoline")
I'm very interested in the concept of creating a "template database" that has data segments for these and others pre-loaded. If someone tries that, do update here with how that's done best.

Working with pseudocode from the dyld_shared_cache

Something you'll likely become familiar with is the statement (self + 10), where 10 is any 2 digit number. In objc source, you would see this as an ivar. If you've loaded in the relevant class information, you can help IDA display these ivars properly in the pseudocode view like so:
  • Right-click the a1 or self variable on line one
  • Click Y or "Set ivar type"
  • Change the class of self/a1 to the class shown next to it.
  • Change a1 to self if need be
Ivars should now be properly generated and shown in pseudocode.

InternalUI .development cache

While someone more experienced could speak to the exact purpose of this build of the cache, given that a dump was leaked to the general public I see no need not to discuss this.
The .development cache (which cannot be loaded in cracked IDA versions) appears to be a build of the shared cache that properly holds symbols for the libobjc, libsystem, and other libraries, instead of raw addresses.
If you're using Hopper or IDA 7.5, give the .development cache a shot.
Do note, I've had some issues with certain functions in it. I'm excited to see more information or research on the functionality of this object.

Other fun easter eggs in dumps

I'll leave these for you to find, but as a hint, look in folders that normally have no binaries and you might find a nice treat.
(not to mention the kexts, who needs kernelcaches anyways)

Pre-7.3 dyld_shared_cache analysis

I do not intend to pick a fight with illegitimate IDA users. The software is insanely expensive, I cannot fault anyone in that regard. If you are using an illegitimate copy, don't tell me, I don't want to know. Best of luck.
It's from a year of experience with it that I'm telling you: * Illegitimate versions of IDA cannot properly handle arm64e code very well. * Illegitimate versions of IDA cannot properly handle .development versions of shared caches available in InternalUI dumps whatsoever. It's completely incapable, and fails to process modules it loads. * Users of illegitimate versions of IDA should primarily stick to Simulator runtime binaries as detailed below. * Consider Hopper. It is capable of a few of IDA >7.3's features (arm64e, .development caches) and carries a much smaller price tag * Get comfortable with assembly if you intend to use Hopper. The pseudocode it generates is among the "least desirable" in the industry, and the assembly is easier to read. * Additionally, consider Ghidra. I'm not familiar with it, but others are, and can help you work with it. * Ghidra pseudocode I have heard is on par with IDA 7.0's pseudocode.
I've decided to leave the below sections in this guide for educational purposes, but using a cracked IDA here is more than likely a waste of your time compared to the myriad of options available. Additionally, I obviously cannot condone the usage of such.

If you are dead-set on using the arm64 shared cache:

Before you start analyzing the entire thing, I've already done that! I've publicly shared the fully processed cache here: https://developer.openpack.io/dyld_shared_cache_arm64.i64. Do not let my sacrifice of 4 days be in vain. Use this, don't waste your time.
It includes SpringBoardHome and 740 other frameworks SpringBoardHome depends on. It's a 13 GB file. Have fun.
This is not worth it, you have been warned. Please consider using simulator binaries instead.
Trying to search for a function name will crash IDA entirely. Close the Functions view and open the "Program Segmentation" window. Browse frameworks like this, and carefully scroll through to find the function you want.
Although you can work around the Function name search crash by using a full filter instead of the quick filter, this will cause decompilation to take several minutes while the filter is active. Additionally applying and removing the filter will take several minutes (but typically doesn't crash).

Simulator Binaries: the recommended solution on older IDA versions

The iOS simulator runtime is for you. x64 binaries that don't have the "Red Address" issue are available.
Find them here: /Library/DevelopeCoreSimulatoProfiles/Runtimes/iOS\ 12.4.simruntime/Contents/Resources/RuntimeRoot/System/Library/PrivateFrameworks
You may need to change the name of the folder for the simulator versions you have downloaded and installed.

dsc_fix.py Plugin

This plugin no longer functions, as the IDA SDK no longer provides the needed interfaces. Additionally, it needs to be updated for python3. Probably works on old IDA versions, do let me know.
submitted by _kritanta to jailbreakdevelopers [link] [comments]

what is this i just downloaded (youtube code?)

so this is kinda a wierd story. I was planning to restart my computer. (cant remember why) I spend most of my time watching youtube videos so i had alot of tabs open. So i was watching the videos then deleting the tab but not opening new tabs. So i was down 2 i think 1 it was a pretty long video so i tried to open a youtube home page tab just to look while i listened to the video. And this is a short exerp of what i got.





YouTube











submitted by inhuman7773 to techsupport [link] [comments]

My thoughts on why rust isn't well designed or very practical

It's been a while since I wrote an essay but I'll write this in mostly the same format. I'll give you an overview, explain each point with information and examples then summarize it.
Rust claims to be safe but doesn't help more than a language such as Java, rust design is missing good practices that exist during it's initial development, rust offers no improvement over C++ (except having better default options) but in reality makes it worse and in practice is less useful than language that exist before it.

It claims to be safe

On the homepage rust claims to be memory safe. However you look elsewhere the majority of people and content claim it's safe as in you'll get less bugs than another language such as Java. This is completely not true. Below are some explains of why it doesn't help and most of us can agree Java which is also memory safe isn't considered as 'safe' nor resist bugs.

Doesn't check your arrays at compile time

Rust says it will elimination bounds checking on array access when it can prove the value will never be out of bounds. However there's no way to ask the compiler to give me an error when it can't prove the index will never be out of bounds. Why us there no option? I lost count of how many times I forgot to check the bound after I increment the array index or when I need to look ahead when parsing text.
I found while implementing the check in a toy language for school that it took less than 2 hours and improved the compile time since the check is faster than the time it took to generate the code for the runtime bound check.

Has poor error handling

To contrast Zig has amazing error handling. Rust ask you to put things in a Result (Ok(yourvalue)). However if a function returns a Result you don't have to check it. I'm not even sure if you'll get a warning (I assume you do)
With the amounts of unwraps I seen and the fact rust promotes that style with syntax error handling looks like a nightmare waiting to happen. Not ugly that but I don't believe you can ask the compiler or any sort of tool if a library will panic. I don't think I would be able to trust any sort of libraries I didn't audit or write myself. I can't just check at the namespaces/references/modules it includes/uses

Doesn't have any built in scope guard/error defer

Scopeguards is a practice a significant amount of people use to handle errors. Zig has it, it's called errdefer. D has it built in. Numerous C++ libs has an implementation (here's one from Facebook folly (SCOPE_FAIL)). Rust doesn't have it at all. There is a crate but my issue with this is 1) the syntax promotes a DISASTROUS way of handling errors 2) defer isn't part of the standard library. It's essential and not just for as a scopeguard.

It acceptable to lose data! (Subjective)

From what I seen in the community people will regularly say rust will terminate rather than running a corrupt program and that's a good thing. Losing data/memory is never a good thing and it's completely insane that this is more acceptable than implementing something that resembles error handling

Rust design is missing good practices that exist during it's initial development

Rust is not safe and doesn't help you catch errors

Covered above

Missing syntax

I'll skip the nitpicking and focus on the most important two.
When there is a binary OK/Error in a Result or Some/None in an Option you have to use a full blown match to handle it instead of something that's more readable.
In other languages there syntax to allow you to specify if something can be null (zig lets you write ?i32, C# allows you to write int?). There's also syntax to coalesce null with a value (val = myfn(abc) ?? my_default_number). For something as common as errors and null handling it should have been prioritized.

No reflection/introspection

Python/JavaScript/C#/Java all have it. Rust says to use serde which is highly suspicious. Why use a library instead of the language? It appears the answer is you have to implement a trait, which is not reflection or introspection. This makes it tedious and error prone in a few areas. Especially database access and writing http server code

Standard library missing must have (Subjective)

The standard library has a number of enums/collections/traits. There's a few standard (can be seen here if you search 'error') and it has an implementation for a number of collections. But missing everyday items like regular expression, compression/zlib/gzip, base64 encode/decode etc

Rust offers no improvement over C++ and may make it worse

Slow compile time

In C++ it's well known that templates make compile time slow. It's known you can put less in headers so it takes less time to compile. Rust however explodes compile time with traits and whatever else that's making it slow (it isn't borrow checking)

Less+lower quality static analyzers

There's quality commercial static analyzers available for C++. If we stick to free clang provides good sanitizers (array bounds, memory errors and a huge list of undefined and suspicious behaviour)

Misguiding programmers (subjective)

Officially rust says it's memory safe but the community acts like it's 'safe' as in not likely to cause difficult to fix bugs. They also insist there's no 'null' in the language which is silly since boxing an option emits null pointers. It's fine to say 'values' are 'optional' but insisting there's no null pointers is weird and may cause confusion when people try to imagine how their code will be generated.

Rust doesn't fit in anywhere

For large projects the compile time is significantly slower than C++ so it is unusable. For smaller projects python/javascript/Go/C#/java is preferred due to reflection (less boilerplate) and having a significantly larger standard library which will help reduce development time (unless you happen to already know every community library you need before you start which is generally not likely). Language listed are all memory safe.
For medium size projects C#, Java and Go are still viable and C# runs extremely fast that if you needed the execution speed you're likely to skip rust and go directly to C++ for better speed control. With clang sanitizers rust doesn't have much of a selling point past C++ with a number of disadvantage mentioned above. It mostly have better errors that are turned on by default. I haven't compared debugging in rust vs c++ or how long the compiler takes when using C++ sanitizers. If we're going to compare development time C# runtime speed is within a magnitude of speed and have vastly superior IDEs and tools even on mac and linux.

Summary

Rust lack of error handling and no compile error improvements compared to languages like C#. Rust does not appear to improve software quality. Compared to C++ rust may have slower compile times and C++ has better or on par free static analyzers with quality commercial analyzers available. The rust standard library is smaller than many languages. Rust community appears to misguide people into think it's safer than it is, recommends poor practices (panic and losing memory is 'ok') and may confuse implementation details (no 'null'). Practically in every project size another language/compiler would be better due to development time, less tedious boiler plate and tooling
submitted by IndependentDocument5 to ProgrammingLanguages [link] [comments]

Problem with Unreal Engine's Nativization feature + Visual Studio 2017

Im using UE4.25.1 by the way.
I don't know why it won't allow me to package my game after enabling nativization. I also did add the assets to nativize in the array by manually setting up my blueprint for nativization via Class settings.
It packages and runs smoothly afterwards when nativization is disabled.

I'm getting the ff errors from my output log:
Took 184.0273603s to run UnrealBuildTool.exe, ExitCode=6
UATHelper: Packaging (Windows (64-bit)): UnrealBuildTool failed. See log for more details. (C:\Users\Zelijah\AppData\Roaming\Unreal Engine\AutomationTool\Logs\Z+[GAMES]+Epic+Games+UE_4.25\UBT-InMyHead-Win64-Development.txt)
UATHelper: Packaging (Windows (64-bit)): AutomationTool exiting with ExitCode=6 (6)
UATHelper: Packaging (Windows (64-bit)): BUILD FAILED
PackagingResults: Error: Unknown Error


Here's my full log text file:
AndroidPlatformFactory.RegisterBuildPlatforms: UnrealBuildTool.AndroidPlatformSDK has no valid SDK IOSPlatformFactory.RegisterBuildPlatforms: UnrealBuildTool.IOSPlatformSDK using manually installed SDK LinuxPlatformFactory.RegisterBuildPlatforms: UnrealBuildTool.LinuxPlatformSDK has no valid SDK WindowsPlatformFactory.RegisterBuildPlatforms: UnrealBuildTool.WindowsPlatformSDK using manually installed SDK BuildMode.Execute: Command line: "Z:\[GAMES]\Epic Games\UE_4.25\Engine\Binaries\DotNET\UnrealBuildTool.exe" InMyHead Win64 Development -Project="Z:\Zelijah Media Files\In My Head (feat. Hijo)\UE Assets\[Project]\InMyHead\InMyHead.uproject" "Z:\Zelijah Media Files\In My Head (feat. Hijo)\UE Assets\[Project]\InMyHead\InMyHead.uproject" -NoUBTMakefiles -remoteini="Z:\Zelijah Media Files\In My Head (feat. Hijo)\UE Assets\[Project]\InMyHead" -skipdeploy -Manifest="Z:\Zelijah Media Files\In My Head (feat. Hijo)\UE Assets\[Project]\InMyHead\Intermediate\Build\Manifest.xml" -NoHotReload -log="C:\Users\Zelijah\AppData\Roaming\Unreal Engine\AutomationTool\Logs\Z+[GAMES]+Epic+Games+UE_4.25\UBT-InMyHead-Win64-Development.txt" DynamicCompilation.RequiresCompilation: Compiling Z:\Zelijah Media Files\In My Head (feat. Hijo)\UE Assets\[Project]\InMyHead\Intermediate\Build\BuildRules\InMyHeadModuleRules.dll: Assembly does not exist WindowsPlatform.FindVSInstallDirs: Found Visual Studio installation: Z:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise (Product=Microsoft.VisualStudio.Product.Enterprise, Version=15.9.28307.1146, Sort=0) WindowsPlatform.FindToolChainDirs: Found Visual Studio toolchain: Z:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.16.27023 (Version=14.16.27040) WindowsPlatform.UpdateCachedWindowsSdks: Found Windows 8.1 SDK at C:\Program Files (x86)\Windows Kits\8.1 WindowsPlatform.EnumerateSdkRootDirs: Found Windows 10 SDK root at C:\Program Files (x86)\Windows Kits\10 (1) WindowsPlatform.EnumerateSdkRootDirs: Found Windows 10 SDK root at C:\Program Files (x86)\Windows Kits\10 (2) WindowsPlatform.UpdateCachedWindowsSdks: Found Universal CRT version 10.0.10240.0 at C:\Program Files (x86)\Windows Kits\10 WindowsPlatform.UpdateCachedWindowsSdks: Found Windows 10 SDK version 10.0.14393.0 at C:\Program Files (x86)\Windows Kits\10 WindowsPlatform.UpdateCachedWindowsSdks: Found Universal CRT version 10.0.14393.0 at C:\Program Files (x86)\Windows Kits\10 DynamicCompilation.RequiresCompilation: Compiling Z:\Zelijah Media Files\In My Head (feat. Hijo)\UE Assets\[Project]\InMyHead\Intermediate\Plugins\NativizedAssets\Windows\Game\Intermediate\Build\BuildRules\NativizedAssetsModuleRules.dll: Assembly does not exist UEBuildTarget.AddPlugin: Enabling plugin 'PythonScriptPlugin' (referenced via InMyHead.uproject) UEBuildTarget.AddPlugin: Enabling plugin 'NativizedAssets' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'Paper2D' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'AISupport' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'LightPropagationVolume' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'CameraShakePreviewer' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'ActorLayerUtilities' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'AnimationSharing' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'SignificanceManager' (referenced via default plugins -> AnimationSharing.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'CLionSourceCodeAccess' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'CodeLiteSourceCodeAccess' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'GitSourceControl' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'KDevelopSourceCodeAccess' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'NullSourceCodeAccess' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'PerforceSourceControl' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'PlasticSourceControl' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'RiderSourceCodeAccess' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'SubversionSourceControl' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'UObjectPlugin' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'VisualStudioCodeSourceCodeAccess' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'VisualStudioSourceCodeAccess' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'XCodeSourceCodeAccess' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'AssetManagerEditor' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'CryptoKeys' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'CurveEditorTools' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'DataValidation' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'FacialAnimation' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'GameplayTagsEditor' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'GeometryMode' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'MacGraphicsSwitching' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'MaterialAnalyzer' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'MobileLauncherProfileWizard' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'PluginBrowser' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'SpeedTreeImporter' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'DatasmithContent' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'VariantManagerContent' (referenced via default plugins -> DatasmithContent.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'AlembicImporter' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'GeometryCache' (referenced via default plugins -> AlembicImporter.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'AutomationUtils' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'ScreenshotTools' (referenced via default plugins -> AutomationUtils.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'BackChannel' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'ChaosClothEditor' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'ChaosCloth' (referenced via default plugins -> ChaosClothEditor.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'ChaosEditor' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'PlanarCut' (referenced via default plugins -> ChaosEditor.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'GeometryProcessing' (referenced via default plugins -> ChaosEditor.uplugin -> PlanarCut.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'EditableMesh' (referenced via default plugins -> ChaosEditor.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'GeometryCollectionPlugin' (referenced via default plugins -> ChaosEditor.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'ProceduralMeshComponent' (referenced via default plugins -> ChaosEditor.uplugin -> GeometryCollectionPlugin.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'ChaosSolverPlugin' (referenced via default plugins -> ChaosEditor.uplugin -> GeometryCollectionPlugin.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'ChaosNiagara' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'Niagara' (referenced via default plugins -> ChaosNiagara.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'CharacterAI' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'PlatformCrypto' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'ProxyLODPlugin' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'SkeletalReduction' (referenced via default plugins) UEBuildTarget.AddPlugin: Ignoring plugin 'MagicLeapMedia' (referenced via default plugins) due to unsupported target platform. UEBuildTarget.AddPlugin: Enabling plugin 'MagicLeapPassableWorld' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'MagicLeap' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'MLSDK' (referenced via default plugins -> MagicLeap.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'MagicLeapLightEstimation' (referenced via default plugins -> MagicLeap.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'AndroidMedia' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'AvfMedia' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'ImgMedia' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'MediaCompositing' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'MediaPlayerEditor' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'WmfMedia' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'MeshPainting' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'TcpMessaging' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'UdpMessaging' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'ActorSequence' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'LevelSequenceEditor' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'MatineeToLevelSequence' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'TemplateSequence' (referenced via default plugins -> MatineeToLevelSequence.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'MovieRenderPipeline' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'EditorScriptingUtilities' (referenced via default plugins -> MovieRenderPipeline.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'NetcodeUnitTest' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'NUTUnrealEngine4' (referenced via default plugins) UEBuildTarget.AddPlugin: Ignoring plugin 'OnlineSubsystemGooglePlay' (referenced via default plugins) due to unsupported target platform. UEBuildTarget.AddPlugin: Ignoring plugin 'OnlineSubsystemIOS' (referenced via default plugins) due to unsupported target platform. UEBuildTarget.AddPlugin: Enabling plugin 'OnlineSubsystemNull' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'OnlineSubsystem' (referenced via default plugins -> OnlineSubsystemNull.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'OnlineSubsystemUtils' (referenced via default plugins -> OnlineSubsystemNull.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'LauncherChunkInstaller' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'AndroidDeviceProfileSelector' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'AndroidMoviePlayer' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'AndroidPermission' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'AppleImageUtils' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'AppleMoviePlayer' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'ArchVisCharacter' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'AssetTags' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'AudioCapture' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'CableComponent' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'CustomMeshComponent' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'ExampleDeviceProfileSelector' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'GoogleCloudMessaging' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'GooglePAD' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'IOSDeviceProfileSelector' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'LinuxDeviceProfileSelector' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'LocationServicesBPLibrary' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'MobilePatchingUtils' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'OculusVR' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'PhysXVehicles' (referenced via default plugins) UEBuildTarget.AddPlugin: Ignoring plugin 'PostSplashScreen' (referenced via default plugins) due to unsupported target platform. UEBuildTarget.AddPlugin: Enabling plugin 'RuntimePhysXCooking' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'SoundFields' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'SteamVR' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'Synthesis' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'WebMMoviePlayer' (referenced via default plugins) UEBuildTarget.AddPlugin: Enabling plugin 'WebMMedia' (referenced via default plugins -> WebMMoviePlayer.uplugin) UEBuildTarget.AddPlugin: Enabling plugin 'WindowsMoviePlayer' (referenced via default plugins) LuminSDKVersionHelper.HasAnySDK: *** Unable to determine MLSDK location *** VCToolChain..ctor: Compiler: Z:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.16.27023\bin\HostX64\x64\cl.exe VCToolChain..ctor: Linker: Z:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.16.27023\bin\HostX64\x64\link.exe VCToolChain..ctor: Library Manager: Z:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.16.27023\bin\HostX64\x64\lib.exe VCToolChain..ctor: Resource Compiler: C:\Program Files (x86)\Windows Kits\10\bin\x64\rc.exe ExternalExecution.AreGeneratedCodeFilesOutOfDate: UnrealHeaderTool needs to run because no generated code directory was found for module NativizedAssets ExternalExecution.ExecuteHeaderToolIfNecessary: Parsing headers for InMyHead ExternalExecution.ExecuteHeaderToolIfNecessary: Running UnrealHeaderTool "Z:\Zelijah Media Files\In My Head (feat. Hijo)\UE Assets\[Project]\InMyHead\InMyHead.uproject" "Z:\Zelijah Media Files\In My Head (feat. Hijo)\UE Assets\[Project]\InMyHead\Intermediate\Build\Win64\InMyHead\Development\InMyHead.uhtmanifest" -LogCmds="loginit warning, logexit warning, logdatabase error" -Unattended -WarningsAsErrors -abslog="C:\Users\Zelijah\AppData\Roaming\Unreal Engine\AutomationTool\Logs\Z+[GAMES]+Epic+Games+UE_4.25\UHT-InMyHead-Win64-Development.txt" -installed ExternalExecution.ExecuteHeaderToolIfNecessary: Reflection code generated for InMyHead in 7.4428985 seconds UEBuildTarget.GenerateManifest: Writing manifest to Z:\Zelijah Media Files\In My Head (feat. Hijo)\UE Assets\[Project]\InMyHead\Intermediate\Build\Manifest.xml HotReload.IsLiveCodingSessionActive: Checking for live coding mutex: Global\LiveCoding_Z++Zelijah Media Files+In My Head (feat. Hijo)+UE Assets+[Project]+InMyHead+Binaries+Win64+InMyHead.exe ActionGraph.IsActionOutdated: Module.NativizedAssets.4_of_11.cpp: Produced item "Module.NativizedAssets.4_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.9_of_11.cpp: Produced item "Module.NativizedAssets.9_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.3_of_11.cpp: Produced item "Module.NativizedAssets.gen.3_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: SharedPCH.Engine.cpp: Produced item "SharedPCH.Engine.h.pch" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.9_of_11.cpp: Produced item "Module.NativizedAssets.gen.9_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.4_of_11.cpp: Produced item "Module.NativizedAssets.gen.4_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.7_of_11.cpp: Produced item "Module.NativizedAssets.gen.7_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.8_of_11.cpp: Produced item "Module.NativizedAssets.gen.8_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.6_of_11.cpp: Produced item "Module.NativizedAssets.gen.6_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.8_of_11.cpp: Produced item "Module.NativizedAssets.8_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.7_of_11.cpp: Produced item "Module.NativizedAssets.7_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.1_of_11.cpp: Produced item "Module.NativizedAssets.1_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.5_of_11.cpp: Produced item "Module.NativizedAssets.5_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.2_of_11.cpp: Produced item "Module.NativizedAssets.2_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.5_of_11.cpp: Produced item "Module.NativizedAssets.gen.5_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: InMyHead.target: Produced item "InMyHead.target" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.1_of_11.cpp: Produced item "Module.NativizedAssets.gen.1_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.2_of_11.cpp: Produced item "Module.NativizedAssets.gen.2_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.10_of_11.cpp: Produced item "Module.NativizedAssets.10_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: InMyHead.exe: Produced item "InMyHead.exe" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.10_of_11.cpp: Produced item "Module.NativizedAssets.gen.10_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Default.rc2: Produced item "Default.rc2.res" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.6_of_11.cpp: Produced item "Module.NativizedAssets.6_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.11_of_11.cpp: Produced item "Module.NativizedAssets.gen.11_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.3_of_11.cpp: Produced item "Module.NativizedAssets.3_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: InMyHead.cpp: Produced item "InMyHead.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.11_of_11.cpp: Produced item "Module.NativizedAssets.11_of_11.cpp.obj" doesn't exist. ActionGraph.IsActionOutdated: SharedPCH.Core.cpp: Produced item "SharedPCH.Core.h.pch" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.4_of_11.cpp: Produced item "Module.NativizedAssets.4_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.9_of_11.cpp: Produced item "Module.NativizedAssets.9_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.3_of_11.cpp: Produced item "Module.NativizedAssets.gen.3_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.8_of_11.cpp: Produced item "Module.NativizedAssets.gen.8_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.1_of_11.cpp: Produced item "Module.NativizedAssets.gen.1_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.2_of_11.cpp: Produced item "Module.NativizedAssets.gen.2_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.9_of_11.cpp: Produced item "Module.NativizedAssets.gen.9_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.7_of_11.cpp: Produced item "Module.NativizedAssets.gen.7_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.10_of_11.cpp: Produced item "Module.NativizedAssets.10_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.11_of_11.cpp: Produced item "Module.NativizedAssets.11_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.10_of_11.cpp: Produced item "Module.NativizedAssets.gen.10_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: SharedPCH.Engine.cpp: Produced item "SharedPCH.Engine.h.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.2_of_11.cpp: Produced item "Module.NativizedAssets.2_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: SharedPCH.Core.cpp: Produced item "SharedPCH.Core.h.obj" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.6_of_11.cpp: Produced item "Module.NativizedAssets.gen.6_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.8_of_11.cpp: Produced item "Module.NativizedAssets.8_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.5_of_11.cpp: Produced item "Module.NativizedAssets.gen.5_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: SharedPCH.Engine.cpp: Produced item "SharedPCH.Engine.h.txt" doesn't exist. ActionGraph.IsActionOutdated: InMyHead.exe: Produced item "InMyHead.pdb" was produced by outdated command-line. ActionGraph.IsActionOutdated: New command-line: Z:\[GAMES]\Epic Games\UE_4.25\Engine\Build\Windows\link-filter\link-filter.exe -- "Z:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.16.27023\bin\HostX64\x64\link.exe" @"Z:\Zelijah Media Files\In My Head (feat. Hijo)\UE Assets\[Project]\InMyHead\Intermediate\Build\Win64\InMyHead\Development\InMyHead.exe.response" ActionGraph.IsActionOutdated: SharedPCH.Core.cpp: Produced item "SharedPCH.Core.h.txt" doesn't exist. ActionGraph.IsActionOutdated: InMyHead.cpp: Produced item "InMyHead.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.6_of_11.cpp: Produced item "Module.NativizedAssets.6_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.11_of_11.cpp: Produced item "Module.NativizedAssets.gen.11_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.gen.4_of_11.cpp: Produced item "Module.NativizedAssets.gen.4_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.7_of_11.cpp: Produced item "Module.NativizedAssets.7_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.3_of_11.cpp: Produced item "Module.NativizedAssets.3_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.5_of_11.cpp: Produced item "Module.NativizedAssets.5_of_11.cpp.txt" doesn't exist. ActionGraph.IsActionOutdated: Module.NativizedAssets.1_of_11.cpp: Produced item "Module.NativizedAssets.1_of_11.cpp.txt" doesn't exist. ActionGraph.DeleteOutdatedProducedItems: Deleting outdated item: Z:\Zelijah Media Files\In My Head (feat. Hijo)\UE Assets\[Project]\InMyHead\Binaries\Win64\InMyHead.pdb BuildMode.Build: Building InMyHead... BuildMode.OutputToolchainInfo: Using Visual Studio 2017 14.16.27040 toolchain (Z:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.16.27023) and Windows 10.0.14393.0 SDK (C:\Program Files (x86)\Windows Kits\10). BuildMode.OutputToolchainInfo: [Upgrade] BuildMode.OutputToolchainInfo: [Upgrade] Using backward-compatible build settings. The latest version of UE4 sets the following values by default, which may require code changes: BuildMode.OutputToolchainInfo: [Upgrade] bLegacyPublicIncludePaths = false => Omits subfolders from public include paths to reduce compiler command line length. (Previously: true). BuildMode.OutputToolchainInfo: [Upgrade] ShadowVariableWarningLevel = WarningLevel.Error => Treats shadowed variable warnings as errors. (Previously: WarningLevel.Warning). BuildMode.OutputToolchainInfo: [Upgrade] PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs => Set in build.cs files to enables IWYU-style PCH model. See https://docs.unrealengine.com/en-US/Programming/BuildTools/UnrealBuildTool/IWYU/index.html. (Previously: PCHUsageMode.UseSharedPCHs). BuildMode.OutputToolchainInfo: [Upgrade] Suppress this message by setting 'DefaultBuildSettings = BuildSettingsVersion.V2;' in InMyHead.Target.cs, and explicitly overriding settings that differ from the new defaults. BuildMode.OutputToolchainInfo: [Upgrade] ParallelExecutor.ExecuteActions: Building 28 actions with 16 processes... ParallelExecutor.ExecuteActions: [1/28] Default.rc2 ParallelExecutor.ExecuteActions: [2/28] SharedPCH.Core.cpp ParallelExecutor.ExecuteActions: [3/28] InMyHead.cpp ParallelExecutor.ExecuteActions: [4/28] SharedPCH.Engine.cpp ParallelExecutor.ExecuteActions: [5/28] Module.NativizedAssets.gen.5_of_11.cpp ParallelExecutor.ExecuteActions: [6/28] Module.NativizedAssets.gen.4_of_11.cpp ParallelExecutor.ExecuteActions: [7/28] Module.NativizedAssets.gen.2_of_11.cpp ParallelExecutor.ExecuteActions: [8/28] Module.NativizedAssets.gen.3_of_11.cpp ParallelExecutor.ExecuteActions: [9/28] Module.NativizedAssets.gen.6_of_11.cpp ParallelExecutor.ExecuteActions: [10/28] Module.NativizedAssets.gen.7_of_11.cpp ParallelExecutor.ExecuteActions: [11/28] Module.NativizedAssets.gen.8_of_11.cpp ParallelExecutor.ExecuteActions: [12/28] Module.NativizedAssets.gen.9_of_11.cpp ParallelExecutor.ExecuteActions: [13/28] Module.NativizedAssets.gen.1_of_11.cpp ParallelExecutor.ExecuteActions: [14/28] Module.NativizedAssets.gen.10_of_11.cpp ParallelExecutor.ExecuteActions: [15/28] Module.NativizedAssets.gen.11_of_11.cpp ParallelExecutor.ExecuteActions: [16/28] Module.NativizedAssets.10_of_11.cpp ParallelExecutor.ExecuteActions: Z:/Zelijah Media Files/In My Head (feat. Hijo)/UE Assets/[Project]/InMyHead/Intermediate/Plugins/NativizedAssets/Windows/Game/Source/NativizedAssets/Private/W_PlayerHUD__pf655287937.cpp(571): error C2065: 'UW_Minimap_C__pf655287937': undeclared identifier ParallelExecutor.ExecuteActions: Z:/Zelijah Media Files/In My Head (feat. Hijo)/UE Assets/[Project]/InMyHead/Intermediate/Plugins/NativizedAssets/Windows/Game/Source/NativizedAssets/Private/W_PlayerHUD__pf655287937.cpp(571): error C2672: 'NewObject': no matching overloaded function found ParallelExecutor.ExecuteActions: Z:/Zelijah Media Files/In My Head (feat. Hijo)/UE Assets/[Project]/InMyHead/Intermediate/Plugins/NativizedAssets/Windows/Game/Source/NativizedAssets/Private/W_PlayerHUD__pf655287937.cpp(571): error C2974: 'NewObject': invalid template argument for 'T', type expected ParallelExecutor.ExecuteActions: Z:\[GAMES]\Epic Games\UE_4.25\Engine\Source\Runtime\CoreUObject\Public\UObject/UObjectGlobals.h(1225): note: see declaration of 'NewObject' ParallelExecutor.ExecuteActions: Z:/Zelijah Media Files/In My Head (feat. Hijo)/UE Assets/[Project]/InMyHead/Intermediate/Plugins/NativizedAssets/Windows/Game/Source/NativizedAssets/Private/W_PlayerHUD__pf655287937.cpp(572): error C3536: '__Local__8': cannot be used before it is initialized ParallelExecutor.ExecuteActions: Z:/Zelijah Media Files/In My Head (feat. Hijo)/UE Assets/[Project]/InMyHead/Intermediate/Plugins/NativizedAssets/Windows/Game/Source/NativizedAssets/Private/W_PlayerHUD__pf655287937.cpp(572): error C2440: '': cannot convert from 'int' to 'FUnconvertedWrapper__UW_Minimap_C__pf655287937' ParallelExecutor.ExecuteActions: Z:/Zelijah Media Files/In My Head (feat. Hijo)/UE Assets/[Project]/InMyHead/Intermediate/Plugins/NativizedAssets/Windows/Game/Source/NativizedAssets/Private/W_PlayerHUD__pf655287937.cpp(572): note: No constructor could take the source type, or constructor overload resolution was ambiguous ParallelExecutor.ExecuteActions: Z:/Zelijah Media Files/In My Head (feat. Hijo)/UE Assets/[Project]/InMyHead/Intermediate/Plugins/NativizedAssets/Windows/Game/Source/NativizedAssets/Private/W_PlayerHUD__pf655287937.cpp(575): error C2440: '=': cannot convert from 'int' to 'UWidget *' ParallelExecutor.ExecuteActions: Z:/Zelijah Media Files/In My Head (feat. Hijo)/UE Assets/[Project]/InMyHead/Intermediate/Plugins/NativizedAssets/Windows/Game/Source/NativizedAssets/Private/W_PlayerHUD__pf655287937.cpp(575): note: Conversion from integral type to pointer type requires reinterpret_cast, C-style cast or function-style cast ParallelExecutor.ExecuteActions: [17/28] Module.NativizedAssets.5_of_11.cpp ParallelExecutor.ExecuteActions: [18/28] Module.NativizedAssets.2_of_11.cpp ParallelExecutor.ExecuteActions: [19/28] Module.NativizedAssets.8_of_11.cpp ParallelExecutor.ExecuteActions: [20/28] Module.NativizedAssets.7_of_11.cpp ParallelExecutor.ExecuteActions: [21/28] Module.NativizedAssets.6_of_11.cpp ParallelExecutor.ExecuteActions: [22/28] Module.NativizedAssets.3_of_11.cpp ParallelExecutor.ExecuteActions: [23/28] Module.NativizedAssets.11_of_11.cpp ParallelExecutor.ExecuteActions: [24/28] Module.NativizedAssets.1_of_11.cpp ParallelExecutor.ExecuteActions: [25/28] Module.NativizedAssets.4_of_11.cpp ParallelExecutor.ExecuteActions: [26/28] Module.NativizedAssets.9_of_11.cpp UnrealBuildTool.Main: CompilationResultException: Error: OtherCompilationError UnrealBuildTool.Main: at UnrealBuildTool.ActionGraph.ExecuteActions(BuildConfiguration BuildConfiguration, List`1 ActionsToExecute) in D:\Build\++UE4+Licensee\Sync\Engine\Saved\CsTools\Engine\Source\Programs\UnrealBuildTool\System\ActionGraph.cs:line 242 UnrealBuildTool.Main: at UnrealBuildTool.BuildMode.Build(List`1 TargetDescriptors, BuildConfiguration BuildConfiguration, ISourceFileWorkingSet WorkingSet, BuildOptions Options, FileReference WriteOutdatedActionsFile) in D:\Build\++UE4+Licensee\Sync\Engine\Saved\CsTools\Engine\Source\Programs\UnrealBuildTool\Modes\BuildMode.cs:line 372 UnrealBuildTool.Main: at UnrealBuildTool.BuildMode.Execute(CommandLineArguments Arguments) in D:\Build\++UE4+Licensee\Sync\Engine\Saved\CsTools\Engine\Source\Programs\UnrealBuildTool\Modes\BuildMode.cs:line 219 UnrealBuildTool.Main: at UnrealBuildTool.UnrealBuildTool.Main(String[] ArgumentsArray) in D:\Build\++UE4+Licensee\Sync\Engine\Saved\CsTools\Engine\Source\Programs\UnrealBuildTool\UnrealBuildTool.cs:line 550 Timeline.Print: Timeline: Timeline.Print: Timeline.Print: [ 0.000] Timeline.Print: [ 0.000](+0.053) Timeline.Print: [ 0.053](+0.002) FileMetadataPrefetch.QueueEngineDirectory() Timeline.Print: [ 0.055](+0.229) XmlConfig.ReadConfigFiles() Timeline.Print: [ 0.285](+0.000) SingleInstanceMutex.Acquire() Timeline.Print: [ 0.285](+0.125) UEBuildPlatform.RegisterPlatforms() Timeline.Print: 0.286 [ 0.000](+0.090) Initializing InstalledPlatformInfo Timeline.Print: 0.377 [ 0.091](+0.000) Querying types Timeline.Print: 0.378 [ 0.093](+0.001) MacPlatformFactory Timeline.Print: 0.380 [ 0.094](+0.000) TVOSPlatformFactory Timeline.Print: 0.380 [ 0.095](+0.022) AndroidPlatformFactory Timeline.Print: 0.403 [ 0.117](+0.000) HoloLensPlatformFactory Timeline.Print: 0.403 [ 0.117](+0.002) IOSPlatformFactory Timeline.Print: 0.405 [ 0.120](+0.004) LinuxPlatformFactory Timeline.Print: 0.410 [ 0.124](+0.000) LuminPlatformFactory Timeline.Print: 0.410 [ 0.124](+0.000) WindowsPlatformFactory Timeline.Print: [ 0.418](+0.015) TargetDescriptor.ParseCommandLine() Timeline.Print: [ 0.448](+4.949) UEBuildTarget.Create() Timeline.Print: 0.453 [ 0.004](+3.175) RulesCompiler.CreateTargetRulesAssembly() Timeline.Print: 0.453 0.004 [ 0.000](+2.372) Timeline.Print: 2.825 2.377 [ 2.372](+0.032) Finding engine modules Timeline.Print: 2.858 2.409 [ 2.405](+0.005) Finding plugin modules Timeline.Print: 2.863 2.415 [ 2.410](+0.115) Timeline.Print: 2.978 2.530 [ 2.525](+0.004) Finding program modules Timeline.Print: 2.983 2.534 [ 2.530](+0.002) Finding program targets Timeline.Print: 2.985 2.536 [ 2.532](+0.040) Timeline.Print: 3.026 2.577 [ 2.572](+0.597) Compiling rules assembly (InMyHeadModuleRules.dll) Timeline.Print: 3.628 [ 3.180](+0.360) RulesAssembly.CreateTargetRules() Timeline.Print: 3.989 [ 3.540](+0.079) Timeline.Print: 4.068 [ 3.620](+0.227) Compiling rules assembly (NativizedAssetsModuleRules.dll) Timeline.Print: 4.296 [ 3.848](+0.015) UEBuildTarget constructor Timeline.Print: 4.312 [ 3.864](+1.085) UEBuildTarget.PreBuildSetup() Timeline.Print: [ 5.401](+32.503) UEBuildTarget.Build() Timeline.Print: 5.401 [ 0.000](+0.109) Timeline.Print: 5.511 [ 0.109](+22.197) ExternalExecution.SetupUObjectModules() Timeline.Print: 27.708 [22.307](+0.195) Timeline.Print: 27.903 [22.502](+7.442) Executing UnrealHeaderTool Timeline.Print: 35.347 [29.946](+0.002) ExternalExecution.ResetCachedHeaderInfo() Timeline.Print: 35.349 [29.948](+0.002) ExternalExecution.UpdateDirectoryTimestamps() Timeline.Print: 35.352 [29.950](+0.035) Timeline.Print: 35.387 [29.986](+2.375) UEBuildBinary.Build() Timeline.Print: 37.762 [32.361](+0.141) Timeline.Print: [37.905](+0.002) ActionGraph.CheckPathLengths Timeline.Print: [37.908](+0.020) Timeline.Print: [37.928](+0.001) Reading dependency cache Timeline.Print: [37.930](+0.001) Reading action history Timeline.Print: [37.932](+0.022) ActionGraph.GetActionsToExecute() Timeline.Print: 37.934 [ 0.001](+0.001) Prefetching include dependencies Timeline.Print: 37.936 [ 0.003](+0.017) Cache outdated actions Timeline.Print: [37.955](+0.049) Timeline.Print: [38.004](+145.515) ActionGraph.ExecuteActions() Timeline.Print: [183.519](+0.203) Timeline.Print: [183.722](+0.000) FileMetadataPrefetch.Stop() Timeline.Print: [183.725]

I also tried doing it with a blank project in Unreal and it gives me this message:

Missing UE4Game binary.
You may have to build the UE4 project with your IDE. Alternatively, build using UnrealBuildTool with the commandline:
UE4Game

I decided to post it here since nobody seems to figure out what and where my problem is coming from either from Visual Studio or Unreal itself.... please help me... :(
submitted by jedlsf to gamedev [link] [comments]

Free Binary Option Strategy  Binary Options Buy Sell Indicator  Straight-forward Success SIMPLE BINARY OPTION STRATEGY WITH 85% SUCCESS RATE. MUST WATCH Binary Options 60 Seconds Indicator %100 Winning Trades Binary Options Signals Indicator 100% Free Download! FOREX Trading Strategy  Sliding on Averages

Binary option trading on margin involves high risk, and is not suitable for all investors. As a leveraged product losses are able to exceed initial deposits and capital is at risk. Before deciding to trade binary options or any other financial instrument you should carefully consider your investment objectives, level of experience, and risk Get 9 binary option plugins, code & scripts on CodeCanyon. Buy binary option plugins, code & scripts from $4. All from our global community of web developers. Binary Options Trading Plan Template. Missing: html Must include: html How to Succeed with Binary Options Trading at Home 2020 www.binaryoptions.net Binary options trading in the USA. This cover page design opciones binaris en iqoptions template 40679 is complete compatible with Google Docs. But there is a mistake made by beginning traders Binary option indicator mt4 olymp tradewww.kwarcab-bintan.or.id. By. Corretoras de opções binárias para operar - Juli 13, 2020. 1. 0 Templatemonster's binary options website templates are your best solution if you want to be certain your new audience won't run away to the next website. The purpose of relevant design in the business campaign is difficult to overrate.

[index] [4928] [29413] [5090] [12714] [5159] [27123] [13871] [20987] [2890] [23663]

Free Binary Option Strategy Binary Options Buy Sell Indicator Straight-forward Success

IQ Option Templates Binary Options Strategy ... Binary Options Secret Forex Strategy Forex Method Forex Signals Forex Indicators Forex Template Forex Robot IQ Option Real Tradings IQ Option ... Binary Options Signals Binary Options Tricks % 100 Winning IQ Option Metatrader Market Admin MT4 Market Admin Metatrader Indicators Metatrader Templates Metatrader Signals Safe Forex Brokers Forex ... 60 seconds binary options strategy winning 22 out of 24 trades-100% profit guaranteed - Duration: 26:48. ... LIVE TRADING WITH OUR TEMPLATE !!! - Duration: 25:15. Binary Options Strategy ... Binary Options Templates Binary Options Tricks. Loading... Autoplay When autoplay is enabled, a suggested video will automatically play next. Up next Binary Options Signals Indicator kostenloser Download ... Chaser 1 Minute Template IQ Option REAL Tradings (FREE Download) - Duration: 28:46. Chaser 81 47,058 views. 28:46.

Flag Counter