← Back to branch summary

~ubuntu-branches/ubuntu/hardy/ruby1.8/hardy-updates

« back to all changes in this revision

Viewing changes to wince/wince.c

  • Committer: Bazaar Package Importer
  • Author(s): akira yamada
  • Date: 2007-03-13 22:11:58 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20070313221158-h3oql37brlaf2go2
Tags: 1.8.6-1
http://bugs.debian.org/410018
* new upstream version, 1.8.6.
* libruby1.8 conflicts with libopenssl-ruby1.8 (< 1.8.6) (closes: #410018)
* changed packaging style to cdbs from dbs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
wince/wince.c
 
1
/***************************************************************
 
2
  wince.c
 
3
 
 
4
  author : uema2
 
5
  date   : Nov 30, 2002
 
6
 
 
7
  You can freely use, copy, modify, and redistribute
 
8
  the whole contents.
 
9
***************************************************************/
 
10
 
 
11
#include <windows.h>
 
12
#include <tchar.h>
 
13
#include "wince.h"
 
14
 
 
15
/* global for GetCommandLineA */
 
16
char *_commandLine;
 
17
 
 
18
extern char _currentdir[];
 
19
 
 
20
/* make up Win32API except wce_* functions.  */
 
21
 
 
22
DWORD GetModuleFileNameA( 
 
23
        HMODULE hModule, LPSTR lpFileName,
 
24
        DWORD size )
 
25
{
 
26
        LPWSTR lpFileNameW;
 
27
        LPSTR  mb;
 
28
        size_t ret;
 
29
 
 
30
        if( size==0 ) return 0;
 
31
 
 
32
        lpFileNameW = (LPWSTR)malloc( size*sizeof(wchar_t) );
 
33
        ret = GetModuleFileNameW( hModule, lpFileNameW, size );
 
34
        mb = wce_wctomb(lpFileNameW);
 
35
        strcpy(lpFileName, mb);
 
36
        free(mb);
 
37
        free(lpFileNameW);
 
38
 
 
39
        return ret;
 
40
}
 
41
 
 
42
#if _WIN32_WCE < 300
 
43
FARPROC GetProcAddressA(HMODULE hModule, LPCSTR lpProcName)
 
44
{
 
45
        FARPROC p;
 
46
        LPWSTR  lpwProcName;
 
47
 
 
48
        lpwProcName = wce_mbtowc( lpProcName );
 
49
        p = GetProcAddressW( hModule, lpwProcName );
 
50
        free( lpwProcName );
 
51
        return p;
 
52
}
 
53
#endif 
 
54
 
 
55
char * GetCommandLineA(void)
 
56
{
 
57
        return _commandLine;
 
58
}
 
59
 
 
60
/* this is not Win32API. GetCommandLineA helper. */
 
61
void wce_SetCommandLine(LPCWSTR wcmd)
 
62
{
 
63
        char* acmd;
 
64
 
 
65
        acmd = wce_wctomb( wcmd );
 
66
        _commandLine = (char*)malloc( strlen(acmd)+5 );
 
67
        sprintf( _commandLine, "ruby %s", acmd );
 
68
        free(acmd);
 
69
}
 
70
 
 
71
/* this is not Win32API. GetCommandLineA helper. */
 
72
void wce_FreeCommandLine(void)
 
73
{
 
74
        free(_commandLine);
 
75
        _commandLine = NULL;
 
76
}
 
77
 
 
78
/* I have no idea how to replace this. */
 
79
BOOL GetProcessTimes(HANDLE hprocess,
 
80
        LPFILETIME lpCreationTime, LPFILETIME lpExitTime,
 
81
        LPFILETIME lpKernelTime, LPFILETIME lpUserTime) 
 
82
{
 
83
        return 0;
 
84
}
 
85
 
 
86
/* --------------  file attributes functions. ------------------- */
 
87
DWORD GetFileAttributesA(LPCSTR lpFileName)
 
88
{
 
89
        LPWSTR lpwFileName;
 
90
        DWORD dw;
 
91
 
 
92
        lpwFileName = wce_mbtowc(lpFileName);
 
93
        dw = GetFileAttributesW(lpwFileName);
 
94
        free(lpwFileName);
 
95
        return dw;
 
96
}
 
97
 
 
98
BOOL SetFileAttributesA(
 
99
        LPCSTR lpFileName, DWORD attributes) 
 
100
{
 
101
        LPWSTR lpwFileName;
 
102
        BOOL b;
 
103
 
 
104
        lpwFileName = wce_mbtowc(lpFileName);
 
105
        b = SetFileAttributesW(lpwFileName, attributes);
 
106
        free(lpwFileName);
 
107
        return b;
 
108
}
 
109
 
 
110
/* ---------------  move and remove functions. ------------------- */
 
111
BOOL MoveFileA(LPCSTR fn1, LPCSTR fn2)
 
112
{
 
113
        LPWSTR wfn1, wfn2;
 
114
        BOOL b;
 
115
 
 
116
        wfn1 = wce_mbtowc(fn1);
 
117
        wfn2 = wce_mbtowc(fn2);
 
118
        b = MoveFileW(wfn1, wfn2);
 
119
        free(wfn1);
 
120
        free(wfn2);
 
121
        return 0;
 
122
}
 
123
 
 
124
BOOL MoveFileEx(LPCSTR oldname, LPCSTR newname, DWORD dwFlags)
 
125
{
 
126
        LPWSTR woldname, wnewname;
 
127
        BOOL b;
 
128
 
 
129
        woldname = wce_mbtowc(oldname);
 
130
        wnewname = wce_mbtowc(newname);
 
131
 
 
132
        if( (dwFlags&MOVEFILE_REPLACE_EXISTING)!=0 )
 
133
                DeleteFileW( wnewname );
 
134
 
 
135
        b = MoveFileW( woldname, wnewname );
 
136
 
 
137
        free(woldname);
 
138
        free(wnewname);
 
139
 
 
140
        return b;
 
141
}
 
142
 
 
143
BOOL DeleteFileA(LPCSTR path)
 
144
{ 
 
145
        LPWSTR wpath;
 
146
        BOOL b;
 
147
 
 
148
        wpath = wce_mbtowc(path);
 
149
        b = DeleteFileW(wpath);
 
150
        free(wpath);
 
151
        return 0;
 
152
}
 
153
 
 
154
/* --------------- EnvironmentVariable functions. ----------------- */
 
155
DWORD GetEnvironmentVariable(
 
156
        LPCSTR name, LPSTR value, DWORD size)
 
157
{
 
158
        /* use registry instead of "environment valuable". */
 
159
        HKEY    hk;
 
160
        LONG    lret;
 
161
        LPBYTE  lpData;
 
162
        DWORD   dwType=REG_SZ, cbData;
 
163
        TCHAR   buf[MAX_PATH]={0};
 
164
        LPWSTR  wname;
 
165
        LPSTR   avalue;
 
166
 
 
167
        lret = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
 
168
                                _T("Software\\ruby_mswince"),
 
169
                                0, KEY_QUERY_VALUE, &hk );
 
170
 
 
171
        if ( lret != ERROR_SUCCESS )
 
172
        {
 
173
                strcpy( value, "" );
 
174
                return 0;
 
175
        }
 
176
 
 
177
        lpData = (LPBYTE)buf;
 
178
        cbData = MAX_PATH*sizeof(*buf);
 
179
        wname  = wce_mbtowc( name );
 
180
 
 
181
        lret = RegQueryValueEx( hk, wname,
 
182
                NULL, &dwType, lpData, &cbData );
 
183
        RegCloseKey( hk );
 
184
 
 
185
        if ( lret != ERROR_SUCCESS )
 
186
        {
 
187
                strcpy( value, "" );
 
188
                free( wname );
 
189
                return 0;
 
190
        }
 
191
 
 
192
        avalue = wce_wctomb( (LPCTSTR)lpData );
 
193
        strcpy( value, avalue );
 
194
        free( avalue );
 
195
        free( wname );
 
196
 
 
197
        return strlen(value);
 
198
}
 
199
 
 
200
BOOL SetEnvironmentVariable(LPCSTR name, LPCSTR value)
 
201
{
 
202
        /* use registry instead of "environment valuable". */
 
203
        HKEY    hk;
 
204
        LONG    lret;
 
205
        LPBYTE  lpData;
 
206
        DWORD   ret, dwType=REG_SZ, cbData;
 
207
        LPWSTR  wname, wvalue;
 
208
 
 
209
        lret = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
 
210
                        _T("Software\\ruby_mswince"),
 
211
                        0, _T(""), 0,
 
212
                        0, NULL, &hk, &ret );
 
213
        if( lret != ERROR_SUCCESS )
 
214
                return FALSE;
 
215
 
 
216
        wname  = wce_mbtowc(name);
 
217
        wvalue = wce_mbtowc(value);
 
218
 
 
219
        lpData = (LPBYTE)wvalue;
 
220
        cbData = (wcslen(wvalue) + 1) * sizeof(*wvalue);
 
221
        lret = RegSetValueEx( hk, wname,
 
222
                0, dwType, lpData, cbData );
 
223
        RegCloseKey( hk );
 
224
        free(wname);
 
225
        free(wvalue);
 
226
        return lret == ERROR_SUCCESS;
 
227
}
 
228
 
 
229
LPVOID GetEnvironmentStrings(VOID)
 
230
{
 
231
        return NULL;
 
232
}
 
233
 
 
234
BOOL FreeEnvironmentStrings(LPSTR lpszEnvironmentBlock)
 
235
{
 
236
        return FALSE;
 
237
}
 
238
 
 
239
/* DuplicateHandle, LockFile, etc... */
 
240
/* I have no idea...  */
 
241
BOOL GenerateConsoleCtrlEvent(DWORD dwCtrlEvent,
 
242
                DWORD dwProcessGroupID)
 
243
{
 
244
        return 0;
 
245
}
 
246
 
 
247
BOOL DuplicateHandle(
 
248
        HANDLE source_process, HANDLE source,
 
249
        HANDLE dest_process, HANDLE *dest,
 
250
        DWORD access, BOOL inherit, DWORD options)
 
251
{
 
252
        return 0;
 
253
}
 
254
 
 
255
BOOL LockFile(HANDLE hFile,
 
256
        DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
 
257
        DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh)
 
258
{
 
259
        return FALSE;
 
260
}
 
261
 
 
262
BOOL LockFileEx(HANDLE hFile,
 
263
        DWORD dwFlags, DWORD dwReserved,
 
264
        DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
 
265
        LPOVERLAPPED lpOverlapped)
 
266
{
 
267
        return FALSE;
 
268
}
 
269
 
 
270
BOOL UnlockFile( HFILE hFile,
 
271
        DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
 
272
        DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh)
 
273
{
 
274
        return FALSE;
 
275
}
 
276
 
 
277
BOOL UnlockFileEx(HANDLE hFile,
 
278
        DWORD dwReserved, DWORD nNumberOfBytesToUnlockLow,
 
279
        DWORD nNumberOfBytesToUnlockHigh, LPOVERLAPPED lpOverlapped)
 
280
{
 
281
        return FALSE;
 
282
}
 
283
 
 
284
/* --------------------- etc, etc, etc... ----------------------- */
 
285
BOOL GetVersionExA(OSVERSIONINFOA *v)
 
286
{
 
287
        OSVERSIONINFOW wv;
 
288
        BOOL b;
 
289
        LPSTR mb;
 
290
 
 
291
        b = GetVersionExW(&wv);
 
292
        mb = wce_wctomb(wv.szCSDVersion);
 
293
 
 
294
        strcpy( v->szCSDVersion, mb );
 
295
        free(mb);
 
296
        return b;
 
297
}
 
298
 
 
299
DWORD WaitForMultipleObjectsEx(DWORD count,
 
300
        const HANDLE *handles, BOOL wait_all,
 
301
        DWORD timeout, BOOL alertable)
 
302
{
 
303
        return WaitForMultipleObjects(
 
304
                count, handles, wait_all,
 
305
                timeout );
 
306
}
 
307
 
 
308
BOOL CreateProcessA(LPCSTR appname, LPCSTR commandline,
 
309
        LPSECURITY_ATTRIBUTES att, LPSECURITY_ATTRIBUTES threadatt,
 
310
        BOOL bOpt, DWORD dwFlag, LPVOID lpEnv, LPSTR dir,
 
311
        LPSTARTUPINFO lpsi, LPPROCESS_INFORMATION lppi)
 
312
{
 
313
        LPWSTR wappname, wcommandline, wdir;
 
314
        BOOL b;
 
315
 
 
316
        wappname     = wce_mbtowc(appname);
 
317
        wcommandline = wce_mbtowc(commandline);
 
318
        wdir         = wce_mbtowc(dir);
 
319
 
 
320
        b = CreateProcessW(wappname, wcommandline,
 
321
                        att, threadatt, bOpt, dwFlag, lpEnv,
 
322
                        wdir, lpsi, lppi);
 
323
 
 
324
        free(wappname);
 
325
        free(wcommandline);
 
326
        free(wdir);
 
327
 
 
328
        return b;
 
329
}
 
330
 
 
331
HANDLE CreateEventA(SECURITY_ATTRIBUTES *sa, 
 
332
        BOOL manual_reset, BOOL initial_state, LPCSTR name)
 
333
{
 
334
        HANDLE h;
 
335
        LPWSTR wname;
 
336
 
 
337
        wname = wce_mbtowc(name);
 
338
        h = CreateEventW(sa, manual_reset,
 
339
                initial_state, wname);
 
340
        free(wname);
 
341
 
 
342
        return h;
 
343
}
 
344
 
 
345
DWORD FormatMessageA(DWORD dwFlags, LPCVOID lpSource, 
 
346
        DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, 
 
347
        DWORD nSize, va_list* args)
 
348
{
 
349
        DWORD dw;
 
350
        LPWSTR lpWBuffer;
 
351
 
 
352
        lpWBuffer = wce_mbtowc(lpBuffer);
 
353
        dw = FormatMessageW( dwFlags, lpSource,
 
354
                        dwMessageId, dwLanguageId,
 
355
                        lpWBuffer, nSize, (va_list*)args );
 
356
        free(lpWBuffer);
 
357
        return dw;
 
358
}
 
359
 
 
360
/*---------------- FindFirstFile, FindNextFile ------------------ */
 
361
HANDLE FindFirstFileA(LPCSTR path,
 
362
                        WIN32_FIND_DATAA *data)
 
363
{
 
364
        LPWSTR wpath;
 
365
        LPSTR  mb;
 
366
        HANDLE h;
 
367
        WIN32_FIND_DATAW wdata;
 
368
 
 
369
        wpath = wce_mbtowc(path);
 
370
        h = FindFirstFileW( wpath, &wdata );
 
371
        free(wpath);
 
372
        
 
373
        mb = wce_wctomb( wdata.cFileName );
 
374
        strcpy( data->cFileName, mb );
 
375
        free(mb);
 
376
 
 
377
        return h;
 
378
}
 
379
 
 
380
BOOL FindNextFileA(HANDLE handle,
 
381
        WIN32_FIND_DATAA *data)
 
382
{
 
383
        BOOL b;
 
384
        WIN32_FIND_DATAW wdata;
 
385
        LPSTR mb1;
 
386
 
 
387
        b = FindNextFileW(handle, &wdata);
 
388
 
 
389
        mb1 = wce_wctomb( wdata.cFileName );
 
390
        strcpy( data->cFileName, mb1 );
 
391
        free(mb1);
 
392
 
 
393
        return b;
 
394
}
 
395
 
 
396
/* CreateFile doesn't support SECURITY_ATTRIBUTES in WinCE. */
 
397
/* it must be NULL. */
 
398
HANDLE CreateFileA(LPCSTR filename, DWORD access,
 
399
        DWORD sharing, LPSECURITY_ATTRIBUTES sa,
 
400
        DWORD creation, DWORD attributes, HANDLE template)
 
401
{
 
402
        LPWSTR wfilename;
 
403
        HANDLE h;
 
404
 
 
405
        wfilename = wce_mbtowc(filename);
 
406
        h = CreateFileW(wfilename, access, sharing,
 
407
                        NULL, creation, 0, NULL);
 
408
        free(wfilename);
 
409
 
 
410
        return 0;
 
411
}
 
412
 
 
413
/* ---------------- CharNext, CharPrev. ---------------------*/
 
414
LPSTR CharNextA(LPCSTR a)
 
415
{
 
416
        char *p=(char *)a;
 
417
        if( TRUE==IsDBCSLeadByteEx(CP_ACP, (BYTE)*a) )
 
418
                p+=2;
 
419
        else
 
420
                p++;
 
421
 
 
422
        return p;
 
423
}
 
424
 
 
425
LPSTR CharPrevA(LPCSTR start, LPCSTR ptr)
 
426
{
 
427
        if( start==ptr ) return (LPSTR)start;
 
428
        else if( start+1==ptr ) return (LPSTR)start;
 
429
        else if( TRUE==IsDBCSLeadByteEx(CP_ACP, (BYTE)*(ptr-2)) )
 
430
                return (LPSTR)(ptr-2);
 
431
        else
 
432
                return (LPSTR)(ptr-1);
 
433
}
 
434
 
 
435
/* WinCE doesn't have "drives". */
 
436
DWORD GetLogicalDrives(VOID)
 
437
{
 
438
        return 0;
 
439
}
 
440
 
 
441
/* WinCE doesn't have "user name". */
 
442
BOOL GetUserName(LPSTR lpBuffer, LPDWORD nSize)
 
443
{
 
444
        return 0;
 
445
}
 
446
 
 
447
/*------------------- LoadLibrary -----------------------*/
 
448
HINSTANCE LoadLibraryA(LPCSTR libname)
 
449
{
 
450
        HINSTANCE h;
 
451
        LPWSTR wlibname;
 
452
 
 
453
        // if starts ".\", replace current directory.
 
454
//      wlibname = wce_replaceRelativeDir(libname);
 
455
 
 
456
        wlibname = wce_mbtowc(libname);
 
457
        h = LoadLibraryW(wlibname);
 
458
        free(wlibname);
 
459
        return h;
 
460
}
 
461
 
 
462
HINSTANCE LoadLibraryExA(LPCSTR lpLibFileName, HANDLE hFile,
 
463
                        DWORD dwFlags)
 
464
{
 
465
        HINSTANCE h;
 
466
        LPWSTR wlibname;
 
467
 
 
468
        wlibname = wce_mbtowc(lpLibFileName);
 
469
//      wlibname = wce_replaceRelativeDir(lpLibFileName);
 
470
 
 
471
#if _WIN32_WCE < 300
 
472
        h = LoadLibraryW(wlibname);
 
473
#else
 
474
        h = LoadLibraryExW(wlibname, hFile, dwFlags);
 
475
#endif
 
476
        free(wlibname);
 
477
        return h;
 
478
}
 
479
 
 
480
/* WinCE doesn't have "CreatePipe". */
 
481
BOOL CreatePipe(PHANDLE hReadPipe, PHANDLE hWritePipe,
 
482
        LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize)
 
483
{
 
484
        return FALSE;
 
485
}
 
486
 
 
487
/* WinCE doesn't have "Standard Devices". */
 
488
HANDLE GetStdHandle(DWORD nStdHandle)
 
489
{
 
490
        return NULL;
 
491
}
 
492
 
 
493
BOOL SetStdHandle(DWORD nStdHandle, HANDLE h)
 
494
{
 
495
        return FALSE;
 
496
}
 
497
 
 
498
#if _WIN32_WCE < 300
 
499
VOID ZeroMemory(PVOID p, DWORD length)
 
500
{
 
501
        memset(p,0,length);
 
502
}
 
503
#endif
 
504
 
 
505
 
 
506
/* need in ruby/io.c. */
 
507
int ReadDataPending()
 
508
{
 
509
        return 0;
 
510
}
 
511
 
 
512
/*---------------- helper functions. ---------------------------- */
 
513
FILE *wce_fopen( const char *fname, const char *mode )
 
514
{
 
515
        TCHAR* tfname = wce_replaceRelativeDir(fname);
 
516
        TCHAR* tmode = wce_mbtowc(mode);
 
517
        FILE* fp = _tfopen(tfname, tmode);
 
518
        free(tfname); free(tmode);
 
519
        return fp;
 
520
}
 
521
 
 
522
void wce_SetCurrentDir()
 
523
{
 
524
        WCHAR tbuf[MAX_PATH+1]={0};
 
525
        WCHAR *tp;
 
526
        char *buf;
 
527
 
 
528
        GetModuleFileNameW( NULL, tbuf, MAX_PATH );
 
529
        tp = _tcsrchr( tbuf, '\\' );
 
530
        if( tp!=NULL ) *tp=_T('\0');
 
531
        buf = wce_wctomb(tbuf);
 
532
        strcpy( _currentdir, buf );
 
533
        free(buf);
 
534
}
 
535
 
 
536
TCHAR *wce_replaceRelativeDir(const char* str)
 
537
{
 
538
        TCHAR *tbuf;
 
539
 
 
540
        if( 2<=strlen(str) && str[0]=='.' &&
 
541
                (str[1]=='/' || str[1]=='\\') )
 
542
        {
 
543
                char *buf;
 
544
                int len = strlen(str) + strlen(_currentdir);
 
545
                buf = malloc( len+1 );
 
546
                sprintf(buf, "%s%s", _currentdir, &str[1]);
 
547
                tbuf = wce_mbtowc(buf);
 
548
                free(buf);
 
549
        }
 
550
        else
 
551
                tbuf = wce_mbtowc(str);
 
552
        return tbuf;
 
553
}
 
554
 
 
555
/* char -> wchar_t */
 
556
wchar_t* wce_mbtowc(const char* a)
 
557
{
 
558
        int length;
 
559
        wchar_t *wbuf;
 
560
 
 
561
        length = MultiByteToWideChar(CP_ACP, 0, 
 
562
                a, -1, NULL, 0);
 
563
        wbuf = (wchar_t*)malloc( (length+1)*sizeof(wchar_t) );
 
564
        MultiByteToWideChar(CP_ACP, 0,
 
565
                a, -1, wbuf, length);
 
566
 
 
567
        return wbuf;
 
568
}
 
569
 
 
570
/* wchar_t -> char */
 
571
char* wce_wctomb(const wchar_t* w)
 
572
{
 
573
        DWORD charlength;
 
574
        char* pChar;
 
575
 
 
576
        charlength = WideCharToMultiByte(CP_ACP, 0, w,
 
577
                                        -1, NULL, 0, NULL, NULL);
 
578
        pChar = (char*)malloc(charlength+1);
 
579
        WideCharToMultiByte(CP_ACP, 0, w,
 
580
                -1, pChar, charlength, NULL, NULL);
 
581
 
 
582
        return pChar;
 
583
}