Subversion Repositories Kolibri OS

Rev

Rev 5363 | Rev 6462 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;                                                              ;;
  3. ;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
  4. ;; Distributed under terms of the GNU General Public License    ;;
  5. ;;                                                              ;;
  6. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  7.  
  8. $Revision: 6262 $
  9.  
  10.  
  11. iglobal
  12. ; pointer to memory for path replace table,
  13. ; size of one record is 128 bytes: 64 bytes for search pattern + 64 bytes for replace string
  14.  
  15. ; start with one entry: sys -> <sysdir>
  16. full_file_name_table dd sysdir_name
  17. .size           dd      1
  18.  
  19. tmp_file_name_size dd   1
  20. endg
  21.  
  22. uglobal
  23. ; Parser_params will initialize: sysdir_name = "sys", sysdir_path = <sysdir>
  24. sysdir_name     rb      64
  25. sysdir_path     rb      64
  26. sysdir_name1    rb      64
  27. sysdir_path1    rb      64
  28.  
  29. ; for example:
  30. ;dir_name1      db 'KolibriOS',0
  31. ;               rb 64-8
  32. ;dir_path1      db 'HD0/1',0
  33. ;               rb 64-6
  34. endg
  35.  
  36. uglobal
  37. tmp_file_name_table dd  ?
  38. endg
  39.  
  40. ; use bx_from_load and init system directory /sys
  41. proc Parser_params
  42. locals
  43.   buff db 4 dup(?)              ; for test cd
  44. endl
  45.         mov     eax, [OS_BASE+0x10000+bx_from_load]
  46.         mov     ecx, sysdir_path
  47.         mov     [ecx-64], dword 'sys'
  48.         cmp     al, 'r'; if ram disk
  49.         jnz     @f
  50.         mov     [ecx], dword 'RD/?'
  51.         mov     [ecx+3], byte ah
  52.         mov     [ecx+4], byte 0
  53.         ret
  54. @@:
  55.         cmp     al, 'm'; if ram disk
  56.         jnz     @f
  57.         mov     [ecx], dword 'CD?/'; if cd disk {m}
  58.         mov     [ecx+4], byte '1'
  59.         mov     [ecx+5], dword '/KOL'
  60.         mov     [ecx+9], dword 'IBRI'
  61.         mov     [ecx+13], byte 0
  62. .next_cd:
  63.         mov     [ecx+2], byte ah
  64.         inc     ah
  65.         cmp     ah, '5'
  66.         je      .not_found_cd
  67.         lea     edx, [buff]
  68.         pushad
  69.         stdcall read_file, read_firstapp, edx, 0, 4
  70.         popad
  71.         cmp     [edx], dword 'MENU'
  72.         jne     .next_cd
  73.         jmp     .ok
  74.  
  75. @@:
  76.         sub     al, 49
  77.         mov     [ecx], dword 'HD?/'; if hard disk
  78.         mov     [ecx+2], byte al
  79.         mov     [ecx+4], byte ah
  80.         mov     [ecx+5], dword '/KOL'
  81.         mov     [ecx+9], dword 'IBRI'
  82.         mov     [ecx+13], byte 0
  83. .ok:
  84. .not_found_cd:
  85.         ret
  86. endp
  87.  
  88. proc load_file_parse_table
  89.         stdcall kernel_alloc, 0x1000
  90.         mov     [tmp_file_name_table], eax
  91.         mov     edi, eax
  92.         mov     esi, sysdir_name
  93.         mov     ecx, 128/4
  94.         rep movsd
  95.  
  96.         invoke  ini.enum_keys, conf_fname, conf_path_sect, get_every_key
  97.  
  98.         mov     eax, [tmp_file_name_table]
  99.         mov     [full_file_name_table], eax
  100.         mov     eax, [tmp_file_name_size]
  101.         mov     [full_file_name_table.size], eax
  102.         ret
  103. endp
  104.  
  105. uglobal
  106. def_val_1 db 0
  107. endg
  108.  
  109. proc get_every_key stdcall, f_name, sec_name, key_name
  110.         mov     esi, [key_name]
  111.         mov     ecx, esi
  112.         cmp     byte [esi], '/'
  113.         jnz     @f
  114.         inc     esi
  115. @@:
  116.         mov     edi, [tmp_file_name_size]
  117.         shl     edi, 7
  118.         cmp     edi, 0x1000
  119.         jae     .stop_parse
  120.         add     edi, [tmp_file_name_table]
  121.         lea     ebx, [edi+64]
  122. @@:
  123.         cmp     edi, ebx
  124.         jae     .skip_this_key
  125.         lodsb
  126.         test    al, al
  127.         jz      @f
  128.         or      al, 20h
  129.         stosb
  130.         jmp     @b
  131. @@:
  132.         stosb
  133.  
  134.         invoke  ini.get_str, [f_name], [sec_name], ecx, ebx, 64, def_val_1
  135.  
  136.         cmp     byte [ebx], '/'
  137.         jnz     @f
  138.         lea     esi, [ebx+1]
  139.         mov     edi, ebx
  140.         mov     ecx, 63
  141.         rep movsb
  142. @@:
  143.         push    ebp
  144.         mov     ebp, [tmp_file_name_table]
  145.         mov     ecx, [tmp_file_name_size]
  146.         jecxz   .noreplace
  147.         mov     eax, ecx
  148.         dec     eax
  149.         shl     eax, 7
  150.         add     ebp, eax
  151. .replace_loop:
  152.         mov     edi, ebx
  153.         mov     esi, ebp
  154. @@:
  155.         lodsb
  156.         test    al, al
  157.         jz      .doreplace
  158.         mov     dl, [edi]
  159.         inc     edi
  160.         test    dl, dl
  161.         jz      .replace_loop_cont
  162.         or      dl, 20h
  163.         cmp     al, dl
  164.         jz      @b
  165.         jmp     .replace_loop_cont
  166. .doreplace:
  167.         cmp     byte [edi], 0
  168.         jz      @f
  169.         cmp     byte [edi], '/'
  170.         jnz     .replace_loop_cont
  171. @@:
  172.         lea     esi, [ebp+64]
  173.         call    .replace
  174.         jc      .skip_this_key2
  175. .replace_loop_cont:
  176.         sub     ebp, 128
  177.         loop    .replace_loop
  178. .noreplace:
  179.         pop     ebp
  180.  
  181.         inc     [tmp_file_name_size]
  182. .skip_this_key:
  183.         xor     eax, eax
  184.         inc     eax
  185.         ret
  186. .skip_this_key2:
  187.         pop     ebp
  188.         jmp     .skip_this_key
  189. .stop_parse:
  190.         xor     eax, eax
  191.         ret
  192. endp
  193.  
  194. proc get_every_key.replace
  195. ; in: ebx->destination, esi->first part of name, edi->second part of name
  196. ; maximum length is 64 bytes
  197. ; out: CF=1 <=> overflow
  198. ; 1) allocate temporary buffer in stack
  199.         sub     esp, 64
  200. ; 2) save second part of name to temporary buffer
  201.         push    esi
  202.         lea     esi, [esp+4]    ; esi->tmp buffer
  203.         xchg    esi, edi        ; edi->tmp buffer, esi->source
  204. @@:
  205.         lodsb
  206.         stosb
  207.         test    al, al
  208.         jnz     @b
  209. ; 3) copy first part of name to destination
  210.         pop     esi
  211.         mov     edi, ebx
  212. @@:
  213.         lodsb
  214.         test    al, al
  215.         jz      @f
  216.         stosb
  217.         jmp     @b
  218. @@:
  219. ; 4) restore second part of name from temporary buffer to destination
  220. ; (may cause overflow)
  221.         lea     edx, [ebx+64]   ; limit of destination
  222.         mov     esi, esp
  223. @@:
  224.         cmp     edi, edx
  225.         jae     .overflow
  226.         lodsb
  227.         stosb
  228.         test    al, al
  229.         jnz     @b
  230. ; all is OK
  231.         add     esp, 64         ; CF is cleared
  232.         ret
  233. .overflow:
  234. ; name is too long
  235.         add     esp, 64
  236.         stc
  237.         ret
  238. endp
  239.  
  240.  
  241. char_todown:
  242. ; convert character in al to downcase, using cp866 encoding
  243.         cmp     al, 'A'
  244.         jb      .ret
  245.         cmp     al, 'Z'
  246.         jbe     .az
  247.         cmp     al, 0x80 ; 'А'
  248.         jb      .ret
  249.         cmp     al, 0x90 ; 'Р'
  250.         jb      .rus
  251.         cmp     al, 0xF0 ; 'Ё'
  252.         jz      .yo
  253.         cmp     al, 0x9F ; 'Я'
  254.         ja      .ret
  255. ; 0x90-0x9F -> 0xE0-0xEF
  256.         add     al, 0xE0-0x90
  257. .ret:
  258.         ret
  259.  
  260. .az:
  261. .rus:  ; 0x80-0x8F -> 0xA0-0xAF
  262.         add     al, 0x20
  263.         ret
  264.  
  265. .yo:
  266.         inc     al
  267.         ret
  268.  
  269.  
  270. char_toupper:
  271. ; convert character in al to uppercase, using cp866 encoding
  272.         cmp     al, 'a'
  273.         jb      .ret
  274.         cmp     al, 'z'
  275.         jbe     .az
  276.         cmp     al, 0xA0 ; 'а'
  277.         jb      .ret
  278.         cmp     al, 0xE0 ; 'р'
  279.         jb      .rus
  280.         cmp     al, 0xF1 ; 'ё'
  281.         jz      .yo
  282.         cmp     al, 0xEF ; 'я'
  283.         ja      .ret
  284. ; 0xE0-0xEF -> 0x90-0x9F
  285.         sub     al, 0xE0-0x90
  286. .ret:
  287.         ret
  288.  
  289. .az:
  290. .rus:  ; 0xA0-0xAF -> 0x80-0x8F
  291.         and     al, not 0x20
  292.         ret
  293.  
  294. .yo:
  295.         dec     al
  296.         ret
  297.  
  298.  
  299. uni2ansi_str:
  300. ; convert UNICODE zero-terminated string to ASCII-string (codepage 866)
  301. ; in: esi->source, edi->buffer (may be esi=edi)
  302. ; destroys: eax,esi,edi
  303.         lodsw
  304.         call    uni2ansi_char
  305.         stosb
  306.         test    al, al
  307.         jnz     uni2ansi_str
  308.         ret
  309.  
  310.  
  311. uni2ansi_char:
  312. ; convert UNICODE character in ax to ANSI character in al using cp866 encoding
  313.         cmp     ax, 0x80
  314.         jb      .ret
  315.         cmp     ax, 0xB6
  316.         jz      .B6
  317.         cmp     ax, 0x400
  318.         jb      .unk
  319.         cmp     ax, 0x410
  320.         jb      @f
  321.         cmp     ax, 0x440
  322.         jb      .rus1
  323.         cmp     ax, 0x450
  324.         jb      .rus2
  325.         cmp     ax, 0x460
  326.         jb      @f
  327. .unk:
  328.         mov     al, '_'
  329. .ret:
  330.         ret
  331.  
  332. .B6:
  333.         mov     al, 20
  334.         ret
  335.  
  336. .rus1:  ; 0x410-0x43F -> 0x80-0xAF
  337.         add     al, 0x70
  338.         ret
  339.  
  340. .rus2:  ; 0x440-0x44F -> 0xE0-0xEF
  341.         add     al, 0xA0
  342.         ret
  343.  
  344. @@:
  345.         push    ecx edi
  346.         mov     ecx, 8
  347.         mov     edi, .table
  348.         repnz scasb
  349.         mov     ah, cl
  350.         pop     edi ecx
  351.         jnz     .unk
  352.         mov     al, 0xF7
  353.         sub     al, ah
  354.         ret
  355.  
  356. .table  db  1, 51h, 4, 54h, 7, 57h, 0Eh, 5Eh
  357.  
  358.  
  359. ansi2uni_char:
  360. ; convert ANSI character in al to UNICODE character in ax, using cp866 encoding
  361.         movzx   eax, al
  362.         cmp     al, 0x80
  363.         jb      @f      ; 0x00-0x7F - trivial map
  364.         cmp     al, 0xB0
  365.         jb      .rus    ; 0x80-0xAF -> 0x410-0x43F
  366.         cmp     al, 0xE0
  367.         jb      .unk
  368.         cmp     al, 0xF0
  369.         jb      .rus2   ; 0xE0-0xEF -> 0x440-0x44F
  370.         cmp     al, 0xF8
  371.         jnc     .unk
  372.         mov     al, [eax+uni2ansi_char.table-0xF0]
  373.         add     ax, 400h
  374.         ret
  375.  
  376. @@:
  377.         cmp     al, 20
  378.         jnz     .ret
  379.         mov     al, 0xB6
  380. .ret:
  381.         ret
  382.  
  383. .rus:
  384.         add     ax, 0x410-0x80
  385.         ret
  386.  
  387. .rus2:
  388.         add     ax, 0x440-0xE0
  389.         ret
  390.  
  391. .unk:
  392.         mov     al, '_'
  393.         ret
  394.