1 /******************************************************************************
2 *
3 * Copyright (C) 2006, The Gentee Group. All rights reserved.
4 * This file is part of the Gentee open source project - http://www.gentee.com.
5 *
6 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE GENTEE LICENSE ("AGREEMENT").
7 * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE CONSTITUTES RECIPIENTS
8 * ACCEPTANCE OF THE AGREEMENT.
9 *
10 * ID: defines 18.10.06 0.0.A.
11 *
12 * Author: Alexey Krivonogov
13 *
14 * Summary: This file provides Windows basic types and some constants.
15 *
16 ******************************************************************************/
17
18 #include "defines.h"
19 #include "../../genteeapi/gentee.h"
20 #ifdef LINUX
21 #include <unistd.h>
22 #include <fcntl.h>
23 #include <stdarg.h>
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #include <sys/times.h>
27 #include <dirent.h>
28 #include <pthread.h>
29 #include <stdio.h>
30 //#include <wvstreams/wvstrutils.h>
31 #include <string.h>
32 #include <errno.h>
33 #else
34 #include "shlobj.h"
35 #endif
36
37 #ifdef WINDOWS
38 pvoid _stdout = INVALID_HANDLE_VALUE;
39 pvoid _stdin = INVALID_HANDLE_VALUE;
40 #endif
41
42 /*-----------------------------------------------------------------------------
43 *
44 * ID: os_dircreate 14.12.07
45 *
46 * Summary: Create the directory
47 *
48 -----------------------------------------------------------------------------*/
49
50 uint STDCALL os_dircreate( pstr name )
51 {
52 #ifdef LINUX
53 return mkdir(str_ptr( name ),700);
54 #else
55 return CreateDirectory( str_ptr( name ), NULL );
56 #endif
57 }
58
59 /*-----------------------------------------------------------------------------
60 *
61 * ID: os_dirdelete 14.12.07
62 *
63 * Summary: Delete the empty directory
64 *
65 -----------------------------------------------------------------------------*/
66
67 uint STDCALL os_dirdelete( pstr name )
68 {
69 #ifdef LINUX
70 return rmdir(str_ptr( name ));
71 #else
72 return RemoveDirectory( str_ptr( name ));
73 #endif
74 }
75
76 /*-----------------------------------------------------------------------------
77 *
78 * ID: os_dirgetcur 14.12.07
79 *
80 * Summary: Get the current directory
81 *
82 -----------------------------------------------------------------------------*/
83
84 pstr STDCALL os_dirgetcur( pstr name )
85 {
86 #ifdef LINUX
87 return str_setlen( name,getcwd( str_ptr( name), 512 ));
88 #else
89 return str_setlen( name, GetCurrentDirectory( 512,str_ptr( str_reserve( name, 512 ))));
90 #endif
91 }
92
93 /*-----------------------------------------------------------------------------
94 *
95 * ID: os_dirsetcur 14.12.07
96 *
97 * Summary: Set the current directory
98 *
99 -----------------------------------------------------------------------------*/
100
101 uint STDCALL os_dirsetcur( pstr name )
102 {
103 #ifdef LINUX
104 return chdir( str_ptr( name));
105 #else
106 return SetCurrentDirectory( str_ptr( name ));
107 #endif
108 }
109
110 /*-----------------------------------------------------------------------------
111 *
112 * ID: os_dirdeletefull 14.12.07
113 *
114 * Summary: Delete the directory with subfolders and files
115 *
116 -----------------------------------------------------------------------------*/
117
118 uint STDCALL os_dirdeletefull( pstr name )
119 {
120 #ifdef WINDOWS
121 str stemp;
122 WIN32_FIND_DATA data;
123 pvoid find;
124
125 str_init( &stemp );
126 str_printf( &stemp, "%s%c*.*", str_ptr( name ), SLASH );
127 find = FindFirstFile( str_ptr( &stemp ), &data );
128 if ( find != INVALID_HANDLE_VALUE )
129 {
130 do {
131 if ( data.cFileName[0] == '.' && ( !data.cFileName[1] ||
132 ( data.cFileName[1] == '.' && !data.cFileName[2] )))
133 continue;
134
135 str_printf( &stemp, "%s%c%s", str_ptr( name ), SLASH, data.cFileName );
136
137 if ( data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
138 os_dirdeletefull( &stemp );
139 else
140 os_filedelete( &stemp );
141
142 } while ( FindNextFile( find, &data ));
143
144 FindClose( find );
145 }
146 str_delete( &stemp );
147 #endif
148 return os_dirdelete( name );
149 }
150
151 /*-----------------------------------------------------------------------------
152 *
153 * ID: os_fileclose 14.12.07
154 *
155 * Summary: Close the file
156 *
157 -----------------------------------------------------------------------------*/
158
159 uint STDCALL os_fileclose( uint handle )
160 {
161 #ifdef LINUX
162 return close((handle ));
163 #else
164 return CloseHandle(( pvoid )handle );
165 #endif
166 }
167
168 /*-----------------------------------------------------------------------------
169 *
170 * ID: os_filefullname 14.12.07
171 *
172 * Summary: Get the full name of the file
173 *
174 -----------------------------------------------------------------------------*/
175 /*
176 pstr STDCALL os_filefullname( pstr filename, pstr result )
177 {
178
179 str_reserve( result, 512 );
180 //if ( ichar != SLASH )
181 //printf("ddddddddddd");
182 //result = "DEMO";
183 //str_copy(result, "DEMO");
184 //return result;
185 //if ( str_findch(filename,SLASH) != 0 )
186 pubyte dddd = (pubyte)filename;
187 if ( dddd[0] == '/' )
188 {
189 char cur[512];
190 getcwd( cur, 512 );
191 chdir( filename );
192 basename( filename );
193 getcwd( str_ptr( result ), 512 );
194 uint iDov = str_len( result );
195 //str_setlen(result, strlen( str_ptr( result ) ) );
196 str_setlen(result, strlen( (pubyte) result ) );
197 str_add( result, "/" );
198 str_add( result, filename );
199 chdir( cur );
200 }
201 else
202 { //Œ®¦¥â à  ¡®â âì В¥ª®à à ¥ªâВВ® ¥á«¨ Вў  ¡á®«îâВ®¬ ВЇГЈГўВЁ ¢áâà ¥ç îâáï '.' '..'
203 str_copy( result, filename );
204 }
205 return result;
206
207 }
208 */
209
210 pvoid STDCALL os_filefullname( pubyte filename, pvoid buf )
211 {
212 pubyte ptr;
213
214 #ifdef LINUX
215
216 char cur[512];
217 if ( filename[0] != '/' )
218 {
219 getcwd( cur, 512 );
220 chdir( filename );
221 basename( filename );
222 getcwd( str_ptr( ( pstr )buf ), 512 );
223 str_setlen( ( pstr )buf, strlen( str_ptr( ( pstr )buf ) ) );
224 str_appendb( buf, '/' );
225 str_appendp( buf, filename );
226 chdir( cur );
227 }
228 else
229 { //Ìîæåò ðà áîòà òü ГåêîððåêòГГ® åñëè Гў à áñîëþòГîì ГЇГіГІГЁ âñòðå÷à þòñÿ '.' '..'
230 str_appendp( buf, filename );
231 }
232 #else
233 DWORD temp;
234 temp = GetFullPathName( filename, 512, str_ptr( ( pstr )buf ), &ptr );
235 // äëÿ Windows
236 CharLowerBuff( str_ptr( ( pstr )buf ), temp );
237 str_setlen( ( pstr )buf, temp );
238 #endif
239 return buf;
240 }
241
242
243
244 /*-----------------------------------------------------------------------------
245 *
246 * ID: os_filedelete 14.12.07 .
247 *
248 * Summary: Delete the file
249 *
250 -----------------------------------------------------------------------------*/
251
252 uint STDCALL os_filedelete( pstr name )
253 {
254 #ifdef LINUX
255 return remove(str_ptr(name));
256 #else
257 return DeleteFile( str_ptr( name ));
258 #endif
259 }
260
261 uint STDCALL os_fileopen( pstr name, uint flag )
262 {
263 #ifdef LINUX
264 int fd;
265 fd = open( name, ( flag & FOP_READONLY ? O_RDONLY : O_RDWR ) |
266 ( flag & FOP_CREATE ? O_CREAT : 0 ) |
267 ( flag & FOP_IFCREATE ? O_TRUNC : 0 ), S_IRWXU );
268 if ( fd != -1 && flag & FOP_EXCLUSIVE )
269 {
270 if ( flock( fd, LOCK_EX ) == -1 )
271 {
272 close( fd );
273 fd = -1;
274 }
275 }
276 return fd;
277 #else
278 uint ret;
279
280 ret = ( uint )CreateFile( str_ptr( name ), ( flag & FOP_READONLY ? GENERIC_READ :
281 GENERIC_READ | GENERIC_WRITE ), ( flag & FOP_EXCLUSIVE ? 0 :
282 FILE_SHARE_READ | FILE_SHARE_WRITE ), NULL,
283 ( flag & FOP_CREATE ? CREATE_ALWAYS :
284 ( flag & FOP_IFCREATE ? OPEN_ALWAYS : OPEN_EXISTING )),
285 /*FILE_FLAG_WRITE_THROUGH*/ 0, NULL );
286 //printf("Name=%s %i\n", str_ptr( name ), ret );
287 return ret == ( uint )INVALID_HANDLE_VALUE ? 0 : ret ;
288 #endif
289
290 }
291
292 ulong64 STDCALL os_filepos( uint handle, long64 offset, uint mode )
293 {
294
295 #ifdef LINUX
296 int newset;
297 newset = lseek( handle, offset, ( mode == FSET_BEGIN ?
298 SEEK_SET : ( mode == FSET_CURRENT ? SEEK_CUR : SEEK_END )));
299 if ( newset == offset - 1 )
300 return -1;
301 return newset;
302 #else
303 LARGE_INTEGER li;
304
305 li.QuadPart = offset;
306
307 li.LowPart = SetFilePointer( ( pvoid )handle, li.LowPart, &li.HighPart,
308 ( mode == FSET_BEGIN ?
309 FILE_BEGIN : ( mode == FSET_CURRENT ? FILE_CURRENT : FILE_END )));
310 if ( li.LowPart == MAX_UINT && GetLastError() != NO_ERROR )
311 return -1L;
312 return li.QuadPart;
313 #endif
314 }
315
316 uint STDCALL os_fileread( uint handle, pubyte data, uint size )
317 {
318 #ifdef LINUX
319 uint cntread;
320 cntread = read( handle, data, size );
321 if ( cntread == -1 || cntread != size )
322 return FALSE;
323 return TRUE;
324 #else
325 uint read;
326 if ( !ReadFile( (pvoid)handle, data, size, &read, NULL ) || read != size )
327 return FALSE;
328 return read;
329 #endif
330 }
331
332 ulong64 STDCALL os_filesize( uint handle )
333 {
334 #ifdef LINUX
335 long size, curoff;
336 curoff = lseek( handle, 0, SEEK_CUR );
337 size = lseek( handle, 0, SEEK_END );
338 lseek( handle, curoff, SEEK_SET );
339 return size;
340 #else
341 LARGE_INTEGER li;
342 li.LowPart = GetFileSize( ( pvoid )handle, &li.HighPart );
343 if ( li.LowPart == INVALID_FILE_SIZE && GetLastError() != NO_ERROR )
344 return -1L;
345 return li.QuadPart;
346 #endif
347 }
348
349 //--------------------------------------------------------------------------
350
351 uint STDCALL os_filewrite( uint handle, pubyte data, uint size )
352 {
353 #ifdef LINUX
354 uint cntwrite;
355 cntwrite = write( handle, data, size );
356 if ( cntwrite == -1 || cntwrite != size )
357 return FALSE;
358 return TRUE;
359 #else
360 uint write;
361 if ( !WriteFile( ( pvoid )handle, data, size, &write, NULL ) || write != size )
362 return FALSE;
363 return write;
364 #endif
365 }
366
367 /*-----------------------------------------------------------------------------
368 *
369 * ID: os_fileexist 14.12.07 .
370 *
371 * Summary: If the file or directory exists
372 *
373 -----------------------------------------------------------------------------*/
374
375 uint STDCALL os_fileexist( pstr name )
376 {
377 return os_getattrib( name ) != 0xFFFFFFFF ? 1 : 0;
378 }
379
380 /*-----------------------------------------------------------------------------
381 *
382 * ID: os_getattrib 14.12.07 .
383 *
384 * Summary: Get the file or directory attrbutes
385 *
386 -----------------------------------------------------------------------------*/
387
388 uint STDCALL os_getattrib( pstr name )
389 {
390 #ifdef LINUX
391 struct stat statbuf;
392 stat(str_ptr(name),&statbuf);
393 return statbuf.st_mode;
394 #else
395 return GetFileAttributes( str_ptr( name ));
396 #endif
397
398 }
399
400 /*-----------------------------------------------------------------------------
401 *
402 * ID: os_tempdir 14.12.07 .
403 *
404 * Summary: Get the temp dir
405 *
406 -----------------------------------------------------------------------------*/
407
408 pstr STDCALL os_tempdir( pstr name )
409 {
410 #ifdef LINUX
411 pstr stemp = os_gettemp();
412 uint uLenTempStr = str_len(stemp);
413 str_copy(name,stemp);
414 #else
415 str_setlen( name, GetTempPath( 1024, str_reserve( name, 1024 )->data ));
416 #endif
417 return str_trim( name, SLASH, TRIM_ONE | TRIM_RIGHT );
418 }
419
420 pstr STDCALL os_gettemp( void )
421 {
422 uint diskc = 0;
423 pstr temp;
424 pstr ret;
425 // ubyte temp[ 512 ];
426 // ubyte stemp[ 512 ];
427
428 // str_lenset( dir, 0 );
429 // str_isfree( dir, 512 );
430 /*#ifdef LINUX
431 if ( !ggentee.tempfile )
432 {
433 while( 1 )
434 {
435 wsprintf( stemp, "/temp/gentee%02X.tmp", ggentee.tempid );
436 ggentee.tempfile = file_open( stemp, FOP_CREATE | FOP_EXCLUSIVE );
437 if ( ggentee.tempfile = -1 )
438 ggentee.tempid++;
439 else
440 break;
441 }
442 stemp[ mem_len( stemp ) - 4 ] = 0;
443 // wsprintf( stemp, "%s\\gentee%02X", temp, ggentee.tempid );
444 mkdir( stemp, 700 );
445 ggentee.tempdir = str_new( 0, stemp );
446 }
447 // str_appendp( dir, str_ptr( ggentee.tempdir ));
448 #else*/
449 if ( !_gentee.tempfile )
450 {
451 temp = str_new( NULL );
452 ret = str_new( NULL );
453 os_tempdir( temp );
454
455 while ( 1 )
456 {
457 str_clear( ret );
458 str_printf( ret, "%s\\gentee%02X.tmp", str_ptr( temp ), _gentee.tempid );
459
460 _gentee.tempfile = os_fileopen( ret, FOP_CREATE | FOP_EXCLUSIVE );
461
462 if ( !_gentee.tempfile )
463 {
464 if ( os_getattrib( ret ) == 0xFFFFFFFF )
465 if ( !diskc )
466 {
467 str_copyzero( temp, "c:\\temp" );
468 os_dircreate( temp );
469 diskc = 1;
470 }
471 else
472 msg( MFileopen | MSG_STR, ret );
473 _gentee.tempid++;
474 }
475 else
476 break;
477 }
478 str_setlen( ret, str_len( ret ) - 4 );
479 os_dircreate( ret );
480 str_copy( &_gentee.tempdir, ret );
481
482 str_destroy( temp );
483 str_destroy( ret );
484 }
485 //#endif
486 return &_gentee.tempdir;
487 }
488
489 /*-----------------------------------------------------------------------------
490 *
491 * ID: os_init 14.12.07 .
492 *
493 * Summary: Initializing input and output.
494 *
495 -----------------------------------------------------------------------------*/
496
497 void STDCALL os_init( uint param )
498 {
499 #ifdef LINUX
500 _gentee.multib = 0;
501 #else
502 if ( param ) // if ( !GetConsoleWindow( ))
503 AllocConsole();
504 else
505 {
506 CPINFO cpinfo;
507
508 GetCPInfo( CP_ACP, &cpinfo );
509 _gentee.multib = cpinfo.MaxCharSize > 1 ? 1 : 0;
510 }
511 if ( _gentee.flags & G_CONSOLE || param )
512 {
513 _stdout = GetStdHandle( STD_OUTPUT_HANDLE );
514 _stdin = GetStdHandle( STD_INPUT_HANDLE );
515 }
516 #endif
517 }
518
519 /*-----------------------------------------------------------------------------
520 *
521 * ID: os_print 14.12.07 .
522 *
523 * Summary: Print a text to the console.
524 *
525 -----------------------------------------------------------------------------*/
526
527 void STDCALL os_print( pubyte ptr, uint len )
528 {
529 //if (_gentee.print) : _gentee.print(ptr,len);
530
531 #ifdef LINUX
532 write(1,ptr,len);
533 #else
534 uint write;
535 pubyte charprn;
536
537 if ( _gentee.flags & G_CHARPRN )
538 {
539 charprn = ( pubyte )mem_alloc( len + 1 );
540 //CharToOem( ptr, charprn );
541 ptr = charprn;
542 }
543 if ( _gentee.flags & G_CONSOLE )
544 //WriteFile( _stdout, ptr, len, &write, 0 );
545 os_filewrite( _stdout , ptr, len);
546 else
547 {
548 if ( _stdout == INVALID_HANDLE_VALUE )
549 os_init( 1 );
550 //WriteConsole( _stdout, ptr, len, &write, NULL );
551 }
552 if ( _gentee.flags & G_CHARPRN )
553 mem_free( charprn );
554 #endif
555
556 }
557
558 /*-----------------------------------------------------------------------------
559 *
560 * ID: os_getch 14.12.07 .
561 *
562 * Summary: Get a character form the console.
563 *
564 -----------------------------------------------------------------------------*/
565
566 uint STDCALL os_getchar( void )
567 {
568 #ifdef LINUX
569 return getchar();
570 #else
571 uint mode, get;
572 ubyte input[8];
573
574 if(_gentee.getch)
575 return _gentee.getch(0,1);
576
577 if ( _stdin == INVALID_HANDLE_VALUE )
578 os_init( 1 );
579
580 GetConsoleMode( _stdin, &mode );
581 SetConsoleMode( _stdin, 0 );
582 ReadConsole( _stdin, input, 1, &get, NULL );
583 SetConsoleMode( _stdin, mode );
584 // return _getch();
585 return input[0];
586 #endif
587 }
588
589 /*-----------------------------------------------------------------------------
590 *
591 * ID: os_scan 14.12.07 .
592 *
593 * Summary: Get characters form the console.
594 *
595 -----------------------------------------------------------------------------*/
596
597 uint STDCALL os_scan( pubyte input, uint len )
598 {
599
600 #ifdef LINUX
601 return read(0,input,len);
602 #else
603 uint read;
604
605 if (_gentee.getch)
606 return _gentee.getch(input,len);
607
608 if ( _stdin == INVALID_HANDLE_VALUE )
609 os_init( 1 );
610 ReadConsole( _stdin, input, len, &read, NULL );
611
612 return read;
613 #endif
614 }
615
616 /*-----------------------------------------------------------------------------
617 *
618 * ID: os_strcmplen 14.12.07 .
619 *
620 * Summary: Compare strings
621 *
622 -----------------------------------------------------------------------------*/
623
624 int STDCALL os_strcmplen( pubyte one, pubyte two, uint len )
625 {
626 #ifdef LINUX
627 int cmp = strcmp(one,two);
628 if (cmp < 0)
629 return -1;
630 if (cmp > 0)
631 return 1;
632 #else
633 int cmp = CompareString( LOCALE_USER_DEFAULT, 0, one, len, two, len );
634 if ( cmp == CSTR_LESS_THAN )
635 return -1;
636 if ( cmp == CSTR_GREATER_THAN )
637 return 1;
638 #endif
639 return 0;
640 }
641
642 /*-----------------------------------------------------------------------------
643 *
644 * ID: os_strcmpignlen 14.12.07 .
645 *
646 * Summary: Compare strings
647 *
648 -----------------------------------------------------------------------------*/
649
650 int STDCALL os_strcmpignlen( pubyte one, pubyte two, uint len )
651 {
652 #ifdef LINUX
653 int cmp = strncasecmp(one,two,len);
654 if (cmp < 0)
655 return -1;
656 if (cmp > 0)
657 return 1;
658 #else
659 int cmp = CompareString( LOCALE_USER_DEFAULT, NORM_IGNORECASE, one, len, two, len );
660
661 if ( cmp == CSTR_LESS_THAN )
662 return -1;
663 if ( cmp == CSTR_GREATER_THAN )
664 return 1;
665 #endif
666 return 0;
667 }
668
669 /*-----------------------------------------------------------------------------
670 *
671 * ID: os_ustrcmplen 14.12.07 .
672 *
673 * Summary: Compare strings
674 *
675 -----------------------------------------------------------------------------*/
676
677 int STDCALL os_ustrcmplen( pushort one, pushort two, uint len )
678 {
679 #ifdef LINUX
680 int cmp = strncmp(one,two,len);
681 if (cmp < 0)
682 return -1;
683 if (cmp > 0)
684 return 1;
685 #else
686 int cmp = CompareStringW( LOCALE_USER_DEFAULT, 0, one, len, two, len );
687 if ( cmp == CSTR_LESS_THAN )
688 return -1;
689 if ( cmp == CSTR_GREATER_THAN )
690 return 1;
691 #endif
692 return 0;
693 }
694
695 /*-----------------------------------------------------------------------------
696 *
697 * ID: os_strcmpignlen 14.12.07 .
698 *
699 * Summary: Compare strings
700 *
701 -----------------------------------------------------------------------------*/
702
703 int STDCALL os_ustrcmpignlen( pushort one, pushort two, uint len )
704 {
705 #ifdef WINDOWS
706 int cmp = CompareStringW( LOCALE_USER_DEFAULT, NORM_IGNORECASE, one, len, two, len );
707
708 if ( cmp == CSTR_LESS_THAN )
709 return -1;
710 if ( cmp == CSTR_GREATER_THAN )
711 return 1;
712 #endif
713 return 0;
714 }
715
716 /*-----------------------------------------------------------------------------
717 *
718 * ID: os_strcmp 14.12.07 .
719 *
720 * Summary: Compare strings
721 *
722 -----------------------------------------------------------------------------*/
723
724 int STDCALL os_strcmp( pubyte one, pubyte two )
725 {
726 return os_strcmplen( one, two, -1 );
727 }
728
729 /*-----------------------------------------------------------------------------
730 *
731 * ID: os_strcmpign 14.12.07 .
732 *
733 * Summary: Compare strings
734 *
735 -----------------------------------------------------------------------------*/
736
737 int STDCALL os_strcmpign( pubyte one, pubyte two )
738 {
739 return os_strcmpignlen( one, two, -1 );
740 }
741
742 /*-----------------------------------------------------------------------------
743 *
744 * ID: os_strcmp 14.12.07 .
745 *
746 * Summary: Compare strings
747 *
748 -----------------------------------------------------------------------------*/
749
750 int STDCALL os_ustrcmp( pushort one, pushort two )
751 {
752 return os_ustrcmplen( one, two, -1 );
753 }
754
755 /*-----------------------------------------------------------------------------
756 *
757 * ID: os_strcmpign 14.12.07 .
758 *
759 * Summary: Compare strings
760 *
761 -----------------------------------------------------------------------------*/
762
763 int STDCALL os_ustrcmpign( pushort one, pushort two )
764 {
765 return os_ustrcmpignlen( one, two, -1 );
766 }
767
768 //--------------------------------------------------------------------------
769
770 /*
771 pvoid STDCALL os_alloc( uint size )
772 {
773 return VirtualAlloc( NULL, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE );
774 }
775
776 void STDCALL os_free( pvoid ptr )
777 {
778 VirtualFree( ptr, 0, MEM_RELEASE );
779 }
780 */
781 //--------------------------------------------------------------------------
782
783 uint STDCALL os_time()
784 {
785 #ifdef LINUX
786 struct tms tm1;
787 return times(&tm1);
788 #else
789 return GetTickCount();
790 #endif
791 }
792
793 pubyte STDCALL os_lower(pubyte pData)
794 {
795 #ifdef LINUX
796 return strlower3(pData);
797 //return strlower2(pData);
798 #else
799 return CharLower(pData);
800 #endif
801 }
802
803 pubyte STDCALL strlower1(pubyte string1)
804 {
805 pubyte it = string1;
806 if (string1)
807 {
808 while (*it != 0)
809 {
810 if (!isdigit(*it))
811 *it = tolower(*it);
812 ++it;
813 }
814 /*
815 for (s=string1;*s;++s) {
816 if (!isdigit(*s))
817 *s=tolower(*s);
818 }
819 */
820 }
821 return string1;
822 }
823
824 pvoid STDCALL os_thread(pvoid pfunc,pvoid param)
825 {
826 uint id;
827
828 #ifdef LINUX
829 pthread_t thread_id;
830 //uint thread_id;
831 int rc;
832 rc = pthread_create(&thread_id,NULL,pfunc,param);
833 return (uint) thread_id;
834 #else
835 return CreateThread(0,0,pfunc,param,0,&id);
836 #endif
837 }
838
839 pubyte STDCALL os_getexepath( pubyte dir, pubyte name )
840 {
841 uint len;
842 //ubyte ptr_Test[512];
843 pstr sDir,sName;
844
845
846 #ifdef LINUX
847 //Only for linux
848 // dir[0] = 0;
849 // name[0] = 0;
850 len = readlink( "/proc/self/exe", dir, 512 )- 1 ;
851 while ( len && dir[ len ] != '/' ) {
852 //dir[ len ] = ' ' ;
853 len--;
854 }
855 mem_copyuntilzero( dir + len + 1, name );
856 #else
857 len = GetModuleFileName( 0, dir, 512 ) - 1;
858 while ( len && dir[ len ] != '\\' ) len--;
859 mem_copyuntilzero( dir + len + 1, name );
860 #endif
861 return dir;
862 }
863
864 #ifdef LINUX
865 /*
866 pubyte STDCALL os_getexename( pubyte buf, uint size )
867 {
868 uint len,lich=0;
869 ubyte linkname[64];
870 ubyte link_name[512];
871 pid_t pid;
872 int ret;
873 pid= getpid();
874
875 if(snprintf(linkname,sizeof(linkname),"/proc/%i/exe",pid) , 0)
876 {
877 abort();
878 }
879 ret = readlink(linkname,link_name,size);
880 if (ret == -1) return NULL;
881 while ( ret && link_name[ ret ] != '/' ) {
882 //dir[ len ] = ' ' ;
883 lich++;
884 }
885 mem_copyuntilzero( buf, link_name+ret-lich );
886 //mem_copy(buf,link_name,+(ret-lich));
887 return buf;
888 }
889 */
890 pubyte STDCALL os_getexename( pubyte dir)
891 {
892 uint len,lich=0;
893 ubyte dir2[512];
894 //ubyte ptr_Test[512];
895
896 len = readlink( "/proc/self/exe", dir2, 512 )- 1 ;
897 while ( len && dir2[ len ] != '/' ) {
898 //dir[ len ] = ' ' ;
899 lich++;
900 len--;
901 }
902 mem_copyuntilzero( dir, dir2 + len + 1 - lich);
903 //print( "dir =%s\n", dir );
904 return dir;
905 }
906
907 char * strlower2(char * cstr1)
908 {
909 char * it = cstr1;
910 while (*it != 0)
911 {
912 if (!isdigit(*it))
913 *it = tolower(*it);
914 ++it;
915 }
916 return cstr1;
917 }
918
919 void strlower3(char * s)
920 {
921 uint ddd = strlen(s);
922 while (*s)
923 {
924 if (!isdigit(*s))
925 *s = tolower(*s);
926 s++;
927 }
928 }
929
930
931 void os_splitpath(const char *src, char *drive, char *path, char *file, char *ext)
932 /* , FILE_MAX+1, PATH_MAX+1, FILE_MAX+1, FILE_MAX+1
933 drive : /path/ name.egon .tar.gz */
934 {
935 int len=0;
936 const char *ref1;
937 if (*src!='/')
938 if ((ref1=strchr(src, ':')))
939 {
940 if (((ref1+1)==strchr(src, '/'))||(!ref1[1]))
941 while (src<=ref1)
942 {
943 if (drive)
944 {
945 len++;
946 if (len<=NAME_MAX)
947 {
948 *drive=*src;
949 drive++;
950 }
951 }
952 if (*src==':')
953 {
954 src++;
955 break;
956 }
957 src++;
958 }
959 }
960 len=0;
961 if ((ref1=rindex(src, '/')))
962 while (src<=ref1)
963 {
964 if (path)
965 {
966 len++;
967 if (len<=PATH_MAX)
968 {
969 *path=*src;
970 path++;
971 }
972 }
973 src++;
974 }
975 len=0;
976 if (!(ref1=rindex(src, '.')))
977 ref1=src+strlen(src);
978 while (/*(*src)*/(src<ref1))
979 {
980 /* if (!strchr(src+1, '.'))
981 break;*/
982 if (!strcasecmp(src, ".tar.gz")) /* I am a bad boy */
983 break;
984 if (!strcasecmp(src, ".tar.bz2")) /* very bad */
985 break;
986 if (!strcasecmp(src, ".tar.Z")) /* and this is creepy */
987 break;
988 if (file)
989 {
990 len++;
991 if (len<=NAME_MAX)
992 {
993 *file=*src;
994 file++;
995 }
996 }
997 src++;
998 }
999 len=0;
1000 while (*src)
1001 {
1002 if (ext)
1003 {
1004 len++;
1005 if (len<=NAME_MAX)
1006 {
1007 *ext=*src;
1008 ext++;
1009 }
1010 }
1011 src++;
1012 }
1013 if (drive)
1014 *drive=0;
1015 if (path)
1016 *path=0;
1017 if (file)
1018 *file=0;
1019 if (ext)
1020 *ext=0;
1021 }
1022
1023 #endif
1024
1025
1026 void STDCALL os_exitthread(long retcode)
1027 {
1028 #ifdef LINUX
1029 pthread_exit((void*)retcode);
1030 #else
1031 ExitThread(retcode);
1032 #endif
1033
1034 }
1035
1036
1037 /*
1038 char * strlwr(char* string)
1039 {
1040 char * s;
1041
1042 if (string)
1043 {
1044 for (s = string;*s;++s)
1045 *s = toupper(s*);
1046 }
1047 return string;
1048 }
1049 */
1050