coc-nasm/snippets/nasm.json

This is the snippets and autocompletions for Netwide Assembler language in coc.nvim

{
  "mov": {
    "prefix": "mov",
    "body": [
      "mov ${1:target}, "
    ],
    "description": "NASM mov instruction:\nmov [target], [source]"
  },
  "dup": {
    "prefix": "dup",
    "body": [
      "dup(${0})"
    ],
    "description": "dup command"
  },
  "sum": {
    "prefix": "sum",
    "body": [
      "section .text",
      "\tglobal sum",
      "sum:",
      "\tmov rax, rdi   ; rax = Return value, rdi = a = argv[1]",
      "\tadd rax, rsi   ; rsi = b = argv[2]",
      "\tret            ; Returns rax = a + b = rdi + rsi"
    ],
    "description": [
      "This is an example of a function in NASM",
      "Note: rax = RETURN, rdi = argv[1], rsi = argv[2], rdx = argv[3], rcx = argv[4],",
      "r8 = argv[5], r9 = argv[6]"
    ]
  },
  "equal to a len of a string": {
    "prefix": "const",
    "body": [
      "equ $-${stringlabelname}"
    ],
    "description": "Calculate a length of a string. Place this thing right after you have defined byte a string value"
  },
  "basic pi (64-bit)": {
    "prefix": "pi64",
    "body": [
      "pi dq 3.14${0}"
    ],
    "description": "Basic pi constant (64-bit)."
  },
  "basic pi (32-bit)": {
    "prefix": "pi32",
    "body": [
      "pi dd 3.14${0}"
    ],
    "description": "Basic pi constant (32-bit)."
  },
  "function": {
    "prefix": "function",
    "body": [
      "${1:functionname}:",
      "\tret"
    ],
    "description": "This is the syntax to establish (set up) a function in nasm."
  },
  "newline": {
    "prefix": "newline",
    "body": [
      "mov rax, 1",
      "mov rdi, 1",
      "mov rsi, 10",
      "mov rdx, 1",
      "syscall"
    ],
    "description": "This is a snippet for printing a newline in nasm"
  },
  "printHello": {
    "prefix": "printHello",
    "body": [
      "%macro exit 1",
      "\tmov rax, 60",
      "\tmov rdi, %1",
      "\tsyscall",
      "%endmacro",
      "",
      "%macro getstr 2",
      "\tmov rax, 1",
      "\tmov rdi, 1",
      "\tmov rsi, %1",
      "\tmov rdx, %2",
      "\tsyscall",
      "%endmacro",
      "",
      "section .data",
      "\texample db 0x1b, \"[1;38;2;255;165;0m\", \"Hello world\", 0x1b, \"[0m\", 0xA",
      "\tlength equ $-example",
      "",
      "section .text",
      "\tglobal _start",
      "",
      "_start:",
      "\tgetstr example, length",
      "\texit 0"
    ],
    "description": "An exaple program of Netwide Assembler language."
  },
  "section": {
    "prefix": "section",
    "body": [
      "section ${1:sectionname}"
    ],
    "description": "Used to change and define sections"
  },
  "segment": {
    "prefix": "segment",
    "body": [
      "segment ${1:segmentname}"
    ],
    "description": "`segment` is an exactly equivalent synonym of section"
  },
  "absolute": {
    "prefix": "absolute",
    "body": [
      "absolute ${1:LABEL}"
    ],
    "description": [
      "This command is used to define absolute labels.",
      "According to https://nasm.us/doc/nasmdoc7.html#section-7.4, this can be thought of as an alternative form of SECTION due to the the causes that the subsequent code to be directed at no physical section.",
      "However, (still according to that website) it causes at the hypothetical section starting at the given absolute address."
    ]
  },
  "cmp": {
    "prefix": "cmp",
    "body": [
      "cmp ${1:value1}, "
    ],
    "description": "Compare 2 values:\nmov [target], [source]"
  },
  "The start of an assembly program": {
    "prefix": "program",
    "body": [
      "section .data",
      "\t${definedata}",
      "${0}",
      "section .text",
      "\tglobal _start",
      "_start:",
      "\t${0}"
    ],
    "description": "Automatically build the basical start of nasm language"
  },
  "exit": {
    "prefix": "exit",
    "body": [
      "mov rax, 60",
      "mov rdi, ${1:exitcode}",
      "syscall"
    ],
    "description": "The code to exit the program with your custom exit code"
  },
  "include \"": {
    "prefix": "include",
    "body": [
      "include \"${1:filepath}\""
    ],
    "description": "Include a Netwide Assembler file (quoted)"
  },
  "include": {
    "prefix": "include",
    "body": [
      "include ${1:filemacro}"
    ],
    "description": "Include a Netwide Assembler file"
  },
  "depend": {
    "prefix": "depend",
    "body": [
      "depend ${1:filemacro}"
    ],
    "description": [
      "Do the Registration of a dependency into a file (like .d file in C)",
      "Help the build compiler like make know that this NASM file depends on other files",
      "Netwide Assembler does not directly act with this file, but some build system can read this information"
    ]
  },
  "depend \"": {
    "prefix": "depend",
    "body": [
      "depend \"${1:filepath}\""
    ],
    "description": [
      "(quoted) Do the Registration of a dependency into a file (like .d file in C)",
      "Help the build compiler like make know that this NASM file depends on other files",
      "Netwide Assembler does not directly act with this file, but some build system can read this information"
    ]
  },
  "use": {
    "prefix": "use",
    "body": [
      "use ${1:smart_macro_feature}"
    ],
    "description": [
      "Activate advanced macro or feature for a particular environment.",
      "Basic syntax:",
      "\tuse smart_macro_feature",
      "Now, we only have some features like:",
      "\tsmartalign: Helps `align` work smarter",
      "\tdwarf: Allows you to generate DWARF debug logs inside ELF",
      "\taltreg: Allows you to alternate register names",
      "See https://www.nasm.us/vdoc/2.16.03/html/nasmdoc6.html (from nasm.us, not my website) for more information about features"
    ]
  },
  "repl": {
    "prefix": "repl",
    "body": [
      "repl ${1:newname}"
    ],
    "description": [
      "Renaming a context",
      "You can replace:",
      "",
      "%pop",
      "%push newname",
      "",
      "with the non-destructive version of:",
      "%repl newname"
    ]
  },
  "pathsearch": {
    "prefix": "pathsearch",
    "body": [
      "pathsearch \"${resultmacro_and_filename}\""
    ],
    "description": [
      "%pathsearch: Search for a file",
      "",
      "Basic syntax:",
      "%pathsearch result \"filename\"",
      "- `result` is a single-line macro (is initialized with %$result)",
      "- `filename` is the file you want to find",
      "",
      "Basic example for main.nasm:",
      "",
      "%pathsearch found_path, \"mymacro.inc\"",
      "%ifdef %$found_path",
      "\t%include %$found_path",
      "%else",
      "\t%error \"Error with mymacro.inc: No such file or directory\"",
      "%endif",
      "",
      "Combine with argument -I to make the compiler find the path by looting in other directories. For instance:",
      "nasm -Iincludes/ -Isrc/ main.nasm"
    ]
  },
  "arg": {
    "prefix": "arg",
    "body": [
      "arg ${1:STRING} ${2:LEN}"
    ],
    "description": [
      "Define arguments in `macro` command, not `%macro` preprocessor"
    ]
  },
  "stacksize": {
    "prefix": "stacksize",
    "body": [
      "stacksize ${1:SIZE}"
    ],
    "description": [
      "Examine how many bytes are used in the macro's stack logic (not the CPU's real stack)"
    ]
  },
  "local": {
    "prefix": "local",
    "body": [
      "local ${1:VARIABLE}"
    ],
    "description": [
      "Define local variables.",
      "Those variables do not exist outside the macro"
    ]
  },
  "pragma": {
    "prefix": "pragma",
    "body": [
      "pragma ${1:NAMESPACE_COMMAND} ${2:VALUE}"
    ],
    "description": [
      "Set a special options for Netwide Assembler or local plugin",
      "Now, we have only one real namespace. It is debug",
      "For instance:",
      "",
      "%pragma debug gdb    ; Turn on the output information according to the standard options of gdb",
      "",
      "Depending on ELF/COFF backend, %pragma may not work"
    ]
  },
  "clear": {
    "prefix": "clear",
    "body": [
      "clear ${1:CONTEXT} ${2:TYPE}"
    ],
    "description": [
      "%clear - Clear and delete all defined single-line macros and multi-line macros, EVERY PREPROCESSOR THINGS.",
      "Attention: This command will delete ALL EXISTED MACROS.",
      "However, you still have options using this command."
    ]
  },
  "clear all preprocessors": {
    "prefix": "clearallpreprocessors",
    "body": [
      "clear global all"
    ],
    "description": "CLEAR ALL THE PREPROCESSORS IN THE FILE"
  },
  "error": {
    "prefix": "error",
    "body": [
      "error \"${MESSAGE}\" "
    ],
    "description": "Send an error if a wrong logic has been detected while compiling"
  },
  "fatal": {
    "prefix": "fatal",
    "body": [
      "fatal \"${MESSAGE}\""
    ],
    "description": "Like error, but stop instantly like panic, which is a very serious error which forces the compiler to stop compiling"
  },
  "warning": {
    "prefix": "warning",
    "body": [
      "error \"${MESSAGE}\""
    ],
    "description": [
      "Send a warning to notice developers that something might happend while running this script.",
      "However, the compiler still carries on compiling the source code."
    ]
  },
  "pop": {
    "prefix": "pop",
    "body": [
      "%pop"
    ],
    "description": [
      "%pop: Recover the previous stack by doing a stack pop"
    ]
  },
  "jge": {
    "prefix": "jge",
    "body": [
      "jge ${1:label}"
    ],
    "description": "Jump to a label if in cmp, the previous label is greater than or equal to the target value"
  },
  "jmp": {
    "prefix": "jmp",
    "body": [
      "jmp ${1:label}"
    ],
    "description": "Jump to a label without any conditions"
  },
  "jne": {
    "prefix": "jne",
    "body": [
      "jne ${1:label}"
    ],
    "description": "Jump to a label if in cmp, the previous label is not equal to the target value"
  },
  "je": {
    "prefix": "je",
    "body": [
      "je ${1:label}"
    ],
    "description": "Jump to a label if in cmp, the previous label is equal to the target value"
  },
  "jle": {
    "prefix": "jle",
    "body": [
      "jle ${1:label}"
    ],
    "description": "Jump to a label if in cmp, the previous label is lower than or equal to the target value"
  },
  "jg": {
    "prefix": "jg",
    "body": [
      "jg ${1:label}"
    ],
    "description": "Jump to a label if in cmp, the previous label is greater than the target value"
  },
  "jl": {
    "prefix": "jl",
    "body": [
      "jl ${1:label}"
    ],
    "description": "Jump to a label if in cmp, the previous label is lower than the target value"
  },
  "call": {
    "prefix": "call",
    "body": [
      "call ${functionname}"
    ],
    "description": "call a function"
  },
  "Basic script for outputing a variable/label": {
    "prefix": "basicoutput",
    "body": [
      "mov rax, 1",
      "mov rdi, 1",
      "mov rsi, ${messagevalue}",
      "mov rdx, ${len}",
      "syscall"
    ],
    "description": "This script shows how to print a label basically"
  },
  "Basic script for inputing a variable/label": {
    "prefix": "basicinput",
    "body": [
      "mov rax, 0",
      "mov rdi, 0",
      "mov rsi, ${buffervariable}   ; ",
      "mov rdx, 30",
      "syscall"
    ],
    "description": "This script shows how to make a user input by reading the sidin.\nYou must make an uninitialized memory using section .bss and resb first"
  },
  "enter": {
    "prefix": "enter",
    "body": [
      "enter ${1:imm16} ${2:imm8}",
      "",
      "leave"
    ],
    "description": [
      "This command establishes a stack frame",
      "",
      "Basic syntax:",
      "\tenter imm16, imm8",
      "\tleave",
      "",
      "`enter` configures the stack frame, with:",
      "\t imm16 is bytes need providing for the local variable",
      "\t imm8 is the nesting level (rarely used, the default is 0)",
      "For example:",
      "",
      "enter 32, 0    ; Is equal to `push rbp`",
      "mov rbp, rsp",
      "sub rsp, 32    ; Provide 32 bytes for the local variable",
      "leave          ; We will tell you about this command right later",
      "",
      "`leave` cleans the stack frame. In the above script, it is equal to:",
      "\tmov rsp, rbp",
      "\tpop rbp"
    ]
  },
  "%push preprocessor": {
    "prefix": "push",
    "body": [
      "push ${CONTENT}",
      "\t${0}",
      "%pop"
    ],
    "description": "Push preprocessor: Push data into a temporatory to save until meeting %pop"
  },
  "if preprocessor": {
    "prefix": "if",
    "body": [
      "if ${condition}",
      "\t${0}",
      "%endif"
    ],
    "description": "If stalement for preprocessor"
  },
  "ifnot preprocessor": {
    "prefix": "ifn",
    "body": [
      "ifn ${condition}",
      "\t${0}",
      "%endif"
    ],
    "description": "If stalement for preprocessor"
  },
  "ifdef": {
    "prefix": "ifdef",
    "body": [
      "ifdef ${1:SYMBOL}",
      "\t$0",
      "%endif"
    ],
    "description": "If symbol is defined"
  },
  "ifndef": {
    "prefix": "ifndef",
    "body": [
      "ifndef ${1:SYMBOL}",
      "\t$0",
      "%endif"
    ],
    "description": "If symbol is not defined"
  },
  "ifmacro": {
    "prefix": "ifmacro",
    "body": [
      "ifmacro ${1:MACRO}",
      "\t$0",
      "%endif"
    ],
    "description": "If macro is defined"
  },
  "ifnmacro": {
    "prefix": "ifnmacro",
    "body": [
      "ifnmacro ${1:MACRO}",
      "\t$0",
      "%endif"
    ],
    "description": "If macro is not defined"
  },
  "ifctx": {
    "prefix": "ifctx",
    "body": [
      "ifctx ${1:CONTEXT}",
      "\t$0",
      "%endif"
    ],
    "description": "If current context is matched"
  },
  "ifnctx": {
    "prefix": "ifnctx",
    "body": [
      "ifnctx ${1:CONTEXT}",
      "\t$0",
      "%endif"
    ],
    "description": "If current context is NOT matched"
  },
  "ifidn": {
    "prefix": "ifidn",
    "body": [
      "ifidn ${1:str1}, ${2:str2}",
      "\t$0",
      "%endif"
    ],
    "description": "If strings are identical (case-sensitive)"
  },
  "ifidni": {
    "prefix": "ifidni",
    "body": [
      "ifidni ${1:str1}, ${2:str2}",
      "\t$0",
      "%endif"
    ],
    "description": "If strings are identical (case-insensitive)"
  },
  "ifstr": {
    "prefix": "ifstr",
    "body": [
      "ifstr ${1:SYMBOL}",
      "\t$0",
      "%endif"
    ],
    "description": "If symbol is a string"
  },
  "ifnstr": {
    "prefix": "ifnstr",
    "body": [
      "ifnstr ${1:SYMBOL}",
      "\t$0",
      "%endif"
    ],
    "description": "If symbol is NOT a string"
  },
  "ifnum": {
    "prefix": "ifnum",
    "body": [
      "ifnum ${1:SYMBOL}",
      "\t$0",
      "%endif"
    ],
    "description": "If symbol is numeric"
  },
  "ifnnum": {
    "prefix": "ifnnum",
    "body": [
      "ifnnum ${1:SYMBOL}",
      "\t$0",
      "%endif"
    ],
    "description": "If symbol is NOT numeric"
  },
  "iftoken": {
    "prefix": "iftoken",
    "body": [
      "iftoken ${1:SYMBOL}",
      "\t$0",
      "%endif"
    ],
    "description": "If symbol is a single token"
  },
  "ifntoken": {
    "prefix": "ifntoken",
    "body": [
      "ifntoken ${1:SYMBOL}",
      "\t$0",
      "%endif"
    ],
    "description": "If symbol is NOT a single token"
  },
  "ifid": {
    "prefix": "ifid",
    "body": [
      "ifid ${1:SYMBOL}",
      "\t$0",
      "%endif"
    ],
    "description": "If symbol is an identifier"
  },
  "ifnid": {
    "prefix": "ifnid",
    "body": [
      "ifnid ${1:SYMBOL}",
      "\t$0",
      "%endif"
    ],
    "description": "If symbol is NOT an identifier"
  },
  "ifempty": {
    "prefix": "ifempty",
    "body": [
      "ifempty ${1:SYMBOL}",
      "\t$0",
      "%endif"
    ],
    "description": "If symbol is empty"
  },
  "ifnempty": {
    "prefix": "ifnempty",
    "body": [
      "ifnempty ${1:SYMBOL}",
      "\t$0",
      "%endif"
    ],
    "description": "If symbol is NOT empty"
  },
  "ifenv": {
    "prefix": "ifenv",
    "body": [
      "ifenv ${1:VAR}",
      "\t$0",
      "%endif"
    ],
    "description": "If environment variable exists"
  },
  "ifnenv": {
    "prefix": "ifnenv",
    "body": [
      "ifnenv ${1:VAR}",
      "\t$0",
      "%endif"
    ],
    "description": "If environment variable does NOT exist"
  },
  "elif": {
    "prefix": "elif",
    "body": [
      "elif ${1:condition}",
      "\t$0"
    ],
    "description": "Else-if preprocessor"
  },
  "elifn": {
    "prefix": "elifn",
    "body": [
      "elifn ${1:condition}",
      "\t$0"
    ],
    "description": "Else-if preprocessor"
  },
  "elifdef": {
    "prefix": "elifdef",
    "body": [
      "elifdef ${1:SYMBOL}",
      "\t$0"
    ],
    "description": "Else-if symbol is defined"
  },
  "elifndef": {
    "prefix": "elifndef",
    "body": [
      "elifndef ${1:SYMBOL}",
      "\t$0"
    ],
    "description": "Else-if symbol is NOT defined"
  },
  "elifmacro": {
    "prefix": "elifmacro",
    "body": [
      "elifmacro ${1:MACRO}",
      "\t$0"
    ],
    "description": "Else-if macro is defined"
  },
  "elifnmacro": {
    "prefix": "elifnmacro",
    "body": [
      "elifnmacro ${1:MACRO}",
      "\t$0"
    ],
    "description": "Else-if macro is NOT defined"
  },
  "elifctx": {
    "prefix": "elifctx",
    "body": [
      "elifctx ${1:CONTEXT}",
      "\t$0"
    ],
    "description": "Else-if context matched"
  },
  "elifnctx": {
    "prefix": "elifnctx",
    "body": [
      "elifnctx ${1:CONTEXT}",
      "\t$0"
    ],
    "description": "Else-if context NOT matched"
  },
  "elifidn": {
    "prefix": "elifidn",
    "body": [
      "elifidn ${1:str1}, ${2:str2}",
      "\t$0"
    ],
    "description": "Else-if strings equal (case-sensitive)"
  },
  "elifidni": {
    "prefix": "elifidni",
    "body": [
      "elifidni ${1:str1}, ${2:str2}",
      "\t$0"
    ],
    "description": "Else-if strings equal (case-insensitive)"
  },
  "elifstr": {
    "prefix": "elifstr",
    "body": [
      "elifstr ${1:SYMBOL}",
      "\t$0"
    ],
    "description": "Else-if symbol is string"
  },
  "elifnstr": {
    "prefix": "elifnstr",
    "body": [
      "elifnstr ${1:SYMBOL}",
      "\t$0"
    ],
    "description": "Else-if symbol is NOT string"
  },
  "elifnum": {
    "prefix": "elifnum",
    "body": [
      "elifnum ${1:SYMBOL}",
      "\t$0"
    ],
    "description": "Else-if symbol is numeric"
  },
  "elifnnum": {
    "prefix": "elifnnum",
    "body": [
      "elifnnum ${1:SYMBOL}",
      "\t$0"
    ],
    "description": "Else-if symbol is NOT numeric"
  },
  "eliftoken": {
    "prefix": "eliftoken",
    "body": [
      "eliftoken ${1:SYMBOL}",
      "\t$0"
    ],
    "description": "Else-if symbol is token"
  },
  "elifntoken": {
    "prefix": "elifntoken",
    "body": [
      "elifntoken ${1:SYMBOL}",
      "\t$0"
    ],
    "description": "Else-if symbol is NOT token"
  },
  "elifid": {
    "prefix": "elifid",
    "body": [
      "elifid ${1:SYMBOL}",
      "\t$0"
    ],
    "description": "Else-if symbol is identifier"
  },
  "elifnid": {
    "prefix": "elifnid",
    "body": [
      "elifnid ${1:SYMBOL}",
      "\t$0"
    ],
    "description": "Else-if symbol is NOT identifier"
  },
  "elifempty": {
    "prefix": "elifempty",
    "body": [
      "elifempty ${1:SYMBOL}",
      "\t$0"
    ],
    "description": "Else-if symbol is empty"
  },
  "elifnempty": {
    "prefix": "elifnempty",
    "body": [
      "elifnempty ${1:SYMBOL}",
      "\t$0"
    ],
    "description": "Else-if symbol is NOT empty"
  },
  "elifenv": {
    "prefix": "elifenv",
    "body": [
      "elifenv ${1:VAR}",
      "\t$0"
    ],
    "description": "Else-if environment var exists"
  },
  "elifnenv": {
    "prefix": "elifnenv",
    "body": [
      "elifnenv ${1:VAR}",
      "\t$0"
    ],
    "description": "Else-if environment var does NOT exist"
  },
  "else": {
    "prefix": "else",
    "body": [
      "else",
      "\t$0"
    ],
    "description": "To execute if all stalements are not met."
  },
  "endif": {
    "prefix": "endif",
    "body": [
      "endif",
      "\t$0"
    ],
    "description": "End the current if* stalement"
  },
  "define": {
    "prefix": "define",
    "body": [
      "define ${1:NAME} ${2:VALUE}"
    ],
    "description": "NASM %define macro in order to define a single-line macro"
  },
  "undef": {
    "prefix": "undef",
    "body": [
      "undef ${1:NAME}"
    ],
    "description": "NASM %undef macro in order to undef a single-line macro"
  },
  "struc": {
    "prefix": "struc",
    "body": [
      "struc ${1:STRUCTNAME}",
      "\t${0}",
      "endstruc"
    ],
    "description": "NASM struc to create a structure of data.\nIndex using [SAVEDSTRUCTADDRESS + STRUCTNAME.structvariable].\nSave the struct using: mov register, istruc_value"
  },
  "istruc": {
    "prefix": "istruc",
    "body": [
      "istruc ${1:STRUCTNAME}",
      "\tat${0}",
      "iend"
    ],
    "description": [
      "NASM istruc to define a particular struct from an uninitialized struc.",
      "Define example:",
      "",
      "struc Point",
      "\t.x resq 1    ; 8 bytes = 64 bits (resd for 32-bit; resw for 16-bit, resb for 8-bit, rest for 80-bits)",
      "\t.y resq 2",
      "\t; Point_size = 8 bytes/1 element * 2 elements = 16 bytes",
      "\t; Point.x = 0",
      "\t; Point.y = 8",
      "endstruc",
      "",
      "section .data",
      "p1:",
      "\tistruc Point",
      "\t\tat Point.x, dq 123",
      "\t\tat Point.y, dq 456",
      "\tiend",
      "",
      "section .text",
      "\tglobal _start",
      "_start:",
      "\tmov rsi, p1  ; Save the struct into rsi register",
      "\tmov rax, [rsi + Point.x] ; Index x, now RAX = 123",
      "\tmov rbx, [rsi + Point.y] ; Index y, now RBX = 456",
      "\t; Replace 'rsi' using the struct 'p1' if you have not saved that struct into rsi register yet."
    ]
  },
  "assign": {
    "prefix": "assign",
    "body": [
      "assign ${1:NAME} ${2:VALUE}"
    ],
    "description": "NASM %assign macro"
  },
  "macro": {
    "prefix": "macro",
    "body": [
      "macro ${1:NAME} ${2:ARGS}",
      "\t$0",
      "%endmacro"
    ],
    "description": "NASM macro block in order to define a multi-line macro"
  },
  "imacro": {
    "prefix": "imacro",
    "body": [
      "imacro ${1:NAME} ${2:ARGS}",
      "\t$0",
      "%endmacro"
    ],
    "description": "NASM imacro block in order to define a multi-line macro"
  },
  "rep": {
    "prefix": "rep",
    "body": [
      "rep ${1:COUNT}",
      "\t$0",
      "%endrep"
    ],
    "description": "NASM repetition block"
  },
  "exitrep": {
    "prefix": "exitrep",
    "body": [
      "exitrep"
    ],
    "description": "Exit the rep loop."
  },
  "endrep": {
    "prefix": "endrep",
    "body": [
      "endrep"
    ],
    "description": "End the rep loop."
  },
  "xdefine": {
    "prefix": "xdefine",
    "body": [
      "xdefine ${1:NAME} ${2:VALUE}"
    ],
    "description": "NASM %xdefine (lazy macro)"
  },
  "idefine": {
    "prefix": "idefine",
    "body": [
      "idefine ${1:NAME} ${2:VALUE}"
    ],
    "description": "NASM %idefine (case-insensitive macro)"
  },
  "defstr": {
    "prefix": "defstr",
    "body": [
      "defstr ${1:NAME} ${2:\"string\"}"
    ],
    "description": "NASM %defstr (define from quoted string)"
  },
  "deftok": {
    "prefix": "deftok",
    "body": [
      "deftok ${1:NAME} ${2:TOKEN}"
    ],
    "description": "NASM %deftok (define from token)"
  },
  "defalias": {
    "prefix": "defalias",
    "body": [
      "defalias ${1:NEWNAME} ${2:EXISTING}"
    ],
    "description": "NASM %defalias (alias for macro name)"
  },
  "undefstr": {
    "prefix": "undefstr",
    "body": [
      "undefstr ${1:NAME}"
    ],
    "description": "NASM %undefstr (remove string macro)"
  },
  "undeftok": {
    "prefix": "undeftok",
    "body": [
      "undeftok ${1:NAME}"
    ],
    "description": "NASM %undeftok (remove token macro)"
  },
  "undefalias": {
    "prefix": "undefalias",
    "body": [
      "undefalias ${1:NAME}"
    ],
    "description": "NASM %undefalias (remove alias)"
  },
  "unmacro": {
    "prefix": "unmacro",
    "body": [
      "unmacro ${1:NAME} ${2:ARGS}"
    ],
    "description": "NASM unmacro a multi-line macro with target undef arguments in that thing"
  },
  "strcat": {
    "prefix": "strcat",
    "body": [
      "strcat ${1:DEST}, ${2:STR1}, ${3:STR2}"
    ],
    "description": "NASM %strcat (concatenate strings)"
  },
  "strlen": {
    "prefix": "strlen",
    "body": [
      "strlen ${1:DEST} ${2:STR}"
    ],
    "description": "NASM %strlen (length of string)"
  },
  "substr": {
    "prefix": "substr",
    "body": [
      "substr ${1:DEST} ${2:STRV} ${3:REALSTR} ${4:NUMARGS}"
    ],
    "description": "NASM %substr in order to extract strings"
  },
  "absolute value": {
    "prefix": "abs",
    "body": [
      "abs(${0})"
    ],
    "description": "NASM %abs for calculating the absolute value of a number"
  },
  "cond": {
    "prefix": "cond",
    "body": [
      "cond(${0})"
    ],
    "description": "NASM %cond to expand a value into the second argument if true (nonzero), or the third one (if false)"
  },
  "count": {
    "prefix": "count",
    "body": [
      "count(${0})"
    ],
    "description": "NASM %count to return the number that is a len passed to a macro"
  },
  "eval": {
    "prefix": "eval",
    "body": [
      "eval(${0})"
    ],
    "description": "NASM %eval command to calculate the result of an integer expression"
  },
  "hexdecimal convert function": {
    "prefix": "hex",
    "body": [
      "hex(${1:EXPRESSION})"
    ],
    "description": "NASM %hex: Compute the expression and return a hexdecimal number to the single-line macro as 0xXX"
  },
  "num": {
    "prefix": "num",
    "body": [
      "num(${1:EXPRESSION})"
    ],
    "description": "NASM %num: Force a value to be an unsigned 64-bit integer"
  },
  "str": {
    "prefix": "str",
    "body": [
      "str(${1:EXPRESSION})"
    ],
    "description": "NASM %str: Force a value to be a defined string"
  },
  "tok": {
    "prefix": "tok",
    "body": [
      "tok(${1:EXPRESSION})"
    ],
    "description": "NASM %tok: Force a value to be a defined token (characters, numbers, symbols,...like a string)"
  },
  "sel": {
    "prefix": "sel",
    "body": [
      "sel ${1:SINGLE-LINE_MACRO, LIST_OF_VALUES}"
    ],
    "description": [
      "NASM %sel: Choose an indexed value using number, the first value has the number is 0",
      "Syntax: %sel [index_number], [a], [b], [c], ...  ; Returns the i^(th) number",
      "Basic example:",
      "%define first %sel 0, foo, bar, baz",
      "%define second %sel 1, foo, bar, baz",
      "After the preprocessor, it is like:",
      "%define first foo",
      "%define second bar",
      "Attention: %sel is a static action in the preprocessor, it does not work with runtime values, only works with text substitution"
    ]
  },
  "map": {
    "prefix": "map",
    "body": [
      "map ${1:MAPMACRO, MAPVALUES}"
    ],
    "description": [
      "NASM %map: Map all values into a group for the repitition and more uses",
      "Syntax: %map [macro], [list_of_values]",
      "Basic example:",
      "%macro make_label 1",
      "\tlabel_%1:",
      "%endmacro",
      "",
      "%map make_label, foo, bar, baz",
      "",
      "After the preprocessor, it will be:",
      "label_foo:",
      "label_bar:",
      "label_baz:",
      "Attention: %map only works with one-argument multi-line macro"
    ]
  },
  "map with parenthesises": {
    "prefix": "map(",
    "body": [
      "map(${1:MAPMACRO, MAPVALUES})"
    ],
    "description": [
      "NASM %map: The '()' macro of %map"
    ]
  },
  "sel with parenthesises": {
    "prefix": "sel(",
    "body": [
      "sel(${1:SINGLE-LINE_MACRO, LIST_OF_VALUES})"
    ],
    "description": [
      "NASM %sel: The '()' macro of %sel"
    ]
  },
  "strcat function with parenthesises": {
    "prefix": "strcat(",
    "body": [
      "strcat(${0})"
    ],
    "description": "NASM %strcat (concatenate strings)"
  },
  "strlen function with parenthesises": {
    "prefix": "strlen(",
    "body": [
      "strlen(${1:STRING_VALUE})"
    ],
    "description": "NASM %strlen to calculate the length of a string"
  },
  "substr function with parenthesises": {
    "prefix": "substr(",
    "body": [
      "substr(${SINGLE-LINE_MACRO, TARGET_STRING, STRING_ELEMENT_NUMBER, NUMBER_OF_EXTRACTED_STRINGS})"
    ],
    "description": "NASM %substr to extract strings. By default, NUMBER_OF_EXTRACTED_STRINGS = 1"
  },
  "rotate": {
    "prefix": "rotate",
    "body": [
      "rotate ${1:N}"
    ],
    "description": [
      "NASM %rotate: Rotate an element number list of a macro N times",
      "If N > 0, turns left. Otherwise, turn right if N != 0",
      "",
      "Imagine you have a macro like this:",
      "custom A, B, C, D    ; %1 = A, %2 = B, %3 = C, %4 = D",
      "and you use this command inside the macro:",
      "%rotate 1",
      "Now, the macro after being rotated is:",
      "custom B, C, D, A",
      "and parameters' numbers are:",
      "%1 = B, %2 = C, %3 = D, %4 = A",
      "",
      "Basic example (You can use %rep for faster, but I do this to make you understand the meaning of %rotate):",
      "",
      "%macro myargs 5",
      "\t; Print 5 times, each printing time rotates",
      "\t; For example: If myargs A, B, C, D, E with A = %1",
      "\tdb `%1`, 10",
      "\trotate 1       ; Now B = %1",
      "\tdb `%1`, 10",
      "\trotate 1       ; Now C = %1",
      "\tdb `%1`, 10",
      "\trotate 1       ; Now D = %1",
      "\tdb `%1`, 10",
      "\trotate 1       ; Now E = %1",
      "\tdb `%1`, 10",
      "%endmacro",
      "",
      "myargs \"A\", \"B\", \"C\", \"D\", \"E\"",
      "",
      "The output is:",
      "",
      "db \"A\", 10",
      "db \"B\", 10",
      "db \"C\", 10",
      "db \"D\", 10",
      "db \"E\", 10",
      "",
      "I recommend you to combine this with %rep for the loops"
    ]
  },
  "__?USE_PACKAGE?__": {
    "prefix": "__?USE_package?__",
    "body": [
      "__?USE_${1:PACKAGE}?__"
    ],
    "description": "Testing if a particular package is invoked or not"
  },
  "__?float8?__": {
    "prefix": "__?float8?__",
    "body": [
      "__?float8?__(${1:x})"
    ],
    "description": "NASM macro for 8-bit floating-point literal"
  },
  "__?float16?__": {
    "prefix": "__?float16?__",
    "body": [
      "__?float16?__(${1:x})"
    ],
    "description": "NASM macro for 16-bit floating-point literal"
  },
  "__?bfloat16?__": {
    "prefix": "__?bfloat16?__",
    "body": [
      "__?bfloat16?__(${1:x})"
    ],
    "description": "NASM macro for bfloat16 floating-point literal"
  },
  "__?float32?__": {
    "prefix": "__?float32?__",
    "body": [
      "__?float32?__(${1:x})"
    ],
    "description": "NASM macro for 32-bit floating-point literal"
  },
  "__?float64?__": {
    "prefix": "__?float64?__",
    "body": [
      "__?float64?__(${1:x})"
    ],
    "description": "NASM macro for 64-bit floating-point literal"
  },
  "__?float80m?__": {
    "prefix": "__?float80m?__",
    "body": [
      "__?float80m?__(${1:x})"
    ],
    "description": "NASM macro for 80-bit (memory format) floating-point literal"
  },
  "__?float80e?__": {
    "prefix": "__?float80e?__",
    "body": [
      "__?float80e?__(${1:x})"
    ],
    "description": "NASM macro for 80-bit (extended format) floating-point literal"
  },
  "__?float128l?__": {
    "prefix": "__?float128l?__",
    "body": [
      "__?float128l?__(${1:x})"
    ],
    "description": "NASM macro for 128-bit (low precision) floating-point literal"
  },
  "__?float128h?__": {
    "prefix": "__?float128h?__",
    "body": [
      "__?float128h?__(${1:x})"
    ],
    "description": "NASM macro for 128-bit (high precision) floating-point literal"
  },
  "float8": {
    "prefix": "float8",
    "body": [
      "float8(${1:x})"
    ],
    "description": [
      "Require fp package used",
      "NASM macro for 8-bit floating-point literal"
    ]
  },
  "float16": {
    "prefix": "float16",
    "body": [
      "float16(${1:x})"
    ],
    "description": [
      "Require fp package used",
      "NASM macro for 16-bit floating-point literal"
    ]
  },
  "bfloat16": {
    "prefix": "bfloat16",
    "body": [
      "bfloat16(${1:x})"
    ],
    "description": [
      "Require fp package used",
      "NASM macro for bfloat16 floating-point literal"
    ]
  },
  "float32": {
    "prefix": "float32",
    "body": [
      "float32(${1:x})"
    ],
    "description": [
      "Require fp package used",
      "NASM macro for 32-bit floating-point literal"
    ]
  },
  "float64": {
    "prefix": "float64",
    "body": [
      "float64(${1:x})"
    ],
    "description": [
      "Require fp package used",
      "NASM macro for 64-bit floating-point literal"
    ]
  },
  "float80m": {
    "prefix": "float80m",
    "body": [
      "float80m(${1:x})"
    ],
    "description": [
      "Require fp package used",
      "NASM macro for 80-bit (memory format) floating-point literal"
    ]
  },
  "float80e": {
    "prefix": "float80e",
    "body": [
      "float80e(${1:x})"
    ],
    "description": [
      "Require fp package used",
      "NASM macro for 80-bit (extended format) floating-point literal"
    ]
  },
  "float128l": {
    "prefix": "float128l",
    "body": [
      "float128l(${1:x})"
    ],
    "description": [
      "Require fp package used",
      "NASM macro for 128-bit (low precision) floating-point literal"
    ]
  },
  "float128h": {
    "prefix": "float128h",
    "body": [
      "float128h(${1:x})"
    ],
    "description": [
      "Require fp package used",
      "NASM macro for 128-bit (high precision) floating-point literal"
    ]
  },
  "cpu_dependencies": {
    "prefix": "cpu",
    "body": [
      "cpu ${1:cpu_keyword}"
    ],
    "description": [
      "Defining CPU dependencies.",
      "According to The Netwide Assembler HTML Document:",
      "Current CPU keywords are:",
      "\tCPU 8086 – Assemble only 8086 instruction set",
      "\tCPU 186 – Assemble instructions up to the 80186 instruction set",
      "\tCPU 286 – Assemble instructions up to the 286 instruction set",
      "\tCPU 386 – Assemble instructions up to the 386 instruction set",
      "\tCPU 486 – 486 instruction set",
      "\tCPU 586 – Pentium instruction set",
      "\tCPU PENTIUM – Same as 586",
      "\tCPU 686 – P6 instruction set",
      "\tCPU PPRO – Same as 686",
      "\tCPU P2 – Same as 686",
      "\tCPU P3 – Pentium III (Katmai) instruction sets",
      "\tCPU KATMAI – Same as P3",
      "\tCPU P4 – Pentium 4 (Willamette) instruction set",
      "\tCPU WILLAMETTE – Same as P4",
      "\tCPU PRESCOTT – Prescott instruction set",
      "\tCPU X64 – x86-64 (x64/AMD64/Intel 64) instruction set",
      "\tCPU IA64 – IA64 CPU (in x86 mode) instruction set",
      "\tCPU DEFAULT – All available instructions",
      "\tCPU ALL – All available instructions and flags",
      "All options are case insensitive.",
      "For AVX and AVX-512, currently available flags are:",
      "\tEVEX – Enable generation of EVEX (AVX-512) encoded instructions without an explicit {evex} prefix. Default on.",
      "\tVEX – Enable generation of VEX (AVX) or XOP encoded instructions without an explict {vex} prefix. Default on.",
      "\tLATEVEX – Enable generation of VEX (AVX) encoding of instructions where the VEX instructions forms were introduced after the corresponding EVEX (AVX-512) instruction forms without requiring an explicit {vex} prefix. \nThis is implicit if the EVEX flag is disabled and the VEX flag is enabled. Default off."
    ]
  },
  "float": {
    "prefix": "float",
    "body": [
      "float ${1:floatingpoint_constant}"
    ],
    "description": "Handling of floating-point constants"
  },
  "[warning]": {
    "prefix": "[warning]",
    "body": [
      "[warning ${1:WARNING_DIRECTIVE}]"
    ],
    "description": [
      "Enable or disable warnibgs"
    ]
  }
}