home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / basic / compiler / asic / srch.asm < prev    next >
Assembly Source File  |  1994-03-01  |  6KB  |  120 lines
  1. ; SRCH.ASM -- A SAMPLE ASSEMBLY LANGUAGE SUBROUTINE THAT CAN BE CALLED FROM ASIC
  2. ; Copyright (c) 1993 by David A. Visti -- All rights reserved
  3. ; USING THE "CALL SUB" STATEMENT.  SEE FILE:   CALLSRCH.ASI  (THE CALLING PROGRAM FOR THIS SUB)
  4. ; THIS PROGRAM WILL SEARCH A STRING ARRAY FOR A SEARCH STRING AND WILL
  5. ; RETURN THE ARRAY SUBSCRIPT OF THE ELEMENT CONTAINING THE SEARCH STRING
  6. ; IF THE ELEMENT IS NOT FOUND, IT RETURNS -1 AS THE SUBSCRIPT
  7. ;
  8. ; THIS ROUTINE EXPECTS TO BE CALLED FROM ASIC AS:   
  9. ;
  10. ;       CALL SUB "SRCH" STRINGARRAY$(0),ARRAYSIZE,SEARCHSTRING$,RETURNVAL
  11. ;           WHERE STRINGARRAY$(0) IS THE ARRAY TO BE SEARCHED
  12. ;                 ARRAYSIZE IS THE NUMBER OF ELEMENTS IN THE ARRAY 
  13. ;                   (SHOULD BE THE SAME AS SPECIFIED ON THE DIM STATEMENT)
  14. ;                 SEARCHSTRING$ IS STRING WE'RE TRYING TO FIND IN STRINGARRAY$
  15. ;                 RETURNVAL IS A VARIABLE SRCH WILL USE TO RETURN IT'S RESULT
  16. ;                  RETURNVAL = -1: SEARCHSTRING$ NOT FOUND IN STRINGARRAY$()
  17. ;                  RETURNVAL >=0 : SUBSCRIPT OF FIRST STRINGARRAY$ ELEMENT
  18. ;                                  CONTAINING SEARCH STRING
  19. ;
  20. ;THE ROUTINE EXPECTS PARAMETERS TO BE PLACED ON THE STACK USING THE STANDARD
  21. ;ASIC CONVENTION.  THAT IS, EACH PARAMETER WILL BE PUSHED TO THE STACK AS A 
  22. ;FAR PTR WITH THE SEGMENT OF EACH PARAMETER PUSHED TO THE STACK FOLLOWED BY 
  23. ;ITS OFFSET.  PARAMETERS ARE PUSHED ONTO THE STACK FROM LEFT TO RIGHT.
  24. ;
  25. ;THUS THE STACK WILL APPEAR AS FOLLOWS:
  26. ;
  27. ;        SP+14h   SEGMENT FOR STRINGARRAY$  PARM
  28. ;        SP+12h   OFFSET  FOR STRINGARRAY$  PARM
  29. ;        SP+10h   SEGMENT FOR ARRAYSIZE     PARM
  30. ;        SP+0Eh   OFFSET  FOR ARRAYSIZE     PARM
  31. ;        SP+0Ch   SEGMENT FOR SEARCHSTRING$ PARM
  32. ;        SP+0Ah   OFFSET  FOR SEARCHSTRING$ PARM
  33. ;        SP+08h   SEGMENT FOR RETURNVAL     PARM
  34. ;        SP+06h   OFFSET  FOR RETURNVAL     PARM
  35. ;        SP+04h   BP REGISTER PUSHED TO STACK BY SRCH.ASM
  36. ;        SP+00h   FAR RETURN ADDRESS
  37. ;
  38. ;ASSEMBLY LANGUAGE SUBROUTINES CAN CHANGE REGISTERS AS THEY WISH, HOWEVER,
  39. ;THE "SS" REGISTER SHOULD NOT BE MODIFIED, AND IF YOU PUSH ANY VALUES TO
  40. ;THE STACK, YOU SHOULD POP THEM BEFORE RETURNING.  THE "SP" REGISTER MUST
  41. ;CONTAIN THE SAME VALUE WHEN YOU "RETF" AS IT DID WHEN YOU ENTERED THE 
  42. ;SUBROUTINE.  ASIC WILL TAKE CARE OF REMOVING THE PARAMETERS FROM THE STACK
  43. ;FOR YOU.
  44.  
  45. ;ASIC CALLS SUBROUTINES USING FAR CALLS (SEGMENT:OFFSET), SO YOU MUST USE
  46. ;THE "RETF" INSTRUCTION TO RETURN TO ASIC.
  47.  
  48.  
  49.                 
  50.  
  51. DATA_SEG        SEGMENT PUBLIC
  52.  
  53. MAXSIZE         DW  0                       ; MAX NUM OF ENTRIES IN ARRAY
  54. CURSUB          DW  0                       ; CURRENT ARRAY ELEMENT BEING SEARCHED
  55. ARRAYPTR        DW  0                       ; POINTER TO CURRENT ARRAY ELEMENT
  56. SRCHPTR         DW  0                       ; POINTER TO START OF SEARCH STRING
  57.  
  58. DATA_SEG        ENDS
  59.  
  60. CODE_SEG        SEGMENT PUBLIC
  61.                 ASSUME  CS:CODE_SEG                
  62.                 ASSUME  DS:DATA_SEG
  63. SRCH            PROC    FAR
  64.                 PUBLIC SRCH
  65.                 
  66.                 MOV AX,DATA_SEG                 ; GET DS FOR THIS SUB
  67.                 MOV DS,AX                       
  68.                 PUSH BP                         ; SAVE BP
  69.                 MOV BP,SP                       ; AND SET TO SP
  70.  
  71.                 MOV AX,[BP+08h]                 ; GET SEGMENT FOR LAST PARM
  72.                                                 ; (CURRENTLY ALL ASIC DATA IS
  73.                                                 ; IN ONE SEGMENT, SO WE WON'T
  74.                                                 ; BOTHER RETRIEVING THE OTHER
  75.                                                 ; SEGMENTS FROM THE STACK
  76.                                                 ; INSTEAD, WE'LL USE THE 
  77.                                                 ; SEGMENT REGISTER FROM THE
  78.                                                 ; LAST PARM FOR ALL PARMS)
  79.                 MOV ES,AX                       ; AND PUT IN ES REG
  80.  
  81.                 MOV [CURSUB],0                  ; RESET CURSUB TO 0
  82.                 MOV BX,[BP+0Eh]                 ; GET OFFSET FOR ARRAYSIZE
  83.                 MOV AX,ES:[BX]                  ; AND GET VALUE INTO AX
  84.                 MOV [MAXSIZE],AX                ; AND STORE INTO MAXSIZE
  85.                 MOV BX,[BP+12h]                 ; GET OFFSET OF STRINGARRAY$
  86.                 MOV [ARRAYPTR],BX               ; SAVE IN ARRAYPTR
  87.                 MOV BX,[BP+0Ah]                 ; GET OFFSET OF SEARCHSTRING$
  88.                 MOV [SRCHPTR],BX                ; SAVE IN SRCHPTR
  89. NEXTSUB:        MOV SI,[ARRAYPTR]               ; GET ARRAY PTR
  90.                 MOV DI,[SRCHPTR]                ; GET SEARCH STRING PTR
  91. NEXTBYTE:       MOV AH,BYTE PTR ES:[SI]         ; GET NEXT BYTE OF ARRAY ELEMENT
  92.                 MOV AL,BYTE PTR ES:[DI]         ; AND NEXT BYTE OF SRCH STRING
  93.                 CMP AH,AL                       ; ARE THEY THE SAME
  94.                 JNZ NEXTPAIR                    ; NO, LET'S GET GET ARRAY SUB
  95.                 CMP AH,0
  96.                 JZ  MATCH                       ; WE'RE AT END OF STRINGS, WE MATCHED
  97.                 INC SI                          ; GET NEXT BYTE PAIR
  98.                 INC DI          
  99.                 JMP NEXTBYTE
  100. NEXTPAIR:       MOV AX,[CURSUB]                 ; INCREMENT CURRENT SUB
  101.                 INC AX
  102.                 MOV [CURSUB],AX
  103.                 MOV BX,[MAXSIZE]                ; SEE IF WE'RE PAST MAX SIZE
  104.                 CMP AX,BX
  105.                 JG  NOMATCH                     ; SEARCH WHOLE ARRAY--DIDN'T FIND MATCH
  106.                 MOV AX,[ARRAYPTR]               ; BUMP PTR TO NEXT ELEMENT
  107.                 ADD AX,81
  108.                 MOV [ARRAYPTR],AX               ; SAVE NEW PTR
  109.                 JMP NEXTSUB                     ; AND GO COMPARE NEXT PAIR
  110. NOMATCH:        MOV AX,-1                       ; SET AX TO ERROR VALUE
  111.                 MOV [CURSUB],AX                 ; AND STORE IN CURSUB
  112. MATCH:          MOV AX,[CURSUB]                 ; GET ELEMENT NUMBER TO RETURN
  113.                 MOV BX,[BP+06h]                 ; GET OFFSET FOR RETURNVAL
  114.                 MOV ES:[BX],AX                  ; AND STORE CURSUB IN RETURNVAL
  115.                 POP BP                          ; RESTORE BP REGISTER
  116.                 RETF
  117. SRCH            ENDP
  118. CODE_SEG        ENDS
  119.                 END
  120.