##############################################################################
#                                                                            #
# IAR ARM ANSI C/C++ Compiler V4.42A/W32 EVALUATION    31/Mar/2008  11:28:31 #
# Copyright 1999-2005 IAR Systems. All rights reserved.                      #
#                                                                            #
#    Cpu mode        =  interwork                                            #
#    Endian          =  little                                               #
#    Stack alignment =  4                                                    #
#    Source file     =  D:\Pasha\elf\_MY_PROJECT_\naticq_mod\conf_loader.c   #
#    Command line    =  D:\Pasha\elf\_MY_PROJECT_\naticq_mod\conf_loader.c   #
#                       -D NEWSGOLD -D ELKA -D UIN_WRITE -D kluchnik -D      #
#                       BCFGGEN --preprocess D:\Pasha\elf\_MY_PROJECT_\natic #
#                       q_mod\kluch_BCFGGEN\List\ -lC                        #
#                       D:\Pasha\elf\_MY_PROJECT_\naticq_mod\kluch_BCFGGEN\L #
#                       ist\ -o D:\Pasha\elf\_MY_PROJECT_\naticq_mod\kluch_B #
#                       CFGGEN\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\_MY_PROJECT_\naticq_mod\kluch_BCFGGEN\L #
#                       ist\conf_loader.lst                                  #
#    Object file     =  D:\Pasha\elf\_MY_PROJECT_\naticq_mod\kluch_BCFGGEN\O #
#                       bj\conf_loader.r79                                   #
#                                                                            #
#                                                                            #
##############################################################################

D:\Pasha\elf\_MY_PROJECT_\naticq_mod\conf_loader.c
      1          #include "..\inc\swilib.h"
      2          #include "..\inc\cfg_items.h"
      3          #include "conf_loader.h"
      4          

   \                                 In segment DATA_I, align 4, align-sorted
      5          const char *successed_config_filename="";
   \                     successed_config_filename:
   \   00000000                      DS8 4
   \   00000004                      REQUIRE `?<Initializer for successed_config_filename>`
      6          
      7          
      8          
      9          
     10          #pragma segment="CONFIG_C"

   \                                 In segment CODE, align 4, keep-with-next
     11          int SaveConfigData(const char *fname)
     12          {
     13            int f;
     14            unsigned int ul;
     15            int result=-1;
     16            unsigned int wlen;
     17            unsigned int len=(char *)__segment_end("CONFIG_C")-(char *)__segment_begin("CONFIG_C");
   \                     SaveConfigData:
   \   00000000   60109FE5           LDR      R1,??SaveConfigData_0  ;; SFE(CONFIG_C)
   \   00000004   F0402DE9           PUSH     {R4-R7,LR}
   \   00000008   5C509FE5           LDR      R5,??SaveConfigData_0+0x4  ;; SFB(CONFIG_C)
   \   0000000C   04D04DE2           SUB      SP,SP,#+4
   \   00000010   0040E0E3           MVN      R4,#+0
   \   00000014   056041E0           SUB      R6,R1,R5
     18          
     19            if ((f=fopen(fname,A_WriteOnly+A_BIN+A_Create+A_Truncate,P_WRITE,&ul))!=-1)
   \   00000018   0D30A0E1           MOV      R3,SP
   \   0000001C   402FA0E3           MOV      R2,#+256
   \   00000020   0110A0E3           MOV      R1,#+1
   \   00000024   831C81E3           ORR      R1,R1,#0x8300
   \   00000028   0A0000EF           SWI      +10
   \   0000002C   0070A0E1           MOV      R7,R0
   \   00000030   010077E3           CMN      R7,#+1
   \   00000034   0900000A           BEQ      ??SaveConfigData_1
     20            {
     21              wlen=fwrite(f,__segment_begin("CONFIG_C"),len,&ul);
   \   00000038   0D30A0E1           MOV      R3,SP
   \   0000003C   0620A0E1           MOV      R2,R6
   \   00000040   0510A0E1           MOV      R1,R5
   \   00000044   0C0000EF           SWI      +12
   \   00000048   0050A0E1           MOV      R5,R0
     22              fclose(f,&ul);
   \   0000004C   0D10A0E1           MOV      R1,SP
   \   00000050   0700A0E1           MOV      R0,R7
   \   00000054   0D0000EF           SWI      +13
     23              if (wlen==len) result=0;
   \   00000058   060055E1           CMP      R5,R6
   \   0000005C   0040A003           MOVEQ    R4,#+0
     24            }
     25            return(result);
   \                     ??SaveConfigData_1:
   \   00000060   0400A0E1           MOV      R0,R4
   \   00000064   F280BDE8           POP      {R1,R4-R7,PC}    ;; return
   \                     ??SaveConfigData_0:
   \   00000068   ........           DC32     SFE(CONFIG_C)
   \   0000006C   ........           DC32     SFB(CONFIG_C)
     26          }
     27          
     28          /*
     29          #pragma segment="CONFIG_C"
     30          int LoadConfigData(const char *fname)
     31          {
     32            int f;
     33            unsigned int ul;
     34            char *buf;
     35            int result=0;
     36            void *cfg;
     37            unsigned int rlen, end;
     38          
     39            extern const CFG_HDR cfghdr0; //first var in CONFIG
     40            cfg=(void*)&cfghdr0;
     41          
     42            unsigned int len=(int)__segment_end("CONFIG_C")-(int)__segment_begin("CONFIG_C");
     43          
     44            if (!(buf=malloc(len))) return -1;
     45            if ((f=fopen(fname,A_ReadOnly+A_BIN,P_READ,&ul))!=-1)
     46            {
     47              rlen=fread(f,buf,len,&ul);
     48              end=lseek(f,0,S_END,&ul,&ul);
     49              fclose(f,&ul);
     50              if (rlen!=end || rlen!=len)  goto L_SAVENEWCFG;
     51              memcpy(cfg,buf,len);
     52            }
     53            else
     54            {
     55            L_SAVENEWCFG:
     56              result=SaveConfigData(fname);
     57            }
     58            mfree(buf);
     59            if (result>=0) successed_config_filename=fname;
     60            return(result);
     61          }
     62          
     63          void InitConfig()
     64          {
     65          #ifdef kluchnik2
     66            if (LoadConfigData("4:\\ZBin\\etc\\NATICQMod3.bcfg")<0)
     67            {
     68              LoadConfigData("0:\\ZBin\\etc\\NATICQMod3.bcfg");
     69            }
     70          #else
     71          #ifdef kluchnik
     72            if (LoadConfigData("4:\\ZBin\\etc\\NATICQMod2.bcfg")<0)
     73            {
     74              LoadConfigData("0:\\ZBin\\etc\\NATICQMod2.bcfg");
     75            }
     76          #else
     77            if (LoadConfigData("4:\\ZBin\\etc\\NATICQMod.bcfg")<0)
     78            {
     79              LoadConfigData("0:\\ZBin\\etc\\NATICQMod.bcfg");
     80            }
     81          #endif
     82          #endif
     83          }
     84          */

   \                                 In segment CODE, align 4, keep-with-next
     85          int LoadConfigData(const char *fname, void* cfg, int len)
     86          {
   \                     LoadConfigData:
   \   00000000   F0412DE9           PUSH     {R4-R8,LR}
   \   00000004   04D04DE2           SUB      SP,SP,#+4
   \   00000008   0040A0E1           MOV      R4,R0
   \   0000000C   0150A0E1           MOV      R5,R1
   \   00000010   0260A0E1           MOV      R6,R2
     87            int f;
     88            unsigned int ul;
     89            int result=-1;
   \   00000014   0070E0E3           MVN      R7,#+0
     90            
     91            if ((f=fopen(fname,A_ReadOnly+A_BIN,P_READ,&ul))!=-1)
   \   00000018   0D30A0E1           MOV      R3,SP
   \   0000001C   8020A0E3           MOV      R2,#+128
   \   00000020   801CA0E3           MOV      R1,#+32768
   \   00000024   0A0000EF           SWI      +10
   \   00000028   0080A0E1           MOV      R8,R0
   \   0000002C   070058E1           CMP      R8,R7
   \   00000030   0C00000A           BEQ      ??LoadConfigData_0
     92            {
     93              if (fread(f,cfg,len,&ul)==len)
   \   00000034   0D30A0E1           MOV      R3,SP
   \   00000038   0620A0E1           MOV      R2,R6
   \   0000003C   0510A0E1           MOV      R1,R5
   \   00000040   0B0000EF           SWI      +11
   \   00000044   060050E1           CMP      R0,R6
   \   00000048   0D10A0E1           MOV      R1,SP
   \   0000004C   0800A0E1           MOV      R0,R8
   \   00000050   0300001A           BNE      ??LoadConfigData_1
     94              {
     95                fclose(f,&ul);
   \   00000054   0D0000EF           SWI      +13
     96                result = 0;
   \   00000058   0070A0E3           MOV      R7,#+0
   \   0000005C   0700A0E1           MOV      R0,R7
   \   00000060   F281BDE8           POP      {R1,R4-R8,PC}
     97              }
     98              else
     99              {
    100                fclose(f,&ul);
   \                     ??LoadConfigData_1:
   \   00000064   0D0000EF           SWI      +13
    101              }
    102            }
    103          #ifdef BCFGGEN
    104            if (result == -1)
    105            {
    106              extern const CFG_HDR cfghdr0; //first var in CONFIG
    107              void* bcfg=(void*)&cfghdr0;
    108              unsigned int lenbcfg=(int)__segment_end("CONFIG_C")-(int)__segment_begin("CONFIG_C");
    109              if ((f=fopen(fname,A_ReadWrite+A_Create+A_Truncate,P_READ+P_WRITE,&ul))!=-1)
   \                     ??LoadConfigData_0:
   \   00000068   0D30A0E1           MOV      R3,SP
   \   0000006C   602FA0E3           MOV      R2,#+384
   \   00000070   0210A0E3           MOV      R1,#+2
   \   00000074   C01F81E3           ORR      R1,R1,#0x300
   \   00000078   0400A0E1           MOV      R0,R4
   \   0000007C   0A0000EF           SWI      +10
   \   00000080   0080A0E1           MOV      R8,R0
   \   00000084   070058E1           CMP      R8,R7
   \   00000088   0E00000A           BEQ      ??LoadConfigData_2
    110              {
    111                if (fwrite(f,bcfg,lenbcfg,&ul)==len)
   \   0000008C   3C409FE5           LDR      R4,??LoadConfigData_3  ;; cfghdr0
   \   00000090   3C209FE5           LDR      R2,??LoadConfigData_3+0x4  ;; SFE(CONFIG_C) - SFB(CONFIG_C)
   \   00000094   0D30A0E1           MOV      R3,SP
   \   00000098   0410A0E1           MOV      R1,R4
   \   0000009C   0C0000EF           SWI      +12
   \   000000A0   060050E1           CMP      R0,R6
   \   000000A4   0400001A           BNE      ??LoadConfigData_4
    112                {
    113                  memcpy(cfg,bcfg,len);
   \   000000A8   0620A0E1           MOV      R2,R6
   \   000000AC   0410A0E1           MOV      R1,R4
   \   000000B0   0500A0E1           MOV      R0,R5
   \   000000B4   1E0100EF           SWI      +286
    114                  result=0;
   \   000000B8   0070A0E3           MOV      R7,#+0
    115                }
    116                fclose(f,&ul);
   \                     ??LoadConfigData_4:
   \   000000BC   0D10A0E1           MOV      R1,SP
   \   000000C0   0800A0E1           MOV      R0,R8
   \   000000C4   0D0000EF           SWI      +13
    117              }
    118            }
    119          #endif
    120            return(result);
   \                     ??LoadConfigData_2:
   \   000000C8   0700A0E1           MOV      R0,R7
   \   000000CC   F281BDE8           POP      {R1,R4-R8,PC}
   \                     ??LoadConfigData_3:
   \   000000D0   ........           DC32     cfghdr0
   \   000000D4   ........           DC32     SFE(CONFIG_C) - SFB(CONFIG_C)
    121          }
    122          
    123          

   \                                 In segment DATA_I, align 4, align-sorted
    124          char *config_path=":\\zbin\\etc";
   \                     config_path:
   \   00000000                      DS8 4
   \   00000004                      REQUIRE `?<Initializer for config_path>`

   \                                 In segment CODE, align 4, keep-with-next
    125          int InitConfig(void* cfgstruct, int len, char *name,int disk)
    126          {
   \                     InitConfig:
   \   00000000   30402DE9           PUSH     {R4,R5,LR}
   \   00000004   80D04DE2           SUB      SP,SP,#+128
    127            int result;
    128            char config_name[128];
    129            sprintf(config_name, "%d%s\\%s.bcfg", disk, config_path,name);
   \   00000008   04002DE9           PUSH     {R2}
   \   0000000C   0150A0E1           MOV      R5,R1
   \   00000010   30109FE5           LDR      R1,??InitConfig_0  ;; config_path
   \   00000014   0040A0E1           MOV      R4,R0
   \   00000018   0300A0E1           MOV      R0,R3
   \   0000001C   003091E5           LDR      R3,[R1, #+0]
   \   00000020   24109FE5           LDR      R1,??InitConfig_0+0x4  ;; `?<Constant "%d%s\\\\%s.bcfg">`
   \   00000024   0020A0E1           MOV      R2,R0
   \   00000028   04008DE2           ADD      R0,SP,#+4
   \   0000002C   160000EF           SWI      +22
    130            result = LoadConfigData(config_name,  cfgstruct, len);
    131            return result;
   \   00000030   0520A0E1           MOV      R2,R5
   \   00000034   0410A0E1           MOV      R1,R4
   \   00000038   04008DE2           ADD      R0,SP,#+4
   \   0000003C   ........           BL       LoadConfigData
   \   00000040   84D08DE2           ADD      SP,SP,#+132
   \   00000044   3080BDE8           POP      {R4,R5,PC}       ;; return
   \                     ??InitConfig_0:
   \   00000048   ........           DC32     config_path
   \   0000004C   ........           DC32     `?<Constant "%d%s\\\\%s.bcfg">`
    132          }

   \                                 In segment DATA_ID, align 4, align-sorted
   \                     `?<Initializer for successed_config_filename>`:
   \   00000000   ........           DC32 `?<Constant "">`

   \                                 In segment DATA_ID, align 4, align-sorted
   \                     `?<Initializer for config_path>`:
   \   00000000   ........           DC32 `?<Constant ":\\\\zbin\\\\etc">`

   \                                 In segment CONFIG_C, align 1

   \                                 In segment DATA_C, align 1, align-sorted
   \                     `?<Constant "">`:
   \   00000000   00                 DC8 ""

   \                                 In segment DATA_C, align 4, align-sorted
   \                     `?<Constant ":\\\\zbin\\\\etc">`:
   \   00000000   3A5C7A62696E       DC8 ":\\zbin\\etc"
   \              5C65746300  
   \   0000000B   00                 DC8 0

   \                                 In segment DATA_C, align 4, align-sorted
   \                     `?<Constant "%d%s\\\\%s.bcfg">`:
   \   00000000   256425735C25       DC8 "%d%s\\%s.bcfg"
   \              732E62636667
   \              00          
   \   0000000D   000000             DC8 0, 0, 0

   Maximum stack usage in bytes:

     Function       CSTACK
     --------       ------
     InitConfig       144
     LoadConfigData    32
     SaveConfigData    24


   Segment part sizes:

     Function/Label                 Bytes
     --------------                 -----
     successed_config_filename         4
     SaveConfigData                  112
     LoadConfigData                  216
     config_path                       4
     InitConfig                       80
     ?<Initializer for successed_config_filename>
                                       4
     ?<Initializer for config_path>    4
     ?<Constant "">                    1
     ?<Constant ":\\zbin\\etc">       12
     ?<Constant "%d%s\\%s.bcfg">      16
      Others                          24

 
 420 bytes in segment CODE
  29 bytes in segment DATA_C
   8 bytes in segment DATA_I
   8 bytes in segment DATA_ID
  12 bytes in segment INITTAB
 
 408 bytes of CODE  memory (+ 24 bytes shared)
  37 bytes of CONST memory
   8 bytes of DATA  memory

Errors: none
Warnings: none