title: Insertion sort in Assembly
body: <p>So I'm coding out an insertion sort (in assembly) based on this high level code:</p>
  
  <pre><code>void insertionSort(int data[ ], int arraySize) {
          int insert;
          int moveItem;
          for(int next=1; next&lt;arraySize; next++) {
                      insert=data[next];  //store the value in the current element
                      moveItem=next;    //initialize location to place element
  
                      while((moveItem&gt;0)&amp;&amp;(data[moveItem-1]&gt;insert)) {
                                 //shift element one slot to the right
                                  data[moveItem]=data[moveItem-1];
                                  moveItem--;
                      }  //end while
  
                      data[moveItem]=insert;
          } //end for
  } //end insertionSort
  </code></pre>
  
  <p>There are exactly 20 random numbers in an array called myArray. I cannot use an of the decision derivatives that come in the library that comes with our book. So basically movs, cmps, loops, and jumps
  Here's what I got. I had it sorting the first of 20 random numbers earlier, but I've confused myself to death and have no idea what I'm doing any more. It crashes when it gets to the insertion sort method. Help please.</p>
  
  <pre><code>TITLE Insertion Sort (main.asm)
  INCLUDE Irvine32.inc
  .data
  
  elems = 20
  
  myArray  sdword   elems dup(0)
  str1 byte "Press enter" ,0
  str2 byte "The array now is ",0
  next sdword 1
  start sdword ?
  
  .code
  main PROC
      call Clrscr
      call CreateRandom
      call Display
      call InsertionSort
      call Display
      exit
  main ENDP
  
  CreateRandom PROC
  ;;;;Creates 20 random numbers and populates myArray;;;;;
      call Randomize
      mov ecx, 20
      mov edx, OFFSET myArray
  
  L1:                     
      call Random32                   ;create random number
      mov [edx], eax                  ; move random number to the appropriate spot in the array
      add edx, 4                      ; increase the address of what it is pointing to
      loop L1
      mov edx, OFFSET str1            ; "press enter to continue"
      call WriteString
      call ReadInt
      call Crlf
      ret
  CreateRandom ENDP
  
  Display PROC
  ;;;; Displays current form of the array myArray;;;;;
      mov edx, OFFSET str2                ; "The array now is:"
      call WriteString                    ; write string
      call Crlf
      mov esi, OFFSET myArray             ; offset of the array 
      mov ecx, 20                         ; index of the loop
  L2:  
      mov eax, [esi]                      ; move array at that point to eax
      call WriteDec                       ; print out the array as a decimal
      call Crlf                           ; next line
      add esi, 4                          ; next element in the array
      loop L2
      call Crlf
      ret
  Display ENDP
  
  InsertionSort PROC
  mov ecx, 19
  mov edx, OFFSET myArray
  mov ebx, OFFSET myArray            ; eax=next
  add ebx, 4                        ;moves up the array to second element comparable to next
  
  outterloop:
      mov    esi, [ebx]                    ; esi=data[next]
      mov eax, ebx                ;movelterm=ebx
      L1:
          mov edx, [eax-4]            ;move the number that is greater into edx
          mov [eax], edx                ;move the number into that 2nd element of the
          sub eax, 4
          mov esi, [eax]
          cmp eax, [edx]
          JNG endinner                        ; if the address is not greater than the first address, skip to the end
          mov edx, [eax-4]
          cmp edx, esi                        ; if the address is greater, than it already sorted, skip to end
          JG endinner
          loop L1
      endinner:
          mov [eax], esi  ; move first to the second to finish the sort
          add ebx, 4    ;move to the next element of the array
      inc next   ;counting outside loop
          cmp ecx, next
          JNE outterloop ;return to top of for loop
  
  ret
  InsertionSort ENDP
  
  END main
  </code></pre>