org 256
use16

     mov cx,82h ;load address of first character in Argument in cx
putchar:
   mov dx,[cl]  ;this is the line im not sure about, load address of cx into dx
     mov ah,2   ; call putc
     int 21h    ; putc
     inc cx       ; loop through command line
     cmp cx,90h     ; until 15 characters from argument are read
     ja Done        ;finish looping
     jmp putchar     ; more characters left in arguments, keep reading
     Done:
     mov ah,4Ch ;quit DOS
     int 20h    ;terminate


commandline:   'this well eventually be the string i move the characters read from command line into'            
    

org 100h    ;it looks some weird for me if this is in dec 
use16
        mov bx, 82h ;load address of first character in Argument in bx, we leave first character - space
putchar:
        mov dx, [bx]  ;bx, si or di, to be fair we should use: mov dl, byte [bx], but putc uses only dl part of dx, so we can simply move whole word.
        mov ah, 2     ; call putc
        int 21h       ; putc
        inc bx        ; loop through command line
        cmp bx, 90h   ; until 15 characters from argument are read
        jna putchar
        ret           ; in com files you can just use ret to leave program                                                                                   

org 100h
use16
mov ax,5053h
int 05h
mov [commandline],ax
mov dx,commandline
mov ah,2
int 21h



       ret

commandline:    

    

I only want to load the arguments if they've been entered. And I don't want to read the other characters in the PSP besides the arguments......thanks alot

org 100h    ;it looks some weird for me if this is in dec
use16
        mov bx, 80h  ;load address of counter
        mov cl, [bx] ;load counter
        test cl, cl
        jz bye
        dec cl       ;we don't want print EOL, do we?
        inc bx       ;move to first character
        inc bx       ;skip 1 space. I would rather use scasb to skip all spaces
putchar:
        mov dl, [bx]  ;bx, si or di, to be fair we should use: mov dl, byte [bx], but putc uses only dl part of dx, so we can simply move whole word.
        mov ah, 2     ; call putc
        int 21h       ; putc
        inc bx        ; loop through command line
        dec cl
        jz bye        ;if there is no more characters we can leave program
        cmp bx, 90h   ; until 15 characters from argument are read
        jna putchar
bye:
        ret           ; in com files you can just use ret to leave program    

So if i wanted to load the parameters into a variable. Is my way the best? or are there interrupts that could ...get the string for me and i'd just have to move it into a variable.

org 100h                             ;took your advice lol
use16                           
  org 100h
use16
   mov bx,80h
   mov cl,[bx]
   test cl,cl
   jz NoArguments
   add cx,bx
   inc bx
Again:
   inc bx
   cmp bx,cx
   ja NoArguments
    mov dl,[bx]
    mov ah,2
    int 21h
    jmp Again
NoArguments:
    ret
             


  
    

org 100h
use16
   mov ax,0
   mov bx,80h
   mov cl,[bx]
   test cl,cl
   jz NoArguments
   dec cl
   add cx,bx
Again:
   inc bx
   cmp bx,cx
   ja NoArguments
    mov dl,[bx]
    cmp dl,20h
    jne Again
    inc ax
    jmp Again
 NoArguments:
    mov dx,ax
    add dl,'0'
    mov ah,2
    int 21h
    ret
                                
    

org 100h
use16
   mov dx, '0'
   mov di, 80h
   mov cl, [di]
   xor ch, ch
   inc di
   inc cx
   mov al, 20h
Again:
   repe scasb           ;skip leading spaces
   test cx, cx          ;test if there is no more arguments
   je NoArguments
   inc dx               ;inc arguments count
   repne scasb          ;skip parameter
   jmp Again

NoArguments:
    mov ah,2
    int 21h
    ret    

       org 100h
    use16
       MOV     SI,80h          ;ARGC cmnd line count byte adr in PSP
       LODSW                   ;inc SI=82h now = ARGV
      OR      AL,AL           ;check for AL=0
     JZ      NOinput
     MOV     CL,AL
       XOR     CH,CH
       JCXZ    NOinput         ;another type of check if AL=0
      DEC     CX              ;off by 1 ? ARGC counts space at [81h]
      JZ      NOinput
     CMP     AL,5            ;decide if your program requires a minimum of input
 JB      NOinput         ;print error message AH=9 DS:DX=msg adr INT 21h stuff

       MOV     DI,BUFFER       ;store WORD offset adr of each input at ES:DI
   MOV     AX,SI           ; 82h = first adr
   STOSW                   ; save adr
PARCE:
    LODSB                   ;get byte into AL from DS:SI & INC SI
       CMP     AL,13           ;CR=13 end of command line
  JZ      EOLcmnd         ;redundant with CX=LOOP count
       CMP     AL,'a'
    JB      NOlowr
      CMP     AL,'z'
    JA      NOlowr
      OR      AL,11011111b            ;clear bit-5 = alph to UPPER case
NOlowr:
    CMP     AL,32           ;space=32
   JNZ     NOspac
      MOV     AX,SI
       STOSW                   ; put address of next input into BUFFER
     XOR     AL,AL           ;AL=0=NUL=ASCIIZ file name, alter the command line in the PSP = ok.
NOspac:
  MOV BYTE [SI-1],AL      ;write un/altered byte to were is was in PSP
        LOOP    PARCE           ;use CX to loop (choose one)
        JMP BYTE PARCE          ;use CR check to end loop, JMP SHORT PARCE

;program code here
;exit code here

BUFFER: ;end of .COM code label, starts 60k+? usable buffer.