ASCII to Unicode — How Text Is Stored and Moved

A concise, practical guide to ASCII, its limits, and how Unicode (UTF-8/16/32) solves them. Examples use C.

ASCII in One Page

ASCII (American Standard Code for Information Interchange) encodes characters with 7 bits (0–127).

+-- zone (3 bits) --+--- digit (4 bits) ---+
 b6      b5     b4      b3  b2  b1   b0

• Historically, links and memory often used an extra 8th bit (parity or just 0).

• Character sets included:

  • Control characters: 0–31 and 127 (NUL, BEL, CR, LF, ESC, DEL)
  • Printable: space (32), punctuation, digits 0–9, A–Z, a–z

Reading the classic table

• Column gives the zone (upper 3 bits), row gives the digit (lower 4 bits). Example for 'A': zone 100, digit 0001 → 1000001₂ → 0x41 → decimal 65.

Common Ranges (you’ll use these daily)

Case bit trick Upper/lower differ by 0x20 (bit 5).

• 'a' - 'A' == 32
• c ^ 0x20 toggles case when c is an ASCII letter.

C Snippets

Print ASCII code of a character

#include <stdio.h>

int main(void) {
    char c = 'A';
    printf("char: %c, dec: %d, hex: 0x%02X, bin: ", c, (unsigned char)c, (unsigned char)c);

    unsigned char u = (unsigned char)c;
    for (int i = 7; i >= 0; --i) {
        putchar((u & (1u << i)) ? '1' : '0');
    }
    putchar('\n');
    return 0;
}

Lowercase/uppercase (ASCII only)

#include <stdbool.h>

static inline bool is_upper_ascii(char c) { return c >= 'A' && c <= 'Z'; }
static inline bool is_lower_ascii(char c) { return c >= 'a' && c <= 'z'; }

static inline char to_lower_ascii(char c) {
    return is_upper_ascii(c) ? (char)(c | 0x20) : c;   // set bit 5
}

static inline char to_upper_ascii(char c) {
    return is_lower_ascii(c) ? (char)(c & ~0x20) : c;  // clear bit 5
}

Minimal ASCII table (printables only)

#include <stdio.h>

int main(void) {
    for (int i = 32; i <= 126; ++i) {
        printf("%3d 0x%02X '%c'%s", i, i, (char)i, (i % 8 == 7) ? "\n" : "   ");
    }
    printf("\n");
    return 0;
}

Why ASCII Wasn’t Enough

ASCII covers 128 symbols. That’s fine for basic English, but it cannot represent:

• Accented Latin letters (é, ü), math symbols, emoji
• Non-Latin scripts (한국어, 日本語, العربية, …)

Historic workarounds:

• Extended ASCII (8-bit code pages): incompatible sets above 0x7F
• EBCDIC (IBM mainframes): different 8-bit layout
• BCD (Binary-Coded Decimal): encodes digits in 4 bits; not a character set

These lacked global interoperability.

Unicode: One Code Space for All Writing Systems

Unicode assigns a unique code point to each character: U+0041 'A', U+AC00 '가', U+1F600 '😀', …

Unicode is a catalog of code points; you still need an encoding to store/transmit:

UTF-8

• Variable length (1–4 bytes)
• ASCII 0x00–0x7F maps to exactly the same single byte → backward compatible
• Dominant on the web and UNIX-like systems

UTF-16

• 2 or 4 bytes (surrogate pairs)
• Common in Windows and some language runtimes

UTF-32

• Fixed 4 bytes per code point (simple, larger memory footprint)

Rule of thumb: use UTF-8 unless a legacy interface requires otherwise.

ASCII vs Unicode in Practice

• ASCII is a subset of Unicode: U+0000–U+007F.
• In UTF-8, those code points use the same bytes as ASCII.
• The moment you need anything beyond ASCII (accents, CJK, emoji), store and serve text as UTF-8.

Quick Reference

ASCII   : 7-bit (0x00–0x7F). Often stored in 8 bits.
EBCDIC  : IBM 8-bit alternative; different assignments.
BCD     : Decimal digits in 4 bits (not a character set).
Unicode : Universal code points (U+0000…); needs an encoding.
UTF-8   : 1–4 bytes, ASCII-compatible. Default choice today.
UTF-16  : 2/4 bytes with surrogates.
UTF-32  : 4 bytes fixed width.

Decode (practice)

1. 0x41 → 0100 0001₂ → 'A'
2. 0x30–0x39 → '0'…'9'
3. 0x61 (0110 0001₂) → 'a'; toggle case: 0x61 ^ 0x20 = 0x41 ('A')

Binary Representation of Numbers — A Practical Guide (Integers & Floats)

Why multiple representations?

Computers store values in fixed-width bit strings. For signed integers we need a way to encode “−” as well as magnitude. Three classic schemes exist:

• Sign–Magnitude
• One’s Complement
• Two’s Complement (what modern CPUs use)

They agree on non-negative encodings but differ in how they encode negatives and how arithmetic works.

Sign–Magnitude

• Layout (for an n-bit word): [ sign (1 bit) | magnitude (n−1 bits) ] sign 0 = “+”, sign 1 = “−”.
• Example (8-bit): +21 = 0 | 0010101₂ −21 = 1 | 0010101₂
• Pros: Intuitively mirrors human notation.
• Cons: Two zeros (+0 = 0|000…0, −0 = 1|000…0), and hardware must treat sign separately for addition/subtraction.

Value range (n bits): −(2^(n−1)−1) … + (2^(n−1)−1) (note: both +0 and −0 exist)

One’s Complement (1’s complement)

• Rule: Represent a negative number by bitwise inverting the positive pattern.

• Example (8-bit):

  +21 = 0001 0101
  −21 = ~0001 0101 = 1110 1010

• Pros: Subtraction can be implemented as “add the one’s complement”.

• Cons: Still has −0 = 1111 1111, so there are two zeros; arithmetic needs end-around carry fix-ups.

Value range (n bits): −(2^(n−1)−1) … + (2^(n−1)−1) (with ±0)

Two’s Complement (2’s complement)

• Rule: Represent −x by invert the bits of x and add 1 (modulo 2^n).

• Example (8-bit):

  +21 = 0001 0101
  ~   = 1110 1010
  +1  = 1110 1011  -> −21

• Pros: A single zero, and the same adder does both addition & subtraction. Simple sign extension.

• Cons: Asymmetric range (one extra negative value).

Value range (n bits): −2^(n−1) … + (2^(n−1)−1) (e.g., 8-bit: −128 … +127)

Worked example: ±21 in 8 bits

Tip: Sign extension (two’s complement): when widening, copy the sign bit into the new upper bits. Example: 1110 1011 (−21, 8-bit) → 1111 1111 1110 1011 (−21, 16-bit).

Quick comparison

Self-check: encode −39 in 3 bytes (24 bits)

Let n = 24.

1. Sign–Magnitude

• Magnitude of 39 = …000100111₂.
• Result: 1 | 000000000000000000100111

2. One’s Complement

• +39 = 00000000 00000000 00100111
• Invert → 11111111 11111111 11011000 (hex 0xFFFFD8)

3. Two’s Complement

• Take one’s complement and add 1 → 11111111 11111111 11011001 (hex 0xFFFFD9)

Real numbers: fixed-point vs floating-point

Computers also need fractions. Two main approaches:

Fixed-point

• The binary point is at a fixed, agreed position.
• Great for DSP/embedded when range and scaling are known.
• Simple hardware, predictable overflow, but limited dynamic range.

Floating-point (IEEE-754)

• Scientific-notation style: value = (−1)^sign × 1.fraction × 2^(exponent − bias) (for normalized numbers)
• Much wider dynamic range than fixed-point.
• Standard layouts:

Single precision (32-bit)

[ sign (1) | exponent (8, bias=127) | fraction (23) ]

Double precision (64-bit)

[ sign (1) | exponent (11, bias=1023) | fraction (52) ]

The implicit leading 1. is not stored for normalized numbers; the fraction field holds the bits after the point.

Converting a binary fraction to IEEE-754

Example: convert 100010.101₂ to single & double precision.

1. Normalize so the leading bit is 1:

   100010.101₂ = 1.00010101₂ × 2^5

2. Sign: 0 (positive)

3. Exponent:

   • Single: 5 + 127 = 132 = 1000 0100₂
   • Double: 5 + 1023 = 1028 = 100 0000 0100₂

4. Fraction (drop the leading 1. and fill right with zeros):

   • From 1.00010101₂ → fraction bits 00010101…

Final encodings

• Single (32-bit) Bits: 0 | 10000100 | 00010101000000000000000 Hex: 0x420A8000

• Double (64-bit) Bits: 0 | 10000000100 | 0001010100000000000000000000000000000000000000000000 Hex: 0x4041500000000000

Quick reference & formulas

• One’s complement (n bits)

  encode(+x) = binary(x)
  encode(−x) = (2^n − 1) − binary(x)

• Two’s complement (n bits)

  encode(+x) = binary(x)
  encode(−x) = 2^n − binary(x)  = (~binary(x) + 1) mod 2^n

• Sign extension (two’s complement)

  from n→m bits (m>n): replicate sign bit into the new high (m−n) bits

• Quick & simple: sudo apt-mark hold <package>
• Strict version pin: create /etc/apt/preferences.d/<package>.pref with Pin: version <x.y.z>
• (Optional) Disable the vendor repo if it keeps offering newer builds.

Why pin?

If updating a package (e.g., FortiClient) breaks your workflow, you can freeze that package at a working version while keeping the rest of the system updated.

This works whether you installed the app via:

• apt install ./file.deb (local .deb)
• apt install <package> (from a repo)

1) Easiest: apt-mark hold

# Freeze the package at its current version
sudo apt-mark hold forticlient

# Verify
apt-mark showhold
# (shows: forticlient)

# Later, to allow upgrades again
sudo apt-mark unhold forticlient

After this, sudo apt upgrade will skip forticlient.

Tip – simulate an upgrade to confirm:

apt -s upgrade | grep -i forticlient || echo "forticlient not scheduled for upgrade"

2) Pin a specific version (APT pinning)

Use this when you want to lock to an exact version.

# Create a pin file for this package/version
sudo tee /etc/apt/preferences.d/forticlient.pref >/dev/null <<'EOF'
Package: forticlient
Pin: version 7.4.0.1636
Pin-Priority: 1001
EOF

# Refresh and inspect policies
sudo apt update
apt policy forticlient

• Pin-Priority: 1001 ensures your chosen version wins over newer ones.
• To upgrade later, remove the pin:

sudo rm /etc/apt/preferences.d/forticlient.pref
sudo apt update

# Optionally install a specific version when you're ready
sudo apt install forticlient=7.4.3.1736

3) (Optional) Disable a vendor repo

If a vendor repo keeps pushing newer versions, it will still be ignored by hold/pinning, but you can disable it for cleanliness:

# Check for vendor list files
ls /etc/apt/sources.list.d | grep -i forti

# Example: comment out entries inside that list file
sudo sed -i 's/^\s*deb /# deb /' /etc/apt/sources.list.d/fortinet.list
sudo apt update

Example: FortiClient

If apt list --installed shows:

forticlient/now 7.4.0.1636 amd64 [installed,upgradable to: 7.4.3.1736]

Option A – hold:

sudo apt-mark hold forticlient
apt-mark showhold

Option B – exact version pin:

sudo tee /etc/apt/preferences.d/forticlient.pref >/dev/null <<'EOF'
Package: forticlient
Pin: version 7.4.0.1636
Pin-Priority: 1001
EOF

sudo apt update
apt policy forticlient

Notes & Tips

• apt update only refreshes indexes; upgrades happen on apt upgrade / apt full-upgrade.
• hold applies to the package name you specify. If the vendor changes the package name, re-apply the hold for the new name.
• To hold multiple packages:

sudo apt-mark hold pkg1 pkg2 pkg3

• You can always force-install a specific version (if available in any enabled repo or local cache):

sudo apt install package=VERSION

Unfreeze later

When the vendor fixes the issue and you're ready to upgrade:

# If you used hold:
sudo apt-mark unhold forticlient

# If you used pinning:
sudo rm /etc/apt/preferences.d/forticlient.pref

sudo apt update
sudo apt upgrade

That's it—your system stays updated while your problematic app version remains stable.

https://wikidocs.net/170339

DPI-C & UVM

• DPI is an interface between SystemVerilog and a foreign programming language.
• Two layers, both sides of DPI are fully isolated
  • the SystemVerilog layer
  • a foreign language layer
• For now, SystemVerilog defines a foreign language layer only for the C programming language

UVM

Universial Verification Methodology https://wikidocs.net/170314!

https://systemc.org/ SystemC™ addresses the need for a system design and verification language that spans hardware and software. It is a language built in standard C++ by extending the language with the use of class libraries. The language is particularly suited to model system's partitioning, to evaluate and verify the assignment of blocks to either hardware or software implementations, and to architect and measure the interactions between and among functional blocks.

An SoC is literally a system on a chip, consisting of both silicon and embedded software. Its design involves complex algorithm and architecture development and analysis similar to that performed in system design – a trade-off process that determines critical metrics, such as SOC performance, functionality, and power consumption.

Consequently, design tools must deliver orders-of-magnitude improvement in productivity at both architectural and implementation (RT and physical) levels. Moreover, tools must support a methodology that enables the early development of embedded application and system software, long before the availability of the RTL design or silicon prototype. Failure to achieve the requisite improvements in design productivity would result in missed market windows, and exploding design costs.

SystemC is a single, unified design and verification language that expresses architectural and other system-level attributes in the form of open-source C++ classes. It enables design and verification at the system level, independent of any detailed hardware and software implementation, as well as enabling co-verification with RTL design. This higher level of abstraction enables considerably faster, more productive architectural trade-off analysis, design, and redesign than is possible at the more detailed RT level. Furthermore, verification of system architecture and other system-level attributes is orders of magnitude faster than that at the pin-accurate, timing-accurate RT level.

The SystemC community consists of a large and growing number of system design companies, semiconductor companies, intellectual property providers, and EDA tool vendors who have joined together to support and promote the standard.

QEMU

https://www.qemu.org/docs/master/ QEMU is a generic and open source machine emulator and virtualizer.

QEMU can be used in several different ways. The most common is for System Emulation, where it provides a virtual model of an entire machine (CPU, memory and emulated devices) to run a guest OS. In this mode the CPU may be fully emulated, or it may work with a hypervisor such as KVM, Xen or Hypervisor.Framework to allow the guest to run directly on the host CPU.

The second supported way to use QEMU is User Mode Emulation, where QEMU can launch processes compiled for one CPU on another CPU. In this mode the CPU is always emulated. QEMU also provides a number of standalone command line utilities, such as the qemu-img disk image utility that allows you to create, convert and modify disk images. When operating in user mode, only the user-level code is translated. In system mode, the entire system, including kernel-level code is translated.

1. Execute QEMU is not an RTL‑accurate simulator. It is a full‑system emulator that translates a guest CPU's binary code into host instructions at run‑time, drives that code from a software‑defined "soft‑MMU," and connects the resulting virtual machine to an extensive catalogue of device models. This approach gives near‑native speed on a developer laptop while remaining completely architecture‑agnostic.

2. Dynamic binary translation with TCG Stage Because translation is demand‑driven, hot paths stay cached while cold code never incurs compilation cost. With this "Tiny Code Generator" (TCG) design, a new host CPU needs only a ~2 kLOC back‑end, while each new guest ISA needs a front‑end translator. This split is why QEMU today supports more than 20 architectures without exploding in size.

3. The Soft‑MMU and memory‑mapped I/O

   3.1 Address translation Every guest memory access issued by generated code is wrapped in a helper that goes through QEMU's soft‑MMU TLB. The TLB entries are patched directly into the host code, so the fast path is just a couple of host instructions. A miss traps back into C, performs page‑table walks, and repatches the TB‑‑exactly mirroring real hardware, but in software.

   3.2 MMIO hooks If the physical address lies inside a MemoryRegion flagged as device, the load/store is re‑routed to an emulated callback (, ). Device authors therefore implement register‑level side‑effects in standard C while the common memory API handles endianness, burst limitations, coalesced writes, and KVM ioeventfd plumbing.

   
   

4. Device modelling architecture

   • QOM (QEMU Object Model). All devices, buses and even CPUs are QOM objects, enabling run‑time type checking, property wiring and hot‑plug.
   • Bus hierarchy. Templates exist for PCI, USB, VirtIO, SPI, I²C, AXI, etc. A MemoryRegion can be placed behind any bus master to create bridges, address windows or DMA engines.
   • Firmware integration. ACPI tables or Flattened Device Tree blobs are generated automatically so that unmodified kernels "see" the devices exactly as hardware would present them.

   Compared with cycle‑accurate simulators, the timing model is intentionally loosely timed: the goal is functional correctness plus "good enough" latency to boot real OSes and run benchmarks.

   
   

5. Acceleration paths: pure TCG vs. KVM/HVF/WHPX Pure TCG – portable, single‑binary, no privileges required; speed is 10‑30 × slower than hardware but fast enough for firmware bring‑up, CI and fuzzing. KVM/Hypervisor.framework/WHPX – when the host supports hardware virtualisation for the same ISA, QEMU can skip TCG for most user code and let the CPU run it natively. Device emulation, soft‑MMU for MMIO, and snapshot logic remain identical, preserving the portable machine description. Switching between these modes is often just on the command line.-accel kvm:tcg

   
   

6. How it differs from RTL simulation Aspect

Because QEMU does not model wire‑level timing, it cannot expose hazards like hold‑time violations or DDR read levelling errors. Conversely, RTL cannot realistically boot Linux in seconds on a laptop. Many silicon teams therefore run both‑‑QEMU for software velocity, RTL for hardware sign‑off.

7. Typical workflow for an Arm‑on‑x86 project

# Build
$ ../configure --target-list=aarch64-softmmu --enable-debug
$ make -j$(nproc)
# Run U‑Boot and Linux kernel under TCG
$ qemu-system-aarch64 \
    -machine virt,secure=on,gic-version=3 \
    -cpu cortex-a55 \
    -m 2G \
    -bios u-boot.elf \
    -kernel Image \
    -append "earlycon console=ttyAMA0" \
    -device loader,file=rootfs.cpio,addr=0x84000000
# Attach gdb to inspect MMIO registers
(gdb) target remote :1234

Device events () will fire in the host process every time the guest kernel touches an emulated register, letting you printf‑trace firmware interactions without hardware.readfn/writefn

Virtualization?

https://www.slideshare.net/GauravSuri1/virtualization-and-hypervisors

Why Use glab?

Using glab, you can:

• List, view, and create Merge Requests
• Manage Issues
• Clone repositories
• Automate GitLab workflows
• Merge, rebase, and approve MRs directly from the terminal

This is especially useful for developers and DevOps engineers who frequently work with GitLab.

Installation Methods for Ubuntu/Debian

There are several ways to install glab on Debian-based systems. Below are the most reliable methods:

1. Install via WakeMeOps Repository (Recommended)

This is one of the easiest ways to install glab using a package manager.

# Add the WakeMeOps repository
curl -sSL "https://raw.githubusercontent.com/upciti/wakemeops/main/assets/install_repository" | sudo bash

# Install glab
sudo apt install glab

After installation, verify the version:

glab --version

2. Install via Prebuilt-MPR Repository

If you prefer using a prebuilt .deb package instead of compiling from source, follow these steps:

# Add the Prebuilt-MPR repository
wget -qO - 'https://proget.makedeb.org/debian-feeds/prebuilt-mpr.pub' | gpg --dearmor | sudo tee /usr/share/keyrings/prebuilt-mpr-archive-keyring.gpg 1> /dev/null

echo "deb [arch=all,$(dpkg --print-architecture) signed-by=/usr/share/keyrings/prebuilt-mpr-archive-keyring.gpg] https://proget.makedeb.org prebuilt-mpr $(lsb_release -cs)" | sudo tee /etc/apt/sources.list.d/prebuilt-mpr.list

# Update package lists
sudo apt update

# Install glab
sudo apt install glab

After installation, check the version:

glab --version

3. Install from Source via Makedeb (Advanced Users)

If you want to compile glab from source, use makedeb:

git clone 'https://mpr.makedeb.org/glab'
cd glab/
makedeb -si

This method ensures you have the latest version but requires additional dependencies.

How to Use glab

Once installed, you can authenticate and start using glab.

Login to GitLab

glab auth login

• Select gitlab.com (or your self-hosted GitLab instance).
• Enter your Personal Access Token (which can be generated from GitLab under Settings → Access Tokens).

List Open Merge Requests

glab mr list

View a Specific Merge Request

glab mr view <MR-ID>

Example:

glab mr view 42

Merge a Merge Request

glab mr merge <MR-ID>

List Issues

glab issue list

Reference

https://docs.gitlab.com/editor_extensions/gitlab_cli/#install-the-cli https://gitlab.com/gitlab-org/cli/#installation https://gitlab.com/gitlab-org/cli/-/blob/main/docs/installation_options.md#linux https://docs.makedeb.org/prebuilt-mpr/getting-started/#setting-up-the-repository

Understanding Decimal Representation in Computers: Zoned Decimal and Packed Decimal

The way computers store and calculate numbers is crucial, especially in environments like mainframes or embedded systems where decimal formats such as 'Zoned Decimal' and 'Packed Decimal' are often used. In this article, we'll explain the differences between these two formats and provide examples to help you understand their characteristics.

What is Zoned Decimal?

Zoned Decimal is a method of representing decimal numbers by converting each digit into an ASCII or EBCDIC character code. Each position combines a 'zone bit' and a 'digit bit,' making it easier for humans to read. For example, if we represent the number "1234" in Zoned Decimal, it would look like this:

Zoned Decimal Example (using EBCDIC code)

1: F1 (in binary 11110001)

2: F2 (in binary 11110010)

3: F3 (in binary 11110011)

4: F4 (in binary 11110100)

Here, F represents the zone bits, while 1, 2, 3, and 4 are the digit bits. The zone bits are typically fixed as F (1111), and the digit bits represent the value of each digit. Thus, "1234" uses a total of 4 bytes. This type of data storage is easy for humans to interpret.

The key feature of Zoned Decimal is its high readability. Since each digit is clearly represented as a character, it's easy for people to understand when debugging or maintaining the data. However, this comes at the cost of memory efficiency. Since each digit takes up 1 byte, more memory is required.

What is Packed Decimal?

Packed Decimal is a method that compresses numeric data to optimize memory usage. In this format, two digits are stored in a single byte. By using Packed Decimal, you can represent the same number with fewer bytes. For instance, representing the number "213" in Packed Decimal would be as follows:

Packed Decimal Example

21: Stored in the first byte (in binary 00100001)

3: Stored in the second byte, including the sign (for positive numbers, 00111100, where the last 4 bits C indicate a positive value)

Thus, +213 is represented as 00100001 00111100 in binary. The last 4 bits C indicate that the number is positive.

Packed Decimal Example (for -213)

21: Stored in the first byte (in binary 00100001)

3: Stored in the second byte, including the sign (for negative numbers, 00111101, where the last 4 bits D indicate a negative value)

Thus, -213 is represented as 00100001 00111101 in binary. The last 4 bits D indicate that the number is negative.

The main advantage of Packed Decimal is memory efficiency. You can store the same number with fewer bytes, which is beneficial when dealing with large amounts of data. However, since the numbers are stored in a format that is harder for humans to interpret, the readability is lower.

Summary of Differences Between Zoned Decimal and Packed

When to Use Which?

Zoned Decimal is useful in situations where human readability or debugging is important. The high readability makes it easy to understand the state of the numeric data.

Packed Decimal is preferable in environments with limited memory or when handling large amounts of numeric data. The efficient use of memory allows you to store more data.

1. Prerequisites: Tools Installation

Before configuring Vim, you need to install essential tools like Vim, Ctags, Cscope, and a plugin manager.

1.1) Install Vim If Vim is not already installed, you can install it using your package manager. Make sure to use a version that supports plugins like YouCompleteMe (Vim 9.1+).

sudo apt install vim # For Ubuntu

1.2) Install Ctags Ctags helps index your code symbols so that you can jump to their definitions.

sudo apt install exuberant-ctags

1.3) Install Cscope Cscope allows for advanced code navigation, such as finding all references of a function.

sudo apt install cscope

1.4) Install a Plugin Manager (Vim-Plug) Vim-Plug is a lightweight plugin manager for Vim.

curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

2. Configure .vimrc File

Your .vimrc file is where you will configure Vim and set up all the plugins. You can open this file for editing by running:

vim ~/.vimrc

Below is an example configuration that you can add to your .vimrc.

call plug#begin('~/.vim/plugged')

" YouCompleteMe: Code completion
Plug 'ycm-core/YouCompleteMe'

" Gutentags: Automatically manage Ctags
Plug 'ludovicchabant/vim-gutentags'

" Cscope integration
Plug 'mtth/scratch.vim'

" NERDTree: File explorer
Plug 'preservim/nerdtree'

" FZF: Fuzzy file finder
Plug 'junegunn/fzf.vim'

call plug#end()

After adding this, save and close the file, then run the following command in Vim to install the plugins:

vim 
:PlugInstall

3. Plugin Configuration

3.1) YouCompleteMe Setup (Code Completion) YouCompleteMe is a powerful code completion plugin. After installation, it requires compilation.

1. Navigate to the YouCompleteMe directory:

   cd ~/.vim/plugged/YouCompleteMe

2. Compile YouCompleteMe with support for C/C++:

   python3 install.py --clangd-completer

3. Add this line to your .vimrc for enhanced functionality:

   vim
   let g:ycm_auto_hover = 1 " Automatically display code completion popup

3.2) Gutentags Setup (Ctags Management) Gutentags automatically generates and updates Ctags for your project.

Add the following configuration to your .vimrc:

let g:gutentags_project_root = ['.git', '.hg', '.svn', 'Makefile']
let g:gutentags_ctags_auto_settags = 1

Gutentags will automatically manage and update the tags file in your project directories.

3.3) Cscope Setup Cscope allows you to navigate code and find function definitions, callers, text search, etc.

Add the following to your .vimrc to enable Cscope:

if has("cscope")
    set csprg=/usr/bin/cscope
    set csto=1
    set cst
    set nocsverb
    if filereadable("cscope.out")
        cs add cscope.out
    endif
    set csverb
    nmap <C-\>s :cs find s <C-R>=expand("<cword>")<CR><CR>
    nmap <C-\>g :cs find g <C-R>=expand("<cword>")<CR><CR>
    nmap <C-\>c :cs find c <C-R>=expand("<cword>")<CR><CR>
    nmap <C-\>t :cs find t <C-R>=expand("<cword>")<CR><CR>
    nmap <C-\>e :cs find e <C-R>=expand("<cword>")<CR><CR>
    nmap <C-\>f :cs find f <C-R>=expand("<cfile>")<CR><CR>
endif

To generate the Cscope database (cscope.out), run the following in your project root:

cscope -Rbq

3.4) NERDTree Setup (File Explorer) NERDTree provides a side panel for file navigation.

Add this to your .vimrc:

vim
nmap <C-n> :NERDTreeToggle<CR>

Press (Control + n) to toggle the file explorer on and off.

3.5) FZF Setup (Fuzzy Finder) FZF is a fuzzy finder that allows quick file navigation. sangs_o.log Add this to your .vimrc:

vim
nnoremap <C-p> :Files<CR>

Press (Control + p) to open the file finder.

4. Ctags and Cscope Usage in Vim

4.1) Ctags Usage Once Ctags is generated, you can navigate to function definitions in Vim:

Ctrl-]: Jump to the definition of the symbol under the cursor.

Ctrl-t: Jump back to the previous position.

4.2) Cscope Usage You can use Cscope to perform several useful searches:

Ctrl-\ s: Find all references of the symbol under the cursor.

Ctrl-\ g: Find the definition of the symbol under the cursor.

Ctrl-\ c: Find all calls to the function under the cursor.

Ctrl-\ t: Find all occurrences of the text under the cursor.

5. Troubleshooting Common Issues

Error: YouCompleteMe unavailable: requires Vim 9.1.0016+ This occurs when your Vim version is below 9.1. You will need to upgrade Vim to 9.1 or higher.

Upgrading Vim: Remove the old Vim version:

sudo apt remove vim vim-runtime gvim
sudo apt autoremove

Install dependencies:

sudo apt install libncurses5-dev libgtk2.0-dev libatk1.0-dev libbonoboui2-dev \ libcairo2-dev libx11-dev libxpm-dev libxt-dev python3-dev ruby-dev lua5.1 lua5.1-dev \ libperl-dev git build-essential

Clone the Vim repository and build it:

cd ~
git clone https://github.com/vim/vim.git
cd vim
make distclean ./configure --with-features=huge --enable-multibyte --enable-python3interp=yes \ --enable-rubyinterp=yes --enable-luainterp=yes --enable-perlinterp=yes \ --enable-cscope --prefix=/usr/local
make
sudo make install