Hello World! in Assembly, C, C++, Java, LISP, Pascal, VHDL

Wew, Hello World! in many programming languages.

Assembly

MIPS Assembly- RISC Processor

       .data
msg:     .asciiz "Hello, world!"
         .align 2
         .text
         .globl main
main:
         la $a0,msg
         li $v0,4
         syscall
         jr $ra

Intel x86,DOS, TASM

MODEL SMALL
IDEAL
STACK 100H

DATASEG
MSG DB 'Hello, World!', 13, '$'

CODESEG
Start:
MOV AX, @data
MOV DS, AX
MOV DX, OFFSET MSG
MOV AH, 09H ; output ascii string
INT 21H
MOV AX, 4C00H
INT 21H
END Start

C

#include <stdio.h>
int main(void){
	printf("Hello, world!\n");
	return 0;
}

C++

#include <iostream>

int main(){
	std::cout << "Hello, World!\n";
}

Java

public class HelloWorld
   {
        public static void main(String[] args)
        {
             System.out.println("Hello, world!");
        }
   }

LISP

(format t "Hello World!~%")
(write-line "Hello World!")
 "Hello World!"

VHDL

use std.textio.all;

ENTITY hello IS
END ENTITY hello;

ARCHITECTURE Scriptol OF hello IS
 CONSTANT message : string := "hello world";
BEGIN
 PROCESS
 variable L: line;
 BEGIN
 write(L, message);
 writeline(output, L);
 wait;
 END PROCESS;
END ARCHITECTURE Scriptol;

source: http://www.mycplus.com/featured-articles/hello-world-programs-in-300-programming-languages/

Assembler: Membuat Insertion Sort+Minimum Sort

Ini bakal panjang dan membosankan, sumpah. Jika tidak tertarik atau berkepentingan saya harap tidak memaksakan diri membacanya.

Program ini mempunyai kemampuan mengurutkan masukan baik berupa integer, real maupun karakter. Proses pengurutan dapat dilakukan dengan insertion sort maupun minimum sort.

#########################################################################
# author    :     Kuncoro Dwi Atmojo     nama program:             >>> SuperSorter <<<                                                   #
##########################################################################
#>>>>>>>>>>>>>>>>               main program                    <<<<<<<<<<<<<<<<<<<<<<<<#
#>>>>                  program meminta masukan N bilangan/karakter                 <<<<<#
#>>>>>>>>             program mengurutkan bilangan/karakter                      <<<<<<<#
#>>>>>>>>>>             tersebut dengan insertion sort/minimum sort         <<<<<<<<<<<<#

############# penggunaan register #######################################################
#$s1    :nilai N, jumlah input                                                            #
#$s0    :counter untuk pengisian N bilangan/karakter                                    #
#$s2    :pilihan integer, pecahan atau karakter                                            #
#$s3    :counter untuk menampilkan isi array yang terurut                                #
#$t1    :index untuk menggeser nilai yang lebih besar dari masukan baru                    #
#$t3    :index dari masukan baru, selalu bertambah setiap ada masukan                    #
#$t4    :nilai masukan pengguna                                                            #
#$t5    :index dari nilai yang dibandingkan dengan masukkan baru                        #
#$t6    :nilai dalam array yang akan dibandingkan, nilai dari array dengan indeks $t5    #
#$t7    :index array yang akan ditampilkan                                                #
#$t8    :temp karakter yang akan diprint                                                #
#$f2    :masukan baru berupa pecahan                                                    #
#$f4    :pecahan yang akan dibandingkan dengan masukan baru                                #
###############     kamus     ###########################################################
.data
arrint: .word 0:300
arrfloat: .space 2048
arrchar: .space 1024
##############   algoritma   #################
.text
.globl main
main:                                            # main program
jal inisial                                    # menanyakan jenis masukkan, metode sorting yang dipakai, jumlah N
beq $t0,98, main_minsort                    # jika memilih metode minimum sort (b), selanjutnya ke main_minsort

main_insort:                                # main untuk insertion sort
li $s0, 1
li $t3, 0                                # index masukan, jika char maka t3 +1, int maka t3+4, double maka t3+8
muter:
jal input                        # minta masukan
jal insort                        # langsung mengurutkan setiap masukan
addi $s0,1
ble $s0, $s1, muter                # terus minta masukan hingga s0 sama dengan N
jal tampilkan                            # menampilkan hasilnya ke layar
j keluar                                # keluar program

main_minsort:                                 # main untuk minimum sort
li $s0, 1
li $t3, 0                                # index masukan, jika char maka t3 +1, int maka t3+4, double maka t3+8
jal input_minsort                    # meminta masukan, memasukkan ke dalam array tanpa mengurutkannya
addi $s0,1
ble $s0, $s1, input_minsort            # terus minta masukan hingga s0 sama dengan N
jal minsort                            # mengurutkan isi array dengan metode minimum sort
jal tampilkan                            # menampilkan hasil urutan ke layar
j keluar                                # keluar dari program
#>>>>>> end of main program <<<<<<#

#>>>>>> inisial <<<<<<<<<#
.data
str0: .asciiz “   ~~~ program mengurutkan N masukan ~~~\n   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n”
str1: .asciiz “\n N:”
str7: .asciiz “anda ingin memasukkan integer, pecahan atau karakter(i/p/k)? “
str8: .asciiz “\n pilih metode pengurutan:\n a. insertion sort\n b. minimum sort\n”
str9: .asciiz “(a/b)?”
pilihan: .space 8
.text
inisial:
la $a0, str0                        # menampilkan tulisan
li $v0, 4                            # ‘~~~ program mengurutkan…’
syscall

pilihinput:                            # >>>> memilih jenis input <<<<
la $a0, str7                    # menampilkan tulisan
li $v0,4                        # ‘anda ingin memasukkan integer…’
syscall

li $v0,8                        # meminta masukan
la $a0,pilihan                    # menyimpannya di ‘pilihan’
li $a1, 8
syscall

lb $t2,($a0)                    # meload pilihan ke $t2

beq $t2,105, pilihmetode        # jika masukan sudah benar, pilih metode
beq $t2,112, pilihmetode        # masukan yang benar ‘i’, ‘p’, atau ‘k’
beq $t2,107, pilihmetode

b pilihinput                    # jika masukan salah, minta masukan lagi

pilihmetode:                        # >>> memilih metode sorting yang digunakan <<<
la $a0, str8                    # menamppilkan tulisan
li $v0,4                        # ‘pilih metode…’
syscall

masukanpilihan:
la $a0, str9                # menampilkan tulisan ‘(a/b)?’
li $v0,4
syscall

li $v0,8                    # meminta masukan
la $a0,pilihan                # menyimpannya di ‘pilihan’
li $a1, 8
syscall

lb $t0,($a0)                    # meload masukan jenis metode ke $t0

beq $t0,97, masukkanN            # jika pilihan benar (a/b)
beq $t0,98, masukkanN            # branch ke masukkanN

b masukanpilihan                # jika salah minta masukan lagi

masukkanN:                                # >>> meminta masukan N jumlah input <<<
la $a0, str1                        # menampilkan tulisan
li $v0, 4                            # ‘N: ‘
syscall

li $v0,5                            # meminta masukan, menyimpan di $v0
syscall
move $s1,$v0                        # memindah masukan ke $s1

blez $s1, keluar                    # jika N kurang dari 1, keluar

jr $ra                                # kembali ke register $ra (setelah jal inisial)
#>>>>>>>> end of inisial <<<<<<<<<<<<#

#>>>>>>>> input <<<<<<<<<<<<<<<<<<<#
.data
str3: .asciiz “<> masukan ke-”
str4: .asciiz “: “

.text
input:                                    # >>> meminta input bilangan/karakter yang ingin diurutkan <<<
la $a0, str3                        # menampilkan tulisan ‘masukan ke-’
li $v0, 4
syscall

move $a0, $s0                        # menampilkan counter masukan
li $v0, 1
syscall

la $a0, str4                        # menampilkan ‘: ‘
li $v0, 4
syscall

beq $t2,105, input.ins.int            # branch sesuai pilihan jenis input
beq $t2,112, input.ins.float        # i (105), p(112), atau k(107)
beq $t2,107, input.ins.char

input.ins.int:
li $v0,5                        # meminta masukan integer, menyimpan di $v0
syscall
jr $ra                            # kembali ke langkah setelah input

input.ins.float:
li $v0,7                        # meminta masukan pecahan (double), menyimpak di $f0
syscall
jr $ra                            # kembali ke langkah setelah input

input.ins.char:
li $v0,8                        # meminta masukan karakter
la $a0, arrchar($t3)            # menyimpan di arrchar($t3)
li $a1,1024
syscall
jr $ra                            # kembali ke langkah setelah input
#>>>>>> end of input <<<<<<<<<<#

membuat Program Pengecek Palindrome dengan Assembler

Assembly merupakan bahasa pemrograman tingkat rendah yang sangat dekat dengan kode-kode mesin. Assembly pertama kali dikembangkan pada tahun 1950 sebagai bahasa pemrograman generasi kedua. Pada masa itu bahasa ini merupakan bahasa yang canggih karena programmer tidak perlu lagi mengingat alamat memori dalam memprogram. Sekarang Assembly berguna sebagai perantara bahasa-bahasa tingkat tinggi seperti C, C++, Java dan lain sebagainya. Assembly digunakan dalam pembuatan embedded system. Assembler berguna untuk  mentranslate perintah-perintah Assembly ke dalam kode-kode mesin.  Syntax Assembly agak bervariatif bergantung dengan organisasi dan arsitektur komputer. Kali ini kita belajar assemply MIPS, dengan menggunakan simulatornya SPIM.

download pcSPIM di sini

Program yang akan kita buat adalah program pengecek palindrom. Program akan meminta masukan kalimat yang diakhiri tanda “#” kemudian menyatakan apakah kalimat tersebut merupakan palindrom. Palindrom merupakan kalimat yang dibaca sama dari depan maupun belakang, contohnya: “malam”, “kasur rusak”, “kodok”, dan sebagainya.

 

#PROGRAM IsPalindrom

#program meminta masukkan kalimat dengan diakhiri tanda “#”

#program memberitahu apakah kalimat tersebut merupakan palindrom

.data #kamus

str1: .asciiz “masukkan sebuah kalimat dan akhiri dengan #: “

str2: .asciiz “kalimat tersebut adalah sebuah palindrom”

str3: .asciiz “kalimat tersebut bukan sebuah palindrom”

kalimat: .space 64

.text #algoritma

main:

li $v0, 4

la $a0, str1

syscall #menampilkan str1 ke layar

li $v0, 8

la $a0, kalimat #menyiapkan buffer

li $a1, 64 #menyiapkan panjang tempat

syscall #meminta masukkan kalimat

move $s0, $a0 #menyimpan address huruf pertama kalimat ke $s0

move $s1, $a0 #dan juga $s1, yang akan

#digunakan sebagai pencacah

loop:

lb $s2, ($s1) #meload isi byte di $s1 dan memasukkannya ke $s2

addi $s1, 1 #mencacah $s1

bne $s2, 35, loop #loop berhenti jika bertemu tanda “#”

addi $s1, -2 #mengurangi $s1 dengan 2, ini adalah

#address huruf terakhir kalimat

li $s4, 1 #inisiasi $s4 dengan 1, berarti true

putar: 

lb $s2, ($s0) #mengeluarkan isi byte $s0 dan $s1

lb $s3, ($s1)

bne $s2, $s3, ngenol #membandingkannya, jika tidak sama

  #$s4 menjadi 0/false

addi $s0, 1 #mencacah $s0 naik, $s1 turun

addi $s1, -1

ble $s0, $s1, putar #kembali ke putar hingga $s0 lebih besar dari $s1

li $v0, 4

la $a0, str2

syscall #$s4=1, menampilkan str2

j metu

ngenol: li $s4, 0

li $v0, 4

la $a0, str3

syscall #$s4=0, menampilkan str3

metu: li $v0,10

 syscall

Sedikit Penjelasan

tanda # berarti awal komentar. Suatu komentar dapat dibaca oleh manusia tetapi diabaikan oleh komputer. .data menandakan awal kamus atau variabel-variabel dan konstanta yang akan digunakan dalam kode program. .text menandakan awal algoritma / instruksi-instruksi dalam program.

str2: .asciiz “kalimat tersebut adalah sebuah palindrom” berarti kita mengassign ”kalimat tersebut adalah…”  yang bertipe ascii ke dalam variabel str2.

 

li $v0, 4

la $a0, str1

syscall 

berguna untuk menampilkan str1 ke layar. li$v0,4 menyediakan instruksi print string ke dalam alamat $v0. la $a0, str1 menyediakan string yang akan diprint ke dalam alamat $a0. syscall mengeksekusi instruksi dalam $v0.

bne $s2, 35, loop berarti branch if not equal, jika $s2 tidak sama dengan 35, maka program kembali ke instruksi loop:

untuk penjelasan-penjelasan yang lebih lengkap anda dapat langsung membaca komentar-komentar pada program di atas.