Systems Software consists of a set of programs that support. The operation of a computer system and help, the programmer, to simplify the programming process and run application software efficiently.
- A Translator is a system program that converts a program in one language to a program in another language.
- A Translator can be denoted by following symbol:
Where S = Source Language
T = Target Language
B = Base Language in which the translator is written
- Assembler is a language translator which takes as input a program in assembly language of machine A and generates its equivalent machine code for machine A, and the assembler itself is written in assembly language of Machine A.
- A Cross-Assembler runs on one machine, but assembles ALP of another machine and generates machine code for that machine.
- Imagine an ALP program (the actual assembler) running on a Windows machine. It takes as input some 8086 ALP program and generates its machine code for 8086 machine. But the main assembler still runs on Windows machine, even though source and target languages are of a backward processor 8086. (Example: TASM programs running.
- As the name suggests, it converts machine code of a particular machine back to its assembly language. (Recall: reverse engineering).
- This idea of reverse engineering is used to recover some lost source code file using its object file.
- A Compiler is a language translator that takes as input a source program in some HLL and converts it into a lower-level language (i.e. machine or assembly language).
- So, an HLL program is first compiled to generate an object file with machine-level instructions (i.e. compile time) and then instructions in object file are executed (i.e. run time).
- A Cross-Compiler runs on one machine, but generates machine or assembly code for another machine.
- Similar to Disassembler for Assembly Language, a Decompiler traces back the machine or assembly code and converts it into source HLL program.
- This reverse conversion is strictly dependent on how much information about source HLL is present in the machine code (or assembly code).
- An Interpreter is similar to a compiler, but one big difference is that it executes each line of source code as soon as its equivalent machine code is generated. (This approach is different from a compiler, which compiles the entire source code into an object file that is executed separately).
- If there are any errors during interpretation, they are notified immediately to the programmer and remaining source code lines are not processed.
- In case of a Compiler, all errors occurred during compile-time are notified collectively to the programmer; the programmer then corrects the errors and re-compiles and executes the code.
- The main advantage with Interpreters is that, since it immediately notifies an error to the programmer, debugging becomes a lot easier.
- A Pre-processor converts one HLL into another HLL.
- Typically pre-processors are seen as system software used to perform some additional functions (such as removal of white spaces and comments) before the actual translation process can begin.
- So, input and output of pre-processor is generally the same HLL, only some additional functions have been performed on the source.
- A Macro Processor is an example of pre-processor.
- A Macro is defined as a single-line abbreviation of a small sequence of statements.
- A Macro Processor expands the macro calls and removes macro definitions from an as input source code, which contains these macro definitions and calls.
- Macros are used similar to functions, but they are much smaller (and less complex) than functions.
- A Linker (or a Linkage Editor) takes the object file, loads and compiles the external sub-routines from the library and resolves their external references in the main-program.
- A Compiler generates an object file after compiling the source code. But this object file cannot be executed immediately after it gets generated.
- This is because the main program may use separate subroutines in its code (locally defined in the program or available globally as language subroutines). The external sub-routines have not been compiled with the main program and therefore their addresses are not known in the program.
- Programmers usually define the program to be placed at some pre-defined location in the memory. But this loading address given by the programmer may never be used, as it has not been coordinated with the OS.
- A Loader does the job of coordinating with the OS to get the initial loading address for the program, prepares the program for execution (i.e. generates an .exe file) and loads it at that address.
- Also, during the course of its execution, a program may be relocated to a different area of main memory by the OS (when memory is needed for other programs). This may render address-sensitive instructions useless (For example, load / store from a specific address in the memory).
- An important job of Loader is to modify these address-sensitive instructions, so that they run correctly after relocation.