clean up

Author: behnamasadi

README.md

@@ -142,6 +142,7 @@ This change ensures that VSCode uses the "Ninja Multi-Config" generator by defau
      - [Parallelization with std::packaged_task](docs/asynchronous_programming.md#parallelization-with-std--packaged-task)
    * [Attribute specifier sequence [[ attribute-list ]] ](docs/attribute_specifier_sequence.md)  
    * [Basic IO Operation, Streams, Reading/Writing Files, Formatting Output, cin, scanf, gets, getline, printf](docs/basic_IO_operation.md)  
+   * [Big-endian,_Little-endian](docs/big-endian_little-endian.md)  
    * [Bitset, Bit field, Bitwise Operations](docs/bitset_bit_field_bitwise_operations.md)  
    * [Callable Objects, Callbacks](docs/callable_callbacks.md)  
      - [1. Function Pointers](docs/callable_callbacks.md#1-function-pointers)
@@ -165,7 +166,7 @@ This change ensures that VSCode uses the "Ninja Multi-Config" generator by defau
    * [Const, Constexpr and Mutable](docs/const_constexpr_mutable.md)    
    * [Immutable Objects](docs/immutable_objects.md)  
    * [Data Types, Numerical Limits, Machine Epsilon, Precision](docs/primitive_data_types_numerical_limits_machine_epsilon_precision.md)    
-   * [Data Types Conversions, Casting](docs/type_conversions_casting.md)  
+   * [Data Types Conversions, Casting, Type Coercion](docs/type_conversions_casting_type_coercion.md)  
    * [Decay](docs/decay.md)  
    * [Dynamic Memory Allocation in C](docs/dynamic_memory_allocation.md)  
    * [Enum](docs/enum.md)  
@@ -299,14 +300,15 @@ This change ensures that VSCode uses the "Ninja Multi-Config" generator by defau
    * [C++ Translation Units](docs/translation_units.md)   
    * [Undefined behavior, Unspecified and Implementation-Defined](docs/undefined_unspecified_implementation_defined.md)   
    * [Printing List of All Included Headers](docs/print_all_included_headers.md)   
-   * [fPIE (Position Independent Executable) and fPIC(Position Independent Code and) ](docs/fPIE_and_fPIC.md)  
+   * [fPIE (Position Independent Executable) and fPIC(Position Independent Code and) ](docs/fPIE_and_fPIC.md)
+   * [Lexical Analyzer](docs/)     
 
 
 ## [Optimizing C++](src/optimizing_cpp)
 ## [Data File Storage Parsing](#)
-   * [CSV ](src/third_party_tools/csv)  
+   * [CSV ](docs/csv.md)  
    * [YAML ](src/third_party_tools/yaml)  
-   * [JASON ](src/third_party_tools/jason)  
+   * [JASON](docs/json.md)  
    * [XML ](src/third_party_tools/xml/)  
 ## [Code Benchmarking](src/third_party_tools/benchmark)
    * [Google Benchmark ](src/third_party_tools/benchmark)  

docs/big-endian_little-endian.md

@@ -0,0 +1,171 @@
+## Big-endian, Little-endian
+"big-endian" and "little-endian" are terms that describe the order in which bytes are arranged within a binary representation of a number.
+
+- **Big-endian**: The most significant byte (the "big end") is stored at the smallest memory address.
+- **Little-endian**: The least significant byte (the "little end") is stored at the smallest memory address.
+
+Here's a simple C++ example to illustrate big-endian byte order:
+
+1. **Understand the concept**: Let's consider the integer `0x12345678`. In big-endian order, this integer is stored in memory as:
+
+   ```
+   Address    Value
+   0x00       12
+   0x01       34
+   0x02       56
+   0x03       78
+   ```
+
+2. **Code Example**:
+   Below is a simple C++ program that shows how to determine if your system is big-endian and how to manually interpret an integer as big-endian.
+
+```cpp
+#include <iostream>
+
+// Function to check if the system is big-endian
+bool isBigEndian() {
+    unsigned int test = 1;
+    char *byte = (char*)&test;
+    return byte[0] == 0;
+}
+
+// Function to print bytes of an integer
+void printBytes(int value) {
+    unsigned char *bytes = (unsigned char*)&value;
+    for (size_t i = 0; i < sizeof(int); ++i) {
+        std::cout << std::hex << (int)bytes[i] << " ";
+    }
+    std::cout << std::dec << std::endl;
+}
+
+int main() {
+    int number = 0x12345678;
+    
+    std::cout << "System is " << (isBigEndian() ? "Big-endian" : "Little-endian") << std::endl;
+    
+    std::cout << "Original integer: 0x" << std::hex << number << std::dec << std::endl;
+    
+    std::cout << "Bytes in memory: ";
+    printBytes(number);
+    
+    return 0;
+}
+```
+
+### Explanation:
+
+1. **isBigEndian Function**:
+   - We create an unsigned integer `test` with a value of `1`.
+   - We then cast the address of `test` to a `char*` (pointer to a byte).
+   - If the first byte (`byte[0]`) is `0`, it means the most significant byte is at the lowest address, indicating a big-endian system.
+
+2. **printBytes Function**:
+   - This function prints out the bytes of an integer.
+   - We cast the address of the integer to an `unsigned char*` to access individual bytes.
+   - We then print each byte in hexadecimal format.
+
+3. **main Function**:
+   - We define an integer `number` with the value `0x12345678`.
+   - We check and print whether the system is big-endian or little-endian.
+   - We print the original integer in hexadecimal format.
+   - We call `printBytes` to print the bytes of the integer as they are stored in memory.
+
+When you run this program, it will tell you whether your system is big-endian or little-endian and show you the byte order of the integer `0x12345678` in memory.
+
+
+
+
+In a little-endian system, the least significant byte is stored at the smallest memory address. For the integer `0x12345678`, this means that the bytes are stored in reverse order compared to a big-endian system.
+
+Here’s how `0x12345678` would be stored in memory on a little-endian system:
+
+```
+Address    Value
+0x00       78
+0x01       56
+0x02       34
+0x03       12
+```
+
+Let's update the previous C++ example to include a demonstration of this. We'll add a function to print the bytes in both big-endian and little-endian formats to make the difference clear:
+
+```cpp
+#include <iostream>
+
+// Function to check if the system is big-endian
+bool isBigEndian() {
+    unsigned int test = 1;
+    char *byte = (char*)&test;
+    return byte[0] == 0;
+}
+
+// Function to print bytes of an integer in the current system's endian format
+void printSystemBytes(int value) {
+    unsigned char *bytes = (unsigned char*)&value;
+    for (size_t i = 0; i < sizeof(int); ++i) {
+        std::cout << std::hex << (int)bytes[i] << " ";
+    }
+    std::cout << std::dec << std::endl;
+}
+
+// Function to print bytes of an integer in big-endian format
+void printBigEndianBytes(int value) {
+    unsigned char *bytes = (unsigned char*)&value;
+    for (int i = sizeof(int) - 1; i >= 0; --i) {
+        std::cout << std::hex << (int)bytes[i] << " ";
+    }
+    std::cout << std::dec << std::endl;
+}
+
+int main() {
+    int number = 0x12345678;
+    
+    std::cout << "System is " << (isBigEndian() ? "Big-endian" : "Little-endian") << std::endl;
+    
+    std::cout << "Original integer: 0x" << std::hex << number << std::dec << std::endl;
+    
+    std::cout << "Bytes in system's endian format: ";
+    printSystemBytes(number);
+    
+    std::cout << "Bytes in big-endian format: ";
+    printBigEndianBytes(number);
+    
+    return 0;
+}
+```
+
+### Explanation:
+
+1. **printSystemBytes Function**:
+   - This function prints out the bytes of an integer as they are stored in the current system's endian format.
+   - It accesses the bytes by casting the address of the integer to an `unsigned char*` and prints each byte in hexadecimal format.
+
+2. **printBigEndianBytes Function**:
+   - This function prints the bytes of the integer in big-endian format, regardless of the system's actual byte order.
+   - It iterates through the bytes in reverse order to simulate big-endian storage.
+
+3. **main Function**:
+   - Defines an integer `number` with the value `0x12345678`.
+   - Checks and prints whether the system is big-endian or little-endian.
+   - Prints the original integer in hexadecimal format.
+   - Calls `printSystemBytes` to print the bytes in the system's endian format.
+   - Calls `printBigEndianBytes` to print the bytes in big-endian format.
+
+### Output Example:
+On a little-endian system, the output might look like this:
+```
+System is Little-endian
+Original integer: 0x12345678
+Bytes in system's endian format: 78 56 34 12 
+Bytes in big-endian format: 12 34 56 78 
+```
+
+On a big-endian system, the output might look like this:
+```
+System is Big-endian
+Original integer: 0x12345678
+Bytes in system's endian format: 12 34 56 78 
+Bytes in big-endian format: 12 34 56 78 
+```
+
+This shows how the bytes of `0x12345678` are stored in memory on both little-endian and big-endian systems.