//////////////////////////////////////////////////////////////////////////////
//                                                                           /
// IAR ARM ANSI C/C++ Compiler V4.42A/W32 EVALUATION   26/May/2009  12:58:53 /
// Copyright 1999-2005 IAR Systems. All rights reserved.                     /
//                                                                           /
//    Cpu mode        =  interwork                                           /
//    Endian          =  little                                              /
//    Stack alignment =  4                                                   /
//    Source file     =  D:\pasha\elf\evil_src\miosdel\miosd                 /
//                       elka\string_works.c                                 /
//    Command line    =  "D:\pasha\elf\evil_src\miosdel\miosd                /
//                       elka\string_works.c" -D NEWSGOLD -D ELKA -lC        /
//                       "D:\pasha\elf\evil_src\miosdel\miosd                /
//                       elka\Release_ELKA\List\" -lA                        /
//                       "D:\pasha\elf\evil_src\miosdel\miosd                /
//                       elka\Release_ELKA\List\" -o                         /
//                       "D:\pasha\elf\evil_src\miosdel\miosd                /
//                       elka\Release_ELKA\Obj\" -s9 --no_unroll --cpu_mode  /
//                       arm --endian little --cpu ARM926EJ-S --stack_align  /
//                       4 --interwork -e --fpu None --dlib_config           /
//                       "D:\pasha\Embedded Workbench 4.0                    /
//                       Evaluation2\ARM\LIB\dl5tpainl8n.h" -I               /
//                       "D:\pasha\Embedded Workbench 4.0                    /
//                       Evaluation2\ARM\INC\" --inline_threshold=2          /
//    List file       =  D:\pasha\elf\evil_src\miosdel\miosd                 /
//                       elka\Release_ELKA\List\string_works.s79             /
//                                                                           /
//                                                                           /
//////////////////////////////////////////////////////////////////////////////

        NAME string_works

        RTMODEL "StackAlign4", "USED"
        RTMODEL "__cpu_mode", "__pcs__interwork"
        RTMODEL "__data_model", "absolute"
        RTMODEL "__endian", "little"
        RTMODEL "__rt_version", "6"

        RSEG CSTACK:DATA:NOROOT(2)

        MULTWEAK ??MakeGlobalString??rT
        MULTWEAK ??ascii2ws??rT
        MULTWEAK ??char16to8??rT
        MULTWEAK ??char8to16??rT
        MULTWEAK ??strcmp_nocase??rT
        MULTWEAK ??utf82win??rT
        PUBLIC MakeGlobalString
        FUNCTION MakeGlobalString,0203H
        LOCFRAME CSTACK, 24, STACK
        PUBLIC ascii2ws
        FUNCTION ascii2ws,0203H
        LOCFRAME CSTACK, 12, STACK
        PUBLIC char16to8
        FUNCTION char16to8,0203H
        PUBLIC char8to16
        FUNCTION char8to16,0203H
        PUBLIC dos2unicode
        PUBLIC strcmp_nocase
        FUNCTION strcmp_nocase,0203H
        PUBLIC utf82win
        FUNCTION utf82win,0203H
        PUBLIC wintranslation
        
        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 2
        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
        
        
        CFI Common cfiCommon1 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 cfiCommon1
        
MakeGlobalString    SYMBOL "MakeGlobalString"
??MakeGlobalString??rT SYMBOL "??rT", MakeGlobalString
ascii2ws            SYMBOL "ascii2ws"
??ascii2ws??rT      SYMBOL "??rT", ascii2ws
char16to8           SYMBOL "char16to8"
??char16to8??rT     SYMBOL "??rT", char16to8
char8to16           SYMBOL "char8to16"
??char8to16??rT     SYMBOL "??rT", char8to16
strcmp_nocase       SYMBOL "strcmp_nocase"
??strcmp_nocase??rT SYMBOL "??rT", strcmp_nocase
utf82win            SYMBOL "utf82win"
??utf82win??rT      SYMBOL "??rT", utf82win


        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock0 Using cfiCommon0
        CFI NoFunction
        THUMB
??strcmp_nocase??rT:
        BX       PC
        Nop      
        CFI EndBlock cfiBlock0
        REQUIRE strcmp_nocase
// D:\pasha\elf\evil_src\miosdel\miosd elka\string_works.c
//    1 #include "../inc/swilib.h"
//    2 //#include "string_works.h"
//    3 
//    4 #pragma inline=forced
//    5 int toupper(int c)
//    6 {
//    7   if ((c>='a')&&(c<='z')) c+='A'-'a';
//    8   return(c);
//    9 }
//   10 

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock1 Using cfiCommon1
        CFI Function strcmp_nocase
        ARM
//   11 int strcmp_nocase(const char *s1,const char *s2)
//   12 {
//   13   int i;
//   14   int c;
//   15   while(!(i=(c=toupper(*s1++))-toupper(*s2++))) if (!c) break;
strcmp_nocase:
??strcmp_nocase_0:
        LDRB     R2,[R0, #+0]
        CMP      R2,#+97
        BLT      ??strcmp_nocase_1
        CMP      R2,#+123
        SUBLT    R2,R2,#+32
??strcmp_nocase_1:
        LDRB     R12,[R1, #+0]
        ADD      R0,R0,#+1
        MOV      R3,R2
        CMP      R12,#+97
        BLT      ??strcmp_nocase_2
        CMP      R12,#+123
        SUBLT    R12,R12,#+32
??strcmp_nocase_2:
        ADD      R1,R1,#+1
        SUBS     R2,R2,R12
        BNE      ??strcmp_nocase_3
        CMP      R3,#+0
        BNE      ??strcmp_nocase_0
//   16   return(i);
??strcmp_nocase_3:
        MOV      R0,R2
        BX       LR               ;; return
        CFI EndBlock cfiBlock1
//   17 }

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock2 Using cfiCommon0
        CFI NoFunction
        THUMB
??MakeGlobalString??rT:
        BX       PC
        Nop      
        CFI EndBlock cfiBlock2
        REQUIRE MakeGlobalString
//   18 

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock3 Using cfiCommon1
        CFI Function MakeGlobalString
        ARM
//   19 char *MakeGlobalString(const char *first, int breakchar, const char *last)
//   20 {
MakeGlobalString:
        PUSH     {R4-R8,LR}
        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
        MOV      R4,R0
        MOV      R5,R1
        MOV      R6,R2
//   21   int l;
//   22   char *p;
//   23   p=malloc((l=strlen(first))+strlen(last)+2);
        SWI      +27
        MOV      R7,R0
        MOV      R0,R6
        SWI      +27
        ADD      R0,R0,R7
        ADD      R0,R0,#+2
        SWI      +20
        MOV      R8,R0
//   24   strcpy(p,first);
        MOV      R1,R4
        SWI      +26
//   25   if (first[strlen(first)-1]!=breakchar) p[l++]=breakchar;
        MOV      R0,R4
        SWI      +27
        ADD      R0,R0,R4
        LDRB     R0,[R0, #-1]
//   26   strcpy(p+l,last);
        MOV      R1,R6
        CMP      R0,R5
        STRBNE   R5,[R7, +R8]
        ADDNE    R7,R7,#+1
        ADD      R0,R7,R8
        SWI      +26
//   27   return p;
        MOV      R0,R8
        POP      {R4-R8,PC}       ;; return
        CFI EndBlock cfiBlock3
//   28 }

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock4 Using cfiCommon0
        CFI NoFunction
        THUMB
??char8to16??rT:
        BX       PC
        Nop      
        CFI EndBlock cfiBlock4
        REQUIRE char8to16
//   29 

        RSEG DATA_C:CONST:SORT:NOROOT(2)
//   30 const char wintranslation[128]=
//   31 {
//   32   0x5F,0x5F,0x27,0x5F,0x22,0x3A,0xC5,0xD8,0x5F,0x25,0x5F,0x3C,0x5F,0x5F,0x5F,0x5F,
//   33   0x5F,0x27,0x27,0x22,0x22,0x07,0x2D,0x2D,0x5F,0x54,0x5F,0x3E,0x5F,0x5F,0x5F,0x5F,
//   34   0xFF,0xF6,0xF7,0x5F,0xFD,0x83,0xB3,0x15,0xF0,0x63,0xF2,0x3C,0xBF,0x2D,0x52,0xF4,
//   35   0xF8,0x2B,'I' ,'i' ,0xA3,0xE7,0x14,0xFA,0xF1,0xFC,0xF3,0x3E,0x5F,0x5F,0x5F,0xF5,
//   36   0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
//   37   0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
//   38   0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
//   39   0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF
//   40 };
//   41 const unsigned short dos2unicode[128]=
dos2unicode:
        DATA
        DC16 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050
        DC16 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061
        DC16 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072
        DC16 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083
        DC16 1084, 1085, 1086, 1087, 45, 45, 45, 166, 43, 166, 166, 172, 172
        DC16 166, 166, 172, 45, 45, 45, 172, 76, 43, 84, 43, 45, 43, 166, 166
        DC16 76, 1075, 166, 84, 166, 61, 43, 166, 166, 84, 84, 76, 76, 45, 1075
        DC16 43, 43, 45, 45, 45, 45, 166, 166, 45, 1088, 1089, 1090, 1091, 1092
        DC16 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103
        DC16 1025, 1105, 1028, 1108, 1031, 1111, 1038, 1118, 176, 8226, 183
        DC16 118, 8470, 164, 166, 160
wintranslation:
        DC8 95, 95, 39, 95, 34, 58, 197, 216, 95, 37, 95, 60, 95, 95, 95, 95
        DC8 95, 39, 39, 34, 34, 7, 45, 45, 95, 84, 95, 62, 95, 95, 95, 95, 255
        DC8 246, 247, 95, 253, 131, 179, 21, 240, 99, 242, 60, 191, 45, 82, 244
        DC8 248, 43, 73, 105, 163, 231, 20, 250, 241, 252, 243, 62, 95, 95, 95
        DC8 245, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139
        DC8 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152
        DC8 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165
        DC8 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 224, 225, 226
        DC8 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239
//   42 {
//   43   0x0410,0x0411,0x0412,0x0413,0x0414,0x0415,0x0416,0x0417,
//   44   0x0418,0x0419,0x041A,0x041B,0x041C,0x041D,0x041E,0x041F,
//   45   0x0420,0x0421,0x0422,0x0423,0x0424,0x0425,0x0426,0x0427,
//   46   0x0428,0x0429,0x042A,0x042B,0x042C,0x042D,0x042E,0x042F,
//   47   0x0430,0x0431,0x0432,0x0433,0x0434,0x0435,0x0436,0x0437,
//   48   0x0438,0x0439,0x043A,0x043B,0x043C,0x043D,0x043E,0x043F,
//   49   0x002D,0x002D,0x002D,0x00A6,0x002B,0x00A6,0x00A6,0x00AC,
//   50   0x00AC,0x00A6,0x00A6,0x00AC,0x002D,0x002D,0x002D,0x00AC,
//   51   0x004C,0x002B,0x0054,0x002B,0x002D,0x002B,0x00A6,0x00A6,
//   52   0x004C,0x0433,0x00A6,0x0054,0x00A6,0x003D,0x002B,0x00A6,
//   53   0x00A6,0x0054,0x0054,0x004C,0x004C,0x002D,0x0433,0x002B,
//   54   0x002B,0x002D,0x002D,0x002D,0x002D,0x00A6,0x00A6,0x002D,
//   55   0x0440,0x0441,0x0442,0x0443,0x0444,0x0445,0x0446,0x0447,
//   56   0x0448,0x0449,0x044A,0x044B,0x044C,0x044D,0x044E,0x044F,
//   57   0x0401,0x0451,0x0404,0x0454,0x0407,0x0457,0x040E,0x045E,
//   58   0x00B0,0x2022,0x00B7,0x0076,0x2116,0x00A4,0x00A6,0x00A0
//   59 };
//   60 

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock5 Using cfiCommon1
        CFI Function char8to16
        ARM
//   61 unsigned int char8to16(int c)
//   62 {
//   63   if (c>=128)
char8to16:
        CMP      R0,#+128
        BXLT     LR
//   64   {
//   65     //Win->Dos
//   66     c=wintranslation[c-128];
        LDR      R1,??char8to16_0  ;; dos2unicode
        ADD      R0,R0,R1
        LDRB     R0,[R0, #+128]
//   67     if (c<128) return(c);
        CMP      R0,#+128
//   68     return(dos2unicode[c-128]);
        MVNGE    R2,#+255
        ADDGE    R0,R1,R0, LSL #+1
        LDRHGE   R0,[R2, +R0]
//   69   }
//   70   return(c);
        BX       LR               ;; return
        DATA
??char8to16_0:
        DC32     dos2unicode
        CFI EndBlock cfiBlock5
//   71 }

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock6 Using cfiCommon0
        CFI NoFunction
        THUMB
??ascii2ws??rT:
        BX       PC
        Nop      
        CFI EndBlock cfiBlock6
        REQUIRE ascii2ws
//   72 

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock7 Using cfiCommon1
        CFI Function ascii2ws
        ARM
//   73 void ascii2ws(WSHDR *ws, const char *s)
//   74 {
ascii2ws:
        PUSH     {R4,R5,LR}
        CFI ?RET Frame(CFA, -4)
        CFI R5 Frame(CFA, -8)
        CFI R4 Frame(CFA, -12)
        CFI CFA R13+12
        MOV      R4,R0
        MOV      R5,R1
//   75   char c;
//   76   CutWSTR(ws,0);
        MOV      R1,#+0
        SWI      +294
        B        ??ascii2ws_0
//   77   while((c=*s++))
//   78   {
//   79     wsAppendChar(ws,char8to16(c));
??ascii2ws_1:
        BL       char8to16
        MOV      R1,R0
        MOV      R0,R4
        SWI      +28
//   80   }
??ascii2ws_0:
        LDRB     R1,[R5], #+1
        MOVS     R0,R1
        BNE      ??ascii2ws_1
//   81 }
        POP      {R4,R5,PC}       ;; return
        CFI EndBlock cfiBlock7

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock8 Using cfiCommon0
        CFI NoFunction
        THUMB
??char16to8??rT:
        BX       PC
        Nop      
        CFI EndBlock cfiBlock8
        REQUIRE char16to8
//   82 

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock9 Using cfiCommon1
        CFI Function char16to8
        ARM
//   83 int char16to8(int c)
//   84 {
//   85   if (c<0x400) return (c);
char16to8:
        CMP      R0,#+1024
        BXLT     LR
//   86   c-=0x400;
        MVN      R1,#+255
        BIC      R1,R1,#0x300
        ADD      R0,R1,R0
//   87   if (c<16)
        CMP      R0,#+16
        BGE      ??char16to8_0
//   88   {
//   89     if (c==1) c=0;
        CMP      R0,#+1
        MOVEQ    R0,#+0
        BEQ      ??char16to8_1
//   90     else if (c==4) c=2;
        CMP      R0,#+4
        MOVEQ    R0,#+2
        BEQ      ??char16to8_1
//   91     else if (c==6) c=10;
        CMP      R0,#+6
        BXNE     LR
        MOV      R0,#+10
        B        ??char16to8_1
//   92     else return (c);
//   93   }
//   94   else if (c>79)
??char16to8_0:
        CMP      R0,#+80
        BLT      ??char16to8_2
//   95   {
//   96     if (c==0x51) c=16;
        CMP      R0,#+81
        MOVEQ    R0,#+16
        BEQ      ??char16to8_1
//   97     else if (c==0x54) c=18;
        CMP      R0,#+84
        MOVEQ    R0,#+18
        BEQ      ??char16to8_1
//   98     else if (c==0x56) c=11;
        CMP      R0,#+86
        MOVEQ    R0,#+11
        BEQ      ??char16to8_1
//   99     else if (c==0x57) c=23;
        CMP      R0,#+87
        BXNE     LR
        MOV      R0,#+23
??char16to8_1:
        ADD      R0,R0,#+168
        BX       LR
//  100     else return (c);
//  101   }
//  102   else c+=8;
??char16to8_2:
        ADD      R0,R0,#+8
//  103   c+=168;
//  104   return (c);
??char16to8_3:
        B        ??char16to8_1
        CFI EndBlock cfiBlock9
//  105 }

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock10 Using cfiCommon0
        CFI NoFunction
        THUMB
??utf82win??rT:
        BX       PC
        Nop      
        CFI EndBlock cfiBlock10
        REQUIRE utf82win
//  106 

        RSEG CODE:CODE:NOROOT(2)
        CFI Block cfiBlock11 Using cfiCommon1
        CFI Function utf82win
        ARM
//  107 void utf82win(char*d,const char *s)
//  108 {
utf82win:
        LDRB     R2,[R1, #+0]
        CMP      R2,#+0
        BEQ      ??utf82win_0
//  109   for (; *s; s+=2)
//  110   {
//  111     unsigned char ub = *s, lb = *(s+1);
??utf82win_1:
        LDRB     R2,[R1, #+0]
        LDRB     R3,[R1, #+1]
//  112     if (ub == 208)
        CMP      R2,#+208
        BNE      ??utf82win_2
//  113       if (lb != 0x81)
        CMP      R3,#+129
        MOVEQ    R2,#+168
//  114         {*d = lb + 48; d++;}
        ADDNE    R2,R3,#+48
??utf82win_3:
        STRB     R2,[R0], #+1
        B        ??utf82win_4
//  115       else
//  116         {*d = '¨'; d++;}
//  117 
//  118     if (ub == 209)
??utf82win_2:
        CMP      R2,#+209
        BNE      ??utf82win_5
//  119       if (lb != 0x91)
        CMP      R3,#+145
//  120         {*d = lb + 112; d++;}
        ADDNE    R2,R3,#+112
        STRBNE   R2,[R0], #+1
        BNE      ??utf82win_4
//  121       else
//  122         {*d = '¸'; d++;}
        MOV      R2,#+184
        B        ??utf82win_3
??utf82win_5:
        CMP      R3,#+91
        CMPNE    R3,#+81
//  123 
//  124     if ((ub != 208) && (ub != 209) && (lb != 91) && (lb != 81))
//  125     {
//  126       *d = ub;
        STRBNE   R2,[R0], #+1
//  127       d++;
//  128       s--;
        SUBNE    R1,R1,#+1
//  129     }
//  130   }
??utf82win_4:
        LDRB     R2,[R1, #+2]!
        CMP      R2,#+0
        BNE      ??utf82win_1
//  131   *d = 0;
??utf82win_0:
        MOV      R1,#+0
        STRB     R1,[R0, #+0]
//  132 }
        BX       LR               ;; return
        CFI EndBlock cfiBlock11

        END
// 
// 564 bytes in segment CODE
// 384 bytes in segment DATA_C
// 
// 540 bytes of CODE  memory (+ 24 bytes shared)
// 384 bytes of CONST memory
//
//Errors: none
//Warnings: none