//////////////////////////////////////////////////////////////////////////////
//                                                                           /
// IAR ARM ANSI C/C++ Compiler V4.11A/W32              20/Jul/2004  18:58:49 /
// Copyright 1999-2004 IAR Systems. All rights reserved.                     /
//                                                                           /
//    Cpu mode        =  arm                                                 /
//    Endian          =  little                                              /
//    Stack alignment =  4                                                   /
//    Source file     =  C:\medusa\cli.c                                     /
//    Command line    =  -I "C:\Program Files\IAR Systems\Embedded           /
//                       Workbench 4.0\ARM\INC\" -lc C:\medusa\Debug\List\   /
//                       -la C:\medusa\Debug\List\ -o C:\medusa\Debug\Obj\   /
//                       -s2 --no_cse --no_unroll --no_inline                /
//                       --no_code_motion --no_tbaa --no_clustering          /
//                       --no_scheduling --debug --cpu_mode arm --endian     /
//                       little --cpu ARM7TDMI-S --stack_align 4 -e --fpu    /
//                       None "-D_DLIB_CONFIG_FILE=C:\Program Files\IAR      /
//                       Systems\Embedded Workbench                          /
//                       4.0\ARM\LIB\dl4tpannl8n.h" C:\medusa\cli.c          /
//    List file       =  C:\medusa\Debug\List\cli.s79                        /
//                                                                           /
//                                                                           /
//////////////////////////////////////////////////////////////////////////////

        NAME cli

        RTMODEL "ARMv4M", "USED"
        RTMODEL "StackAlign4", "USED"
        RTMODEL "__cpu_mode", "__pcs__arm"
        RTMODEL "__data_model", "absolute"
        RTMODEL "__dlib_file_descriptor", "0"
        RTMODEL "__endian", "little"
        RTMODEL "__rt_version", "6"

        RSEG CSTACK:DATA:NOROOT(2)

??DataTable0 EQU 0
??DataTable1 EQU 0
??DataTable2 EQU 0
??DataTable3 EQU 0
??DataTable4 EQU 0
??DataTable5 EQU 0
??DataTable6 EQU 0
??DataTable7 EQU 0
??DataTable8 EQU 0
        PUBWEAK ?init?tab?DATA_Z
        PUBLIC cliDoCommand
        FUNCTION cliDoCommand,0203H
        LOCFRAME CSTACK, 40, STACK
        PUBLIC cliInit
        FUNCTION cliInit,0203H
        LOCFRAME CSTACK, 4, STACK
        PUBLIC cliRegisterCommand
        FUNCTION cliRegisterCommand,0203H
        LOCFRAME CSTACK, 8, STACK
        MULTWEAK clicharGetOutputBuffer??rA
        MULTWEAK clicharSendOutputBuffer??rA
        PUBLIC handlerTable
        PUBLIC helpHandler
        FUNCTION helpHandler,0603H
        LOCFRAME CSTACK, 32, STACK
        FUNCTION lookupCommand,0203H
        LOCFRAME CSTACK, 20, STACK
        FUNCTION processLineComment,0203H
        FUNCTION seekWhiteSpace,0203H
        FUNCTION skipWhiteSpace,0203H
        MULTWEAK sprintf??rA
        MULTWEAK strutil_strncasecmp??rA
        FUNCTION tokenizeString,0203H
        LOCFRAME CSTACK, 40, STACK
        
        CFI Names cfiNames0
        CFI StackFrame CFA R13 HUGEDATA
        CFI Resource R0:32, R1:32, R2:32, R3:32, R4:32, R5:32, R6:32, R7:32
        CFI Resource R8:32, R9:32, R10:32, R11:32, R12:32, CPSR:32, R13:32
        CFI Resource R14:32, SPSR:32
        CFI VirtualResource ?RET:32
        CFI EndNames cfiNames0
        
        CFI Common cfiCommon0 Using cfiNames0
        CFI CodeAlign 4
        CFI DataAlign 4
        CFI ReturnAddress ?RET CODE
        CFI CFA R13+0
        CFI R0 Undefined
        CFI R1 Undefined
        CFI R2 Undefined
        CFI R3 Undefined
        CFI R4 SameValue
        CFI R5 SameValue
        CFI R6 SameValue
        CFI R7 SameValue
        CFI R8 SameValue
        CFI R9 SameValue
        CFI R10 SameValue
        CFI R11 SameValue
        CFI R12 Undefined
        CFI CPSR SameValue
        CFI R14 Undefined
        CFI SPSR SameValue
        CFI ?RET R14
        CFI EndCommon cfiCommon0
        
clicharGetOutputBuffer SYMBOL "clicharGetOutputBuffer"
clicharSendOutputBuffer SYMBOL "clicharSendOutputBuffer"
sprintf             SYMBOL "sprintf"
strutil_strncasecmp SYMBOL "strutil_strncasecmp"
clicharGetOutputBuffer??rA SYMBOL "??rA", clicharGetOutputBuffer
clicharSendOutputBuffer??rA SYMBOL "??rA", clicharSendOutputBuffer
sprintf??rA         SYMBOL "??rA", sprintf
strutil_strncasecmp??rA SYMBOL "??rA", strutil_strncasecmp

        EXTERN clicharGetOutputBuffer
        FUNCTION clicharGetOutputBuffer,0202H
        EXTERN clicharSendOutputBuffer
        FUNCTION clicharSendOutputBuffer,0202H
        EXTERN sprintf
        FUNCTION sprintf,010202H
        EXTERN strutil_strncasecmp
        FUNCTION strutil_strncasecmp,0202H


        RSEG DATA_Z:DATA:SORT:NOROOT(2)
argvArray:
        DS8 32

        RSEG DATA_Z:DATA:SORT:NOROOT(2)
handlerTable:
        DS8 768

        RSEG DATA_Z:DATA:SORT:NOROOT(2)
handlerTableLen:
        DS8 4

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock0 Using cfiCommon0
        CFI Function lookupCommand
   CODE32      
lookupCommand:
   STMDB       SP!,{R4-R7,LR}     ;; Push
        CFI ?RET Frame(CFA, -4)
        CFI R7 Frame(CFA, -8)
        CFI R6 Frame(CFA, -12)
        CFI R5 Frame(CFA, -16)
        CFI R4 Frame(CFA, -20)
        CFI CFA R13+20
   MOV         R5,R0
   MOV         R6,R1
   MVN         R0,#+0x0
   MOV         R7,R0
   MOV         R1,#+0x0
   MOV         R4,R1
??lookupCommand_0:
   LDR         R2,??DataTable10   ;; handlerTableLen
   LDR         R3,[R2, #+0]
   CMP         R4,R3
   BGE         ??lookupCommand_1
   MOV         R2,#+0x10
   MOV         R12,#+0xC
   LDR         LR,??DataTable9    ;; handlerTable
   MLAS        R0,R12,R4,LR
   LDR         R1,[R0, #+0]
   MOV         R0,R5
   _BLF        strutil_strncasecmp,strutil_strncasecmp??rA
   MOV         R7,R0
   CMP         R0,#+0x0
   BNE         ??lookupCommand_2
   MOV         R1,#+0xC
   LDR         R2,??DataTable9    ;; handlerTable
   MLAS        R3,R1,R4,R2
   STR         R3,[R6, #+0]
   MOV         R12,#+0x0
   MOV         R7,R12
   B           ??lookupCommand_1
??lookupCommand_2:
   ADDS        R4,R4,#+0x1
   B           ??lookupCommand_0
??lookupCommand_1:
   MOV         R0,R7
   LDMIA       SP!,{R4-R7,PC}     ;; return
        CFI EndBlock cfiBlock0

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock1 Using cfiCommon0
        CFI Function skipWhiteSpace
   CODE32      
skipWhiteSpace:
??skipWhiteSpace_0:
   LDR         R1,[R0, #+0]
   LDRB        R2,[R1, #+0]
   CMP         R2,#+0x20
   BEQ         ??skipWhiteSpace_1
   LDR         R3,[R0, #+0]
   LDRB        R12,[R3, #+0]
   CMP         R12,#+0x9
   BNE         ??skipWhiteSpace_2
??skipWhiteSpace_1:
   LDR         R1,[R0, #+0]
   LDRB        R2,[R1, #+0]
   CMP         R2,#+0x0
   BEQ         ??skipWhiteSpace_2
   LDR         R3,[R0, #+0]
   ADDS        R12,R3,#+0x1
   STR         R12,[R0, #+0]
   B           ??skipWhiteSpace_0
??skipWhiteSpace_2:
   LDR         R0,[R0, #+0]
   LDRB        R1,[R0, #+0]
   CMP         R1,#+0x0
   BNE         ??skipWhiteSpace_3
   MVN         R0,#+0x0
   B           ??skipWhiteSpace_4
??skipWhiteSpace_3:
   MOV         R0,#+0x0
??skipWhiteSpace_4:
   MOV         PC,LR              ;; return
        CFI EndBlock cfiBlock1

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock2 Using cfiCommon0
        CFI Function seekWhiteSpace
   CODE32      
seekWhiteSpace:
??seekWhiteSpace_0:
   LDR         R1,[R0, #+0]
   LDRB        R2,[R1, #+0]
   CMP         R2,#+0x20
   BEQ         ??seekWhiteSpace_1
   LDR         R3,[R0, #+0]
   LDRB        R12,[R3, #+0]
   CMP         R12,#+0x9
   BEQ         ??seekWhiteSpace_1
   LDR         R1,[R0, #+0]
   LDRB        R2,[R1, #+0]
   CMP         R2,#+0x0
   BEQ         ??seekWhiteSpace_1
   LDR         R3,[R0, #+0]
   ADDS        R12,R3,#+0x1
   STR         R12,[R0, #+0]
   B           ??seekWhiteSpace_0
??seekWhiteSpace_1:
   LDR         R0,[R0, #+0]
   LDRB        R1,[R0, #+0]
   CMP         R1,#+0x0
   BNE         ??seekWhiteSpace_2
   MVN         R0,#+0x0
   B           ??seekWhiteSpace_3
??seekWhiteSpace_2:
   MOV         R0,#+0x0
??seekWhiteSpace_3:
   MOV         PC,LR              ;; return
        CFI EndBlock cfiBlock2

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock3 Using cfiCommon0
        CFI Function processLineComment
   CODE32      
processLineComment:
   MOV         R2,R0
   CMP         R1,#+0x0
   BEQ         ??processLineComment_0
   LDRB        R0,[R2, #+0]
   CMP         R0,#+0x0
   BNE         ??processLineComment_1
??processLineComment_0:
   MVN         R0,#+0x0
   B           ??processLineComment_2
??processLineComment_1:
   MOV         R12,#+0x0
   MOV         R3,R12
??processLineComment_3:
   CMP         R3,R1
   BGE         ??processLineComment_4
   LDRB        R0,[R2, #+0]
   CMP         R0,#+0x0
   BEQ         ??processLineComment_4
   LDRB        R12,[R2, #+0]
   CMP         R12,#+0x23
   BNE         ??processLineComment_5
   MOV         R0,#+0x0
   STRB        R0,[R2, #+0]
   B           ??processLineComment_4
??processLineComment_5:
   ADDS        R3,R3,#+0x1
   ADDS        R2,R2,#+0x1
   B           ??processLineComment_3
??processLineComment_4:
   MOV         R0,#+0x0
??processLineComment_2:
   MOV         PC,LR              ;; return
        CFI EndBlock cfiBlock3

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock4 Using cfiCommon0
        CFI Function tokenizeString
   CODE32      
tokenizeString:
   STMDB       SP!,{R0,R4-R10,LR}  ;; Push
        CFI ?RET Frame(CFA, -4)
        CFI R10 Frame(CFA, -8)
        CFI R9 Frame(CFA, -12)
        CFI R8 Frame(CFA, -16)
        CFI R7 Frame(CFA, -20)
        CFI R6 Frame(CFA, -24)
        CFI R5 Frame(CFA, -28)
        CFI R4 Frame(CFA, -32)
        CFI CFA R13+36
   SUB         SP,SP,#+0x4
        CFI CFA R13+40
   MOV         R4,R1
   MOV         R5,R2
   CMP         R5,#+0x0
   BNE         ??tokenizeString_0
   MVN         R0,#+0x0
   B           ??tokenizeString_1
??tokenizeString_0:
   MOV         R1,#+0x0
   MOV         R10,R1
??tokenizeString_2:
   CMP         R10,R5
   BGE         ??tokenizeString_3
   MOV         R2,#+0x4
   MLAS        R3,R2,R10,R4
   MOV         R12,#+0x0
   STR         R12,[R3, #+0]
   ADDS        R10,R10,#+0x1
   B           ??tokenizeString_2
??tokenizeString_3:
   ADD         R0,SP,#+0x4
   BL          skipWhiteSpace
   CMN         R0,#+0x1
   BNE         ??tokenizeString_4
   MVN         R0,#+0x0
   B           ??tokenizeString_1
??tokenizeString_4:
   LDR         R0,[SP, #+4]
   MOV         R8,R0
   MOV         R7,R0
   MOV         R6,R0
   MOV         R0,#+0x0
   MOV         R9,R0
   MOV         R1,#+0x4
   MLAS        R2,R1,R9,R4
   LDR         R12,[SP, #+4]
   STR         R12,[R2, #+0]
   ADDS        R9,R9,#+0x1
??tokenizeString_5:
   ADD         R0,SP,#+0x4
   BL          seekWhiteSpace
   CMP         R0,#+0x0
   BNE         ??tokenizeString_6
   CMP         R9,R5
   BGE         ??tokenizeString_6
   LDR         R0,[SP, #+4]
   MOV         R1,#+0x0
   STRB        R1,[R0, #+0]
   LDR         R12,[SP, #+4]
   ADDS        LR,R12,#+0x1
   STR         LR,[SP, #+4]
   ADD         R0,SP,#+0x4
   BL          skipWhiteSpace
   MOV         R0,#+0x4
   MLAS        R1,R0,R9,R4
   LDR         R3,[SP, #+4]
   STR         R3,[R1, #+0]
   ADDS        R9,R9,#+0x1
   B           ??tokenizeString_5
??tokenizeString_6:
   MOV         R0,R9
??tokenizeString_1:
   ADD         SP,SP,#+0x8        ;; stack cleaning
        CFI CFA R13+32
   LDMIA       SP!,{R4-R10,PC}    ;; return
        CFI EndBlock cfiBlock4

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock5 Using cfiCommon0
        CFI Function cliInit
   CODE32      
cliInit:
   STMDB       SP!,{LR}           ;; Push
        CFI ?RET Frame(CFA, -4)
        CFI CFA R13+4
   LDR         R0,??DataTable10   ;; handlerTableLen
   MOV         R1,#+0x0
   STR         R1,[R0, #+0]
   LDR         R2,??cliInit_0     ;; `?<Constant "help <command>">`
   LDR         R1,??cliInit_0+4   ;; helpHandler
   LDR         R0,??cliInit_0+8   ;; `?<Constant "help">`
   BL          cliRegisterCommand
   MOV         R0,#+0x0
   LDMIA       SP!,{PC}           ;; return
   DATA        
??cliInit_0:
   DC32        `?<Constant "help <command>">`
   DC32        helpHandler
   DC32        `?<Constant "help">`
        CFI EndBlock cfiBlock5

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock6 Using cfiCommon0
        CFI Function cliRegisterCommand
   CODE32      
cliRegisterCommand:
   STMDB       SP!,{R4,R5}        ;; Push
        CFI R5 Frame(CFA, -4)
        CFI R4 Frame(CFA, -8)
        CFI CFA R13+8
   MOV         R3,R0
   LDR         R0,??DataTable10   ;; handlerTableLen
   LDR         R0,[R0, #+0]
   CMP         R0,#+0x40
   BNE         ??cliRegisterCommand_0
   MVN         R0,#+0x0
   B           ??cliRegisterCommand_1
??cliRegisterCommand_0:
   LDR         R0,??DataTable10   ;; handlerTableLen
   LDR         R0,[R0, #+0]
   MOV         R4,#+0xC
   LDR         R5,??DataTable9    ;; handlerTable
   MLAS        R0,R4,R0,R5
   MOV         R12,R0
   STR         R3,[R12, #+0]
   STR         R1,[R12, #+4]
   STR         R2,[R12, #+8]
   LDR         R4,??DataTable10   ;; handlerTableLen
   LDR         R5,??DataTable10   ;; handlerTableLen
   LDR         R0,[R5, #+0]
   ADDS        R5,R0,#+0x1
   STR         R5,[R4, #+0]
   MOV         R0,#+0x0
??cliRegisterCommand_1:
   LDMIA       SP!,{R4,R5}        ;; Pop
        CFI R4 SameValue
        CFI R5 SameValue
        CFI CFA R13+0
   MOV         PC,LR              ;; return
        CFI EndBlock cfiBlock6

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock7 Using cfiCommon0
        CFI Function cliDoCommand
   CODE32      
cliDoCommand:
   STMDB       SP!,{R4-R9,LR}     ;; Push
        CFI ?RET Frame(CFA, -4)
        CFI R9 Frame(CFA, -8)
        CFI R8 Frame(CFA, -12)
        CFI R7 Frame(CFA, -16)
        CFI R6 Frame(CFA, -20)
        CFI R5 Frame(CFA, -24)
        CFI R4 Frame(CFA, -28)
        CFI CFA R13+28
   SUB         SP,SP,#+0xC
        CFI CFA R13+40
   MOV         R7,R0
   MOV         R8,R1
   MVN         R0,#+0x0
   MOV         R9,R0
   ADD         R0,SP,#+0x4
   _BLF        clicharGetOutputBuffer,clicharGetOutputBuffer??rA
   MOV         R6,R0
   MOV         R1,R8
   MOV         R0,R7
   BL          processLineComment
   CMN         R0,#+0x1
   BNE         ??cliDoCommand_0
   MOV         R0,R9
   B           ??cliDoCommand_1
??cliDoCommand_0:
   MOV         R2,#+0x8
   LDR         R1,??cliDoCommand_2  ;; argvArray
   MOV         R0,R7
   BL          tokenizeString
   MOV         R4,R0
   CMN         R0,#+0x1
   BEQ         ??cliDoCommand_3
   MOV         R1,SP
   LDR         R2,??cliDoCommand_2  ;; argvArray
   LDR         R0,[R2, #+0]
   BL          lookupCommand
   CMP         R0,#+0x0
   BNE         ??cliDoCommand_4
   LDR         R3,[SP, #+0]
   CMP         R3,#+0x0
   BEQ         ??cliDoCommand_3
   LDR         LR,[SP, #+0]
   LDR         R0,[LR, #+4]
   CMP         R0,#+0x0
   BEQ         ??cliDoCommand_3
   MOV         R2,R5
   LDR         R1,??cliDoCommand_2  ;; argvArray
   MOV         R0,R4
   LDR         R12,[SP, #+0]
   LDR         R3,[R12, #+4]
   MOV         LR,PC
   MOV         PC,R3
   MOV         R9,R0
   CMP         R9,#+0x0
   BEQ         ??cliDoCommand_3
   MOV         R3,R9
   LDR         R2,??cliDoCommand_2  ;; argvArray
   LDR         R2,[R2, #+0]
   LDR         R1,??cliDoCommand_2+4  ;; `?<Constant "%s: error, returned [...">`
   MOV         R0,R6
   _BLF        sprintf,sprintf??rA
   LDR         R1,[SP, #+4]
   MOV         R0,R6
   _BLF        clicharSendOutputBuffer,clicharSendOutputBuffer??rA
   B           ??cliDoCommand_3
??cliDoCommand_4:
   LDR         LR,??cliDoCommand_2  ;; argvArray
   LDR         R2,[LR, #+0]
   LDR         R1,??cliDoCommand_2+8  ;; `?<Constant "error, command not fo...">`
   MOV         R0,R6
   _BLF        sprintf,sprintf??rA
   LDR         R1,[SP, #+4]
   MOV         R0,R6
   _BLF        clicharSendOutputBuffer,clicharSendOutputBuffer??rA
??cliDoCommand_3:
   MOV         R0,R9
??cliDoCommand_1:
   ADD         SP,SP,#+0xC        ;; stack cleaning
        CFI CFA R13+28
   LDMIA       SP!,{R4-R9,PC}     ;; return
   DATA        
??cliDoCommand_2:
   DC32        argvArray
   DC32        `?<Constant "%s: error, returned [...">`
   DC32        `?<Constant "error, command not fo...">`
        CFI EndBlock cfiBlock7

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock8 Using cfiCommon0
        CFI Function helpHandler
   CODE32      
helpHandler:
   STMDB       SP!,{R4-R8,LR}     ;; Push
        CFI ?RET Frame(CFA, -4)
        CFI R8 Frame(CFA, -8)
        CFI R7 Frame(CFA, -12)
        CFI R6 Frame(CFA, -16)
        CFI R5 Frame(CFA, -20)
        CFI R4 Frame(CFA, -24)
        CFI CFA R13+24
   SUB         SP,SP,#+0x8
        CFI CFA R13+32
   MOV         R4,R0
   MOV         R5,R1
   MOV         R6,R2
   ADD         R0,SP,#+0x4
   _BLF        clicharGetOutputBuffer,clicharGetOutputBuffer??rA
   MOV         R8,R0
   CMP         R4,#+0x2
   BLT         ??helpHandler_0
   MOV         R1,SP
   LDR         R0,[R5, #+4]
   BL          lookupCommand
   CMP         R0,#+0x0
   BNE         ??helpHandler_1
   LDR         R1,[SP, #+0]
   LDR         R2,[R1, #+8]
   CMP         R2,#+0x0
   BEQ         ??helpHandler_1
   LDR         R12,[SP, #+0]
   LDR         R3,[R12, #+8]
   LDR         R2,[R5, #+4]
   LDR         R1,??helpHandler_2  ;; `?<Constant "%s: %s\\r\\n">`
   MOV         R0,R8
   _BLF        sprintf,sprintf??rA
   LDR         R1,[SP, #+4]
   MOV         R0,R8
   _BLF        clicharSendOutputBuffer,clicharSendOutputBuffer??rA
   B           ??helpHandler_1
??helpHandler_0:
   LDR         R1,??DataTable9    ;; handlerTable
   STR         R1,[SP, #+0]
   MOV         R2,#+0x0
   MOV         R7,R2
??helpHandler_3:
   LDR         R3,??DataTable10   ;; handlerTableLen
   LDR         R12,[R3, #+0]
   CMP         R7,R12
   BGE         ??helpHandler_1
   LDR         R0,[SP, #+0]
   LDR         R1,[R0, #+8]
   CMP         R1,#+0x0
   BEQ         ??helpHandler_4
   LDR         R3,[SP, #+0]
   LDR         R3,[R3, #+8]
   LDR         LR,[SP, #+0]
   LDR         R2,[LR, #+0]
   LDR         R1,??helpHandler_2  ;; `?<Constant "%s: %s\\r\\n">`
   MOV         R0,R8
   _BLF        sprintf,sprintf??rA
   LDR         R1,[SP, #+4]
   MOV         R0,R8
   _BLF        clicharSendOutputBuffer,clicharSendOutputBuffer??rA
??helpHandler_4:
   ADDS        R7,R7,#+0x1
   LDR         R3,[SP, #+0]
   ADDS        R12,R3,#+0xC
   STR         R12,[SP, #+0]
   B           ??helpHandler_3
??helpHandler_1:
   MOV         R0,#+0x0
   ADD         SP,SP,#+0x8        ;; stack cleaning
        CFI CFA R13+24
   LDMIA       SP!,{R4-R8,PC}     ;; return
   DATA        
??helpHandler_2:
   DC32        `?<Constant "%s: %s\\r\\n">`
        CFI EndBlock cfiBlock8

        RSEG CODE:CODE:NOROOT(2)
   DATA        
??DataTable9:
   DC32        handlerTable

        RSEG CODE:CODE:NOROOT(2)
   DATA        
??DataTable10:
   DC32        handlerTableLen

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock9 Using cfiCommon0
        CFI NoFunction
   CODE32      
strutil_strncasecmp??rA:
   LDR         R12,??Subroutine0_0  ;; strutil_strncasecmp
   MOV         PC,R12
   DATA        
??Subroutine0_0:
   DC32        strutil_strncasecmp
        CFI EndBlock cfiBlock9

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock10 Using cfiCommon0
        CFI NoFunction
   CODE32      
clicharGetOutputBuffer??rA:
   LDR         R12,??Subroutine1_0  ;; clicharGetOutputBuffer
   MOV         PC,R12
   DATA        
??Subroutine1_0:
   DC32        clicharGetOutputBuffer
        CFI EndBlock cfiBlock10

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock11 Using cfiCommon0
        CFI NoFunction
   CODE32      
sprintf??rA:
   LDR         R12,??Subroutine2_0  ;; sprintf
   MOV         PC,R12
   DATA        
??Subroutine2_0:
   DC32        sprintf
        CFI EndBlock cfiBlock11

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock12 Using cfiCommon0
        CFI NoFunction
   CODE32      
clicharSendOutputBuffer??rA:
   LDR         R12,??Subroutine3_0  ;; clicharSendOutputBuffer
   MOV         PC,R12
   DATA        
??Subroutine3_0:
   DC32        clicharSendOutputBuffer
        CFI EndBlock cfiBlock12

        RSEG INITTAB:CODE:ROOT(2)
   DATA
?init?tab?DATA_Z:
   DCD      sfe(DATA_Z) - sfb(DATA_Z), sfb(DATA_Z), sfb(DATA_Z)

        RSEG DATA_C:CONST:SORT:NOROOT(2)
`?<Constant "help">`:
        DC8 "help"
        DC8 0, 0, 0

        RSEG DATA_C:CONST:SORT:NOROOT(2)
`?<Constant "help <command>">`:
        DC8 "help <command>"
        DC8 0

        RSEG DATA_C:CONST:SORT:NOROOT(2)
`?<Constant "%s: error, returned [...">`:
        DC8 "%s: error, returned [%d]\015\012"
        DC8 0

        RSEG DATA_C:CONST:SORT:NOROOT(2)
`?<Constant "error, command not fo...">`:
        DC8 "error, command not found [%s]\015\012"

        RSEG DATA_C:CONST:SORT:NOROOT(2)
`?<Constant "%s: %s\\r\\n">`:
        DC8 "%s: %s\015\012"
        DC8 0, 0, 0

        END
// 
// 1 384 bytes in segment CODE
//    96 bytes in segment DATA_C
//   804 bytes in segment DATA_Z
//    12 bytes in segment INITTAB
// 
// 1 336 bytes of CODE  memory (+ 60 bytes shared)
//    96 bytes of CONST memory
//   804 bytes of DATA  memory
//
//Errors: none
//Warnings: 8
