Ignore:
Timestamp:
Dec 18, 2011, 10:28:22 PM (14 years ago)
Author:
dmik
Message:

Merge branch gcc-kmk to trunk.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk

    • Property svn:ignore
      •  

        old new  
        1 bin
        2 Makefile.inc
         1env.cmd
         2LocalConfig.kmk
    • Property svn:mergeinfo set to
      /branches/gcc-kmkmergedeligible
  • trunk/include/os2wrap.h

    r21597 r21916  
    44
    55#ifdef __EMX__
    6 #define OS2EMX_PLAIN_CHAR
    7 #endif
     6
     7#ifndef USE_OS2_TOOLKIT_HEADERS
     8
     9// be compatible with the toolkit
     10#define OS2_INCLUDED
     11#define OS2DEF_INCLUDED
     12#define WIN_INCLUDED
     13#define __OS2_H__
     14
     15// add missing declarations
     16typedef unsigned short APIRET16;
     17#define APIENTRY16 _Far16 _Pascal
     18
     19#define INCL_LONGLONG_STRUCTS
     20
     21#else // ifndef USE_OS2_TOOLKIT_HEADERS
     22
     23#undef _Pascal
     24#define _Pascal _System // For Vio/Kbd/Mou
     25
     26#endif // ifndef USE_OS2_TOOLKIT_HEADERS
     27
     28#endif // ifdef __EMX__
    829
    930#include <os2.h>
     
    1839#endif
    1940
     41#ifdef __cplusplus
     42extern "C" {
     43#endif
     44
    2045#ifdef INCL_DOSMEMMGR
    2146
     
    47824807 USHORT sel = RestoreOS2FS();
    47834808
    4784     yyrc = VIO16ASSOCIATE(a, b);
    4785     SetFS(sel);
    4786 
    4787     return yyrc;
    4788 } 
     4809    yyrc = VioAssociate(a, b);
     4810    SetFS(sel);
     4811
     4812    return yyrc;
     4813}
    47894814
    47904815#undef  VioAssociate
     
    47964821 USHORT sel = RestoreOS2FS();
    47974822
    4798     yyrc = VIO16CREATELOGFONT(a, b, c, d);
    4799     SetFS(sel);
    4800 
    4801     return yyrc;
    4802 } 
     4823    yyrc = VioCreateLogFont(a, b, c, d);
     4824    SetFS(sel);
     4825
     4826    return yyrc;
     4827}
    48034828
    48044829#undef  VioCreateLogFont
     
    48104835 USHORT sel = RestoreOS2FS();
    48114836
    4812     yyrc = VIO16CREATEPS(a, b, c, d, e, f);
    4813     SetFS(sel);
    4814 
    4815     return yyrc;
    4816 } 
     4837    yyrc = VioCreatePS(a, b, c, d, e, f);
     4838    SetFS(sel);
     4839
     4840    return yyrc;
     4841}
    48174842
    48184843#undef  VioCreatePS
     
    48244849 USHORT sel = RestoreOS2FS();
    48254850
    4826     yyrc = VIO16DELETESETID(a, b);
    4827     SetFS(sel);
    4828 
    4829     return yyrc;
    4830 } 
     4851    yyrc = VioDeleteSetId(a, b);
     4852    SetFS(sel);
     4853
     4854    return yyrc;
     4855}
    48314856
    48324857#undef  VioDeleteSetId
     
    48384863 USHORT sel = RestoreOS2FS();
    48394864
    4840     yyrc = VIO16DESTROYPS(a);
    4841     SetFS(sel);
    4842 
    4843     return yyrc;
    4844 } 
     4865    yyrc = VioDestroyPS(a);
     4866    SetFS(sel);
     4867
     4868    return yyrc;
     4869}
    48454870
    48464871#undef  VioDestroyPS
     
    48524877 USHORT sel = RestoreOS2FS();
    48534878
    4854     yyrc = VIO16GETDEVICECELLSIZE(a, b, c);
    4855     SetFS(sel);
    4856 
    4857     return yyrc;
    4858 } 
     4879    yyrc = VioGetDeviceCellSize(a, b, c);
     4880    SetFS(sel);
     4881
     4882    return yyrc;
     4883}
    48594884
    48604885#undef  VioGetDeviceCellSize
     
    48664891 USHORT sel = RestoreOS2FS();
    48674892
    4868     yyrc = VIO16GETORG(a, b, c);
    4869     SetFS(sel);
    4870 
    4871     return yyrc;
    4872 } 
     4893    yyrc = VioGetOrg(a, b, c);
     4894    SetFS(sel);
     4895
     4896    return yyrc;
     4897}
    48734898
    48744899#undef  VioGetOrg
     
    48804905 USHORT sel = RestoreOS2FS();
    48814906
    4882     yyrc = VIO16QUERYFONTS(a, b, c, d, e, f, g);
    4883     SetFS(sel);
    4884 
    4885     return yyrc;
    4886 } 
     4907    yyrc = VioQueryFonts(a, b, c, d, e, f, g);
     4908    SetFS(sel);
     4909
     4910    return yyrc;
     4911}
    48874912
    48884913#undef  VioQueryFonts
     
    48944919 USHORT sel = RestoreOS2FS();
    48954920
    4896     yyrc = VIO16QUERYSETIDS(a, b, c, d, e);
    4897     SetFS(sel);
    4898 
    4899     return yyrc;
    4900 } 
     4921    yyrc = VioQuerySetIds(a, b, c, d, e);
     4922    SetFS(sel);
     4923
     4924    return yyrc;
     4925}
    49014926
    49024927#undef  VioQuerySetIds
     
    49084933 USHORT sel = RestoreOS2FS();
    49094934
    4910     yyrc = VIO16SETDEVICECELLSIZE(a, b, c);
    4911     SetFS(sel);
    4912 
    4913     return yyrc;
    4914 } 
     4935    yyrc = VioSetDeviceCellSize(a, b, c);
     4936    SetFS(sel);
     4937
     4938    return yyrc;
     4939}
    49154940
    49164941#undef  VioSetDeviceCellSize
     
    49224947 USHORT sel = RestoreOS2FS();
    49234948
    4924     yyrc = VIO16SETORG(a, b, c);
    4925     SetFS(sel);
    4926 
    4927     return yyrc;
    4928 } 
     4949    yyrc = VioSetOrg(a, b, c);
     4950    SetFS(sel);
     4951
     4952    return yyrc;
     4953}
    49294954
    49304955#undef  VioSetOrg
     
    49364961 USHORT sel = RestoreOS2FS();
    49374962
    4938     yyrc = VIO16SHOWPS(a, b, c, d);
    4939     SetFS(sel);
    4940 
    4941     return yyrc;
    4942 } 
     4963    yyrc = VioShowPS(a, b, c, d);
     4964    SetFS(sel);
     4965
     4966    return yyrc;
     4967}
    49434968
    49444969#undef  VioShowPS
     
    49544979
    49554980    return yyrc;
    4956 } 
     4981}
    49574982
    49584983#undef  WinDefAVioWindowProc
     
    49704995
    49714996    return yyrc;
    4972 } 
     4997}
    49734998
    49744999#undef  KbdCharIn
     
    49845009
    49855010    return yyrc;
    4986 } 
     5011}
    49875012
    49885013#undef  KbdClose
     
    49985023
    49995024    return yyrc;
    5000 } 
     5025}
    50015026
    50025027#undef  KbdDeRegister
     
    50125037
    50135038    return yyrc;
    5014 } 
     5039}
    50155040
    50165041#undef  KbdFlushBuffer
     
    50265051
    50275052    return yyrc;
    5028 } 
     5053}
    50295054
    50305055#undef  KbdFreeFocus
     
    50405065
    50415066    return yyrc;
    5042 } 
     5067}
    50435068
    50445069#undef  KbdGetCp
     
    50545079
    50555080    return yyrc;
    5056 } 
     5081}
    50575082
    50585083#undef  KbdGetFocus
     
    50685093
    50695094    return yyrc;
    5070 } 
     5095}
    50715096
    50725097#undef  KbdGetHWID
     
    50825107
    50835108    return yyrc;
    5084 } 
     5109}
    50855110
    50865111#undef  KbdGetStatus
     
    50965121
    50975122    return yyrc;
    5098 } 
     5123}
    50995124
    51005125#undef  KbdOpen
     
    51105135
    51115136    return yyrc;
    5112 } 
     5137}
    51135138
    51145139#undef  KbdPeek
     
    51245149
    51255150    return yyrc;
    5126 } 
     5151}
    51275152
    51285153#undef  KbdRegister
     
    51385163
    51395164    return yyrc;
    5140 } 
     5165}
    51415166
    51425167#undef  KbdSetCp
     
    51525177
    51535178    return yyrc;
    5154 } 
     5179}
    51555180
    51565181#undef  KbdSetCustXt
     
    51665191
    51675192    return yyrc;
    5168 } 
     5193}
    51695194
    51705195#undef  KbdSetFgnd
     
    51805205
    51815206    return yyrc;
    5182 } 
     5207}
    51835208
    51845209#undef  KbdSetHWID
     
    51945219
    51955220    return yyrc;
    5196 } 
     5221}
    51975222
    51985223#undef  KbdSetStatus
     
    52085233
    52095234    return yyrc;
    5210 } 
     5235}
    52115236
    52125237#undef  KbdStringIn
     
    52225247
    52235248    return yyrc;
    5224 } 
     5249}
    52255250
    52265251#undef  KbdSynch
     
    52365261
    52375262    return yyrc;
    5238 } 
     5263}
    52395264
    52405265#undef  KbdXlate
     
    52485273 USHORT sel = RestoreOS2FS();
    52495274
    5250     yyrc = VIO16CHECKCHARTYPE(a, b, c, d);
    5251     SetFS(sel);
    5252 
    5253     return yyrc;
    5254 } 
     5275    yyrc = VioCheckCharType(a, b, c, d);
     5276    SetFS(sel);
     5277
     5278    return yyrc;
     5279}
    52555280
    52565281#undef  VioCheckCharType
     
    52625287 USHORT sel = RestoreOS2FS();
    52635288
    5264     yyrc = VIO16DEREGISTER();
    5265     SetFS(sel);
    5266 
    5267     return yyrc;
    5268 } 
     5289    yyrc = VioDeRegister();
     5290    SetFS(sel);
     5291
     5292    return yyrc;
     5293}
    52695294
    52705295#undef  VioDeRegister
     
    52765301 USHORT sel = RestoreOS2FS();
    52775302
    5278     yyrc = VIO16ENDPOPUP(a);
    5279     SetFS(sel);
    5280 
    5281     return yyrc;
    5282 } 
     5303    yyrc = VioEndPopUp(a);
     5304    SetFS(sel);
     5305
     5306    return yyrc;
     5307}
    52835308
    52845309#undef  VioEndPopUp
     
    52905315 USHORT sel = RestoreOS2FS();
    52915316
    5292     yyrc = VIO16GETANSI(a, b);
    5293     SetFS(sel);
    5294 
    5295     return yyrc;
    5296 } 
     5317    yyrc = VioGetAnsi(a, b);
     5318    SetFS(sel);
     5319
     5320    return yyrc;
     5321}
    52975322
    52985323#undef  VioGetAnsi
     
    53045329 USHORT sel = RestoreOS2FS();
    53055330
    5306     yyrc = VIO16GETBUF(a, b, c);
    5307     SetFS(sel);
    5308 
    5309     return yyrc;
    5310 } 
     5331    yyrc = VioGetBuf(a, b, c);
     5332    SetFS(sel);
     5333
     5334    return yyrc;
     5335}
    53115336
    53125337#undef  VioGetBuf
     
    53185343 USHORT sel = RestoreOS2FS();
    53195344
    5320     yyrc = VIO16GETCONFIG(a, b, c);
    5321     SetFS(sel);
    5322 
    5323     return yyrc;
    5324 } 
     5345    yyrc = VioGetConfig(a, b, c);
     5346    SetFS(sel);
     5347
     5348    return yyrc;
     5349}
    53255350
    53265351#undef  VioGetConfig
     
    53325357 USHORT sel = RestoreOS2FS();
    53335358
    5334     yyrc = VIO16GETCP(a, b, c);
    5335     SetFS(sel);
    5336 
    5337     return yyrc;
    5338 } 
     5359    yyrc = VioGetCp(a, b, c);
     5360    SetFS(sel);
     5361
     5362    return yyrc;
     5363}
    53395364
    53405365#undef  VioGetCp
     
    53465371 USHORT sel = RestoreOS2FS();
    53475372
    5348     yyrc = VIO16GETCURPOS(a, b, c);
    5349     SetFS(sel);
    5350 
    5351     return yyrc;
    5352 } 
     5373    yyrc = VioGetCurPos(a, b, c);
     5374    SetFS(sel);
     5375
     5376    return yyrc;
     5377}
    53535378
    53545379#undef  VioGetCurPos
     
    53605385 USHORT sel = RestoreOS2FS();
    53615386
    5362     yyrc = VIO16GETCURTYPE(a, b);
    5363     SetFS(sel);
    5364 
    5365     return yyrc;
    5366 } 
     5387    yyrc = VioGetCurType(a, b);
     5388    SetFS(sel);
     5389
     5390    return yyrc;
     5391}
    53675392
    53685393#undef  VioGetCurType
     
    53745399 USHORT sel = RestoreOS2FS();
    53755400
    5376     yyrc = VIO16GETFONT(a, b);
    5377     SetFS(sel);
    5378 
    5379     return yyrc;
    5380 } 
     5401    yyrc = VioGetFont(a, b);
     5402    SetFS(sel);
     5403
     5404    return yyrc;
     5405}
    53815406
    53825407#undef  VioGetFont
     
    53885413 USHORT sel = RestoreOS2FS();
    53895414
    5390     yyrc = VIO16GETMODE(a, b);
    5391     SetFS(sel);
    5392 
    5393     return yyrc;
    5394 } 
     5415    yyrc = VioGetMode(a, b);
     5416    SetFS(sel);
     5417
     5418    return yyrc;
     5419}
    53955420
    53965421#undef  VioGetMode
     
    54025427 USHORT sel = RestoreOS2FS();
    54035428
    5404     yyrc = VIO16GETPHYSBUF(a, b);
    5405     SetFS(sel);
    5406 
    5407     return yyrc;
    5408 } 
     5429    yyrc = VioGetPhysBuf(a, b);
     5430    SetFS(sel);
     5431
     5432    return yyrc;
     5433}
    54095434
    54105435#undef  VioGetPhysBuf
     
    54165441 USHORT sel = RestoreOS2FS();
    54175442
    5418     yyrc = VIO16GETSTATE(a, b);
    5419     SetFS(sel);
    5420 
    5421     return yyrc;
    5422 } 
     5443    yyrc = VioGetState(a, b);
     5444    SetFS(sel);
     5445
     5446    return yyrc;
     5447}
    54235448
    54245449#undef  VioGetState
     
    54305455 USHORT sel = RestoreOS2FS();
    54315456
    5432     yyrc = VIO16MODEUNDO(a, b, c);
    5433     SetFS(sel);
    5434 
    5435     return yyrc;
    5436 } 
     5457    yyrc = VioModeUndo(a, b, c);
     5458    SetFS(sel);
     5459
     5460    return yyrc;
     5461}
    54375462
    54385463#undef  VioModeUndo
     
    54445469 USHORT sel = RestoreOS2FS();
    54455470
    5446     yyrc = VIO16MODEWAIT(a, b, c);
    5447     SetFS(sel);
    5448 
    5449     return yyrc;
    5450 } 
     5471    yyrc = VioModeWait(a, b, c);
     5472    SetFS(sel);
     5473
     5474    return yyrc;
     5475}
    54515476
    54525477#undef  VioModeWait
     
    54585483 USHORT sel = RestoreOS2FS();
    54595484
    5460     yyrc = VIO16POPUP(a, b);
    5461     SetFS(sel);
    5462 
    5463     return yyrc;
    5464 } 
     5485    yyrc = VioPopUp(a, b);
     5486    SetFS(sel);
     5487
     5488    return yyrc;
     5489}
    54655490
    54665491#undef  VioPopUp
     
    54725497 USHORT sel = RestoreOS2FS();
    54735498
    5474     yyrc = VIO16PRTSC(a);
    5475     SetFS(sel);
    5476 
    5477     return yyrc;
    5478 } 
     5499    yyrc = VioPrtSc(a);
     5500    SetFS(sel);
     5501
     5502    return yyrc;
     5503}
    54795504
    54805505#undef  VioPrtSc
     
    54865511 USHORT sel = RestoreOS2FS();
    54875512
    5488     yyrc = VIO16PRTSCTOGGLE(a);
    5489     SetFS(sel);
    5490 
    5491     return yyrc;
    5492 } 
     5513    yyrc = VioPrtScToggle(a);
     5514    SetFS(sel);
     5515
     5516    return yyrc;
     5517}
    54935518
    54945519#undef  VioPrtScToggle
     
    55005525 USHORT sel = RestoreOS2FS();
    55015526
    5502     yyrc = VIO16READCELLSTR(a, b, c, d, e);
    5503     SetFS(sel);
    5504 
    5505     return yyrc;
    5506 } 
     5527    yyrc = VioReadCellStr(a, b, c, d, e);
     5528    SetFS(sel);
     5529
     5530    return yyrc;
     5531}
    55075532
    55085533#undef  VioReadCellStr
     
    55145539 USHORT sel = RestoreOS2FS();
    55155540
    5516     yyrc = VIO16READCHARSTR(a, b, c, d, e);
    5517     SetFS(sel);
    5518 
    5519     return yyrc;
    5520 } 
     5541    yyrc = VioReadCharStr(a, b, c, d, e);
     5542    SetFS(sel);
     5543
     5544    return yyrc;
     5545}
    55215546
    55225547#undef  VioReadCharStr
     
    55285553 USHORT sel = RestoreOS2FS();
    55295554
    5530     yyrc = VIO16REGISTER(a, b, c, d);
    5531     SetFS(sel);
    5532 
    5533     return yyrc;
    5534 } 
     5555    yyrc = VioRegister(a, b, c, d);
     5556    SetFS(sel);
     5557
     5558    return yyrc;
     5559}
    55355560
    55365561#undef  VioRegister
     
    55425567 USHORT sel = RestoreOS2FS();
    55435568
    5544     yyrc = VIO16SAVREDRAWUNDO(a, b, c);
    5545     SetFS(sel);
    5546 
    5547     return yyrc;
    5548 } 
     5569    yyrc = VioSavRedrawUndo(a, b, c);
     5570    SetFS(sel);
     5571
     5572    return yyrc;
     5573}
    55495574
    55505575#undef  VioSavRedrawUndo
     
    55565581 USHORT sel = RestoreOS2FS();
    55575582
    5558     yyrc = VIO16SAVREDRAWWAIT(a, b, c);
    5559     SetFS(sel);
    5560 
    5561     return yyrc;
    5562 } 
     5583    yyrc = VioSavRedrawWait(a, b, c);
     5584    SetFS(sel);
     5585
     5586    return yyrc;
     5587}
    55635588
    55645589#undef  VioSavRedrawWait
     
    55705595 USHORT sel = RestoreOS2FS();
    55715596
    5572     yyrc = VIO16SCRLOCK(a, b, c);
    5573     SetFS(sel);
    5574 
    5575     return yyrc;
    5576 } 
     5597    yyrc = VioScrLock(a, b, c);
     5598    SetFS(sel);
     5599
     5600    return yyrc;
     5601}
    55775602
    55785603#undef  VioScrLock
     
    55845609 USHORT sel = RestoreOS2FS();
    55855610
    5586     yyrc = VIO16SCROLLDN(a, b, c, d, e, f, g);
    5587     SetFS(sel);
    5588 
    5589     return yyrc;
    5590 } 
     5611    yyrc = VioScrollDn(a, b, c, d, e, f, g);
     5612    SetFS(sel);
     5613
     5614    return yyrc;
     5615}
    55915616
    55925617#undef  VioScrollDn
     
    55985623 USHORT sel = RestoreOS2FS();
    55995624
    5600     yyrc = VIO16SCROLLLF(a, b, c, d, e, f, g);
    5601     SetFS(sel);
    5602 
    5603     return yyrc;
    5604 } 
     5625    yyrc = VioScrollLf(a, b, c, d, e, f, g);
     5626    SetFS(sel);
     5627
     5628    return yyrc;
     5629}
    56055630
    56065631#undef  VioScrollLf
     
    56125637 USHORT sel = RestoreOS2FS();
    56135638
    5614     yyrc = VIO16SCROLLRT(a, b, c, d, e, f, g);
    5615     SetFS(sel);
    5616 
    5617     return yyrc;
    5618 } 
     5639    yyrc = VioScrollRt(a, b, c, d, e, f, g);
     5640    SetFS(sel);
     5641
     5642    return yyrc;
     5643}
    56195644
    56205645#undef  VioScrollRt
     
    56265651 USHORT sel = RestoreOS2FS();
    56275652
    5628     yyrc = VIO16SCROLLUP(a, b, c, d, e, f, g);
    5629     SetFS(sel);
    5630 
    5631     return yyrc;
    5632 } 
     5653    yyrc = VioScrollUp(a, b, c, d, e, f, g);
     5654    SetFS(sel);
     5655
     5656    return yyrc;
     5657}
    56335658
    56345659#undef  VioScrollUp
     
    56405665 USHORT sel = RestoreOS2FS();
    56415666
    5642     yyrc = VIO16SCRUNLOCK(a);
    5643     SetFS(sel);
    5644 
    5645     return yyrc;
    5646 } 
     5667    yyrc = VioScrUnLock(a);
     5668    SetFS(sel);
     5669
     5670    return yyrc;
     5671}
    56475672
    56485673#undef  VioScrUnLock
     
    56545679 USHORT sel = RestoreOS2FS();
    56555680
    5656     yyrc = VIO16SETANSI(a, b);
    5657     SetFS(sel);
    5658 
    5659     return yyrc;
    5660 } 
     5681    yyrc = VioSetAnsi(a, b);
     5682    SetFS(sel);
     5683
     5684    return yyrc;
     5685}
    56615686
    56625687#undef  VioSetAnsi
     
    56685693 USHORT sel = RestoreOS2FS();
    56695694
    5670     yyrc = VIO16SETCP(a, b, c);
    5671     SetFS(sel);
    5672 
    5673     return yyrc;
    5674 } 
     5695    yyrc = VioSetCp(a, b, c);
     5696    SetFS(sel);
     5697
     5698    return yyrc;
     5699}
    56755700
    56765701#undef  VioSetCp
     
    56825707 USHORT sel = RestoreOS2FS();
    56835708
    5684     yyrc = VIO16SETCURPOS(a, b, c);
    5685     SetFS(sel);
    5686 
    5687     return yyrc;
    5688 } 
     5709    yyrc = VioSetCurPos(a, b, c);
     5710    SetFS(sel);
     5711
     5712    return yyrc;
     5713}
    56895714
    56905715#undef  VioSetCurPos
     
    56965721 USHORT sel = RestoreOS2FS();
    56975722
    5698     yyrc = VIO16SETCURTYPE(a, b);
    5699     SetFS(sel);
    5700 
    5701     return yyrc;
    5702 } 
     5723    yyrc = VioSetCurType(a, b);
     5724    SetFS(sel);
     5725
     5726    return yyrc;
     5727}
    57035728
    57045729#undef  VioSetCurType
     
    57105735 USHORT sel = RestoreOS2FS();
    57115736
    5712     yyrc = VIO16SETFONT(a, b);
    5713     SetFS(sel);
    5714 
    5715     return yyrc;
    5716 } 
     5737    yyrc = VioSetFont(a, b);
     5738    SetFS(sel);
     5739
     5740    return yyrc;
     5741}
    57175742
    57185743#undef  VioSetFont
     
    57245749 USHORT sel = RestoreOS2FS();
    57255750
    5726     yyrc = VIO16SETMODE(a, b);
    5727     SetFS(sel);
    5728 
    5729     return yyrc;
    5730 } 
     5751    yyrc = VioSetMode(a, b);
     5752    SetFS(sel);
     5753
     5754    return yyrc;
     5755}
    57315756
    57325757#undef  VioSetMode
     
    57385763 USHORT sel = RestoreOS2FS();
    57395764
    5740     yyrc = VIO16SETSTATE(a, b);
    5741     SetFS(sel);
    5742 
    5743     return yyrc;
    5744 } 
     5765    yyrc = VioSetState(a, b);
     5766    SetFS(sel);
     5767
     5768    return yyrc;
     5769}
    57455770
    57465771#undef  VioSetState
     
    57525777 USHORT sel = RestoreOS2FS();
    57535778
    5754     yyrc = VIO16SHOWBUF(a, b, c);
    5755     SetFS(sel);
    5756 
    5757     return yyrc;
    5758 } 
     5779    yyrc = VioShowBuf(a, b, c);
     5780    SetFS(sel);
     5781
     5782    return yyrc;
     5783}
    57595784
    57605785#undef  VioShowBuf
     
    57665791 USHORT sel = RestoreOS2FS();
    57675792
    5768     yyrc = VIO16WRTCELLSTR(a, b, c, d, e);
    5769     SetFS(sel);
    5770 
    5771     return yyrc;
    5772 } 
     5793    yyrc = VioWrtCellStr(a, b, c, d, e);
     5794    SetFS(sel);
     5795
     5796    return yyrc;
     5797}
    57735798
    57745799#undef  VioWrtCellStr
     
    57805805 USHORT sel = RestoreOS2FS();
    57815806
    5782     yyrc = VIO16WRTCHARSTR(a, b, c, d, e);
    5783     SetFS(sel);
    5784 
    5785     return yyrc;
    5786 } 
     5807    yyrc = VioWrtCharStr(a, b, c, d, e);
     5808    SetFS(sel);
     5809
     5810    return yyrc;
     5811}
    57875812
    57885813#undef  VioWrtCharStr
     
    57945819 USHORT sel = RestoreOS2FS();
    57955820
    5796     yyrc = VIO16WRTCHARSTRATT(a, b, c, d, e, f);
    5797     SetFS(sel);
    5798 
    5799     return yyrc;
    5800 } 
     5821    yyrc = VioWrtCharStrAtt(a, b, c, d, e, f);
     5822    SetFS(sel);
     5823
     5824    return yyrc;
     5825}
    58015826
    58025827#undef  VioWrtCharStrAtt
     
    58085833 USHORT sel = RestoreOS2FS();
    58095834
    5810     yyrc = VIO16WRTNATTR(a, b, c, d, e);
    5811     SetFS(sel);
    5812 
    5813     return yyrc;
    5814 } 
     5835    yyrc = VioWrtNAttr(a, b, c, d, e);
     5836    SetFS(sel);
     5837
     5838    return yyrc;
     5839}
    58155840
    58165841#undef  VioWrtNAttr
     
    58225847 USHORT sel = RestoreOS2FS();
    58235848
    5824     yyrc = VIO16WRTNCELL(a, b, c, d, e);
    5825     SetFS(sel);
    5826 
    5827     return yyrc;
    5828 } 
     5849    yyrc = VioWrtNCell(a, b, c, d, e);
     5850    SetFS(sel);
     5851
     5852    return yyrc;
     5853}
    58295854
    58305855#undef  VioWrtNCell
     
    58365861 USHORT sel = RestoreOS2FS();
    58375862
    5838     yyrc = VIO16WRTNCHAR(a, b, c, d, e);
    5839     SetFS(sel);
    5840 
    5841     return yyrc;
    5842 } 
     5863    yyrc = VioWrtNChar(a, b, c, d, e);
     5864    SetFS(sel);
     5865
     5866    return yyrc;
     5867}
    58435868
    58445869#undef  VioWrtNChar
     
    58505875 USHORT sel = RestoreOS2FS();
    58515876
    5852     yyrc = VIO16WRTTTY(a, b, c);
    5853     SetFS(sel);
    5854 
    5855     return yyrc;
    5856 } 
     5877    yyrc = VioWrtTTY(a, b, c);
     5878    SetFS(sel);
     5879
     5880    return yyrc;
     5881}
    58575882
    58585883#undef  VioWrtTTY
     
    58665891 USHORT sel = RestoreOS2FS();
    58675892
    5868     yyrc = MOU16CLOSE(a);
    5869     SetFS(sel);
    5870 
    5871     return yyrc;
    5872 } 
     5893    yyrc = MouClose(a);
     5894    SetFS(sel);
     5895
     5896    return yyrc;
     5897}
    58735898
    58745899#undef  MouClose
     
    58805905 USHORT sel = RestoreOS2FS();
    58815906
    5882     yyrc = MOU16DEREGISTER();
    5883     SetFS(sel);
    5884 
    5885     return yyrc;
    5886 } 
     5907    yyrc = MouDeRegister();
     5908    SetFS(sel);
     5909
     5910    return yyrc;
     5911}
    58875912
    58885913#undef  MouDeRegister
     
    58945919 USHORT sel = RestoreOS2FS();
    58955920
    5896     yyrc = MOU16DRAWPTR(a);
    5897     SetFS(sel);
    5898 
    5899     return yyrc;
    5900 } 
     5921    yyrc = MouDrawPtr(a);
     5922    SetFS(sel);
     5923
     5924    return yyrc;
     5925}
    59015926
    59025927#undef  MouDrawPtr
     
    59085933 USHORT sel = RestoreOS2FS();
    59095934
    5910     yyrc = MOU16FLUSHQUE(a);
    5911     SetFS(sel);
    5912 
    5913     return yyrc;
    5914 } 
     5935    yyrc = MouFlushQue(a);
     5936    SetFS(sel);
     5937
     5938    return yyrc;
     5939}
    59155940
    59165941#undef  MouFlushQue
     
    59225947 USHORT sel = RestoreOS2FS();
    59235948
    5924     yyrc = MOU16GETDEVSTATUS(a, b);
    5925     SetFS(sel);
    5926 
    5927     return yyrc;
    5928 } 
     5949    yyrc = MouGetDevStatus(a, b);
     5950    SetFS(sel);
     5951
     5952    return yyrc;
     5953}
    59295954
    59305955#undef  MouGetDevStatus
     
    59365961 USHORT sel = RestoreOS2FS();
    59375962
    5938     yyrc = MOU16GETEVENTMASK(a, b);
    5939     SetFS(sel);
    5940 
    5941     return yyrc;
    5942 } 
     5963    yyrc = MouGetEventMask(a, b);
     5964    SetFS(sel);
     5965
     5966    return yyrc;
     5967}
    59435968
    59445969#undef  MouGetEventMask
     
    59505975 USHORT sel = RestoreOS2FS();
    59515976
    5952     yyrc = MOU16GETNUMBUTTONS(a, b);
    5953     SetFS(sel);
    5954 
    5955     return yyrc;
    5956 } 
     5977    yyrc = MouGetNumButtons(a, b);
     5978    SetFS(sel);
     5979
     5980    return yyrc;
     5981}
    59575982
    59585983#undef  MouGetNumButtons
     
    59645989 USHORT sel = RestoreOS2FS();
    59655990
    5966     yyrc = MOU16GETNUMMICKEYS(a, b);
    5967     SetFS(sel);
    5968 
    5969     return yyrc;
    5970 } 
     5991    yyrc = MouGetNumMickeys(a, b);
     5992    SetFS(sel);
     5993
     5994    return yyrc;
     5995}
    59715996
    59725997#undef  MouGetNumMickeys
     
    59786003 USHORT sel = RestoreOS2FS();
    59796004
    5980     yyrc = MOU16GETNUMQUEEL(a, b);
    5981     SetFS(sel);
    5982 
    5983     return yyrc;
    5984 } 
     6005    yyrc = MouGetNumQueEl(a, b);
     6006    SetFS(sel);
     6007
     6008    return yyrc;
     6009}
    59856010
    59866011#undef  MouGetNumQueEl
     
    59926017 USHORT sel = RestoreOS2FS();
    59936018
    5994     yyrc = MOU16GETPTRPOS(a, b);
    5995     SetFS(sel);
    5996 
    5997     return yyrc;
    5998 } 
     6019    yyrc = MouGetPtrPos(a, b);
     6020    SetFS(sel);
     6021
     6022    return yyrc;
     6023}
    59996024
    60006025#undef  MouGetPtrPos
     
    60066031 USHORT sel = RestoreOS2FS();
    60076032
    6008     yyrc = MOU16GETPTRSHAPE(a, b, c);
    6009     SetFS(sel);
    6010 
    6011     return yyrc;
    6012 } 
     6033    yyrc = MouGetPtrShape(a, b, c);
     6034    SetFS(sel);
     6035
     6036    return yyrc;
     6037}
    60136038
    60146039#undef  MouGetPtrShape
     
    60206045 USHORT sel = RestoreOS2FS();
    60216046
    6022     yyrc = MOU16GETSCALEFACT(a, b);
    6023     SetFS(sel);
    6024 
    6025     return yyrc;
    6026 } 
     6047    yyrc = MouGetScaleFact(a, b);
     6048    SetFS(sel);
     6049
     6050    return yyrc;
     6051}
    60276052
    60286053#undef  MouGetScaleFact
     
    60346059 USHORT sel = RestoreOS2FS();
    60356060
    6036     yyrc = MOU16GETTHRESHOLD(a, b);
    6037     SetFS(sel);
    6038 
    6039     return yyrc;
    6040 } 
     6061    yyrc = MouGetThreshold(a, b);
     6062    SetFS(sel);
     6063
     6064    return yyrc;
     6065}
    60416066
    60426067#undef  MouGetThreshold
     
    60486073 USHORT sel = RestoreOS2FS();
    60496074
    6050     yyrc = MOU16INITREAL(a);
    6051     SetFS(sel);
    6052 
    6053     return yyrc;
    6054 } 
     6075    yyrc = MouInitReal(a);
     6076    SetFS(sel);
     6077
     6078    return yyrc;
     6079}
    60556080
    60566081#undef  MouInitReal
     
    60626087 USHORT sel = RestoreOS2FS();
    60636088
    6064     yyrc = MOU16OPEN(a, b);
    6065     SetFS(sel);
    6066 
    6067     return yyrc;
    6068 } 
     6089    yyrc = MouOpen(a, b);
     6090    SetFS(sel);
     6091
     6092    return yyrc;
     6093}
    60696094
    60706095#undef  MouOpen
     
    60766101 USHORT sel = RestoreOS2FS();
    60776102
    6078     yyrc = MOU16READEVENTQUE(a, b, c);
    6079     SetFS(sel);
    6080 
    6081     return yyrc;
    6082 } 
     6103    yyrc = MouReadEventQue(a, b, c);
     6104    SetFS(sel);
     6105
     6106    return yyrc;
     6107}
    60836108
    60846109#undef  MouReadEventQue
     
    60906115 USHORT sel = RestoreOS2FS();
    60916116
    6092     yyrc = MOU16REGISTER(a, b, c);
    6093     SetFS(sel);
    6094 
    6095     return yyrc;
    6096 } 
     6117    yyrc = MouRegister(a, b, c);
     6118    SetFS(sel);
     6119
     6120    return yyrc;
     6121}
    60976122
    60986123#undef  MouRegister
     
    61046129 USHORT sel = RestoreOS2FS();
    61056130
    6106     yyrc = MOU16REMOVEPTR(a, b);
    6107     SetFS(sel);
    6108 
    6109     return yyrc;
    6110 } 
     6131    yyrc = MouRemovePtr(a, b);
     6132    SetFS(sel);
     6133
     6134    return yyrc;
     6135}
    61116136
    61126137#undef  MouRemovePtr
     
    61186143 USHORT sel = RestoreOS2FS();
    61196144
    6120     yyrc = MOU16SETDEVSTATUS(a, b);
    6121     SetFS(sel);
    6122 
    6123     return yyrc;
    6124 } 
     6145    yyrc = MouSetDevStatus(a, b);
     6146    SetFS(sel);
     6147
     6148    return yyrc;
     6149}
    61256150
    61266151#undef  MouSetDevStatus
     
    61326157 USHORT sel = RestoreOS2FS();
    61336158
    6134     yyrc = MOU16SETEVENTMASK(a, b);
    6135     SetFS(sel);
    6136 
    6137     return yyrc;
    6138 } 
     6159    yyrc = MouSetEventMask(a, b);
     6160    SetFS(sel);
     6161
     6162    return yyrc;
     6163}
    61396164
    61406165#undef  MouSetEventMask
     
    61466171 USHORT sel = RestoreOS2FS();
    61476172
    6148     yyrc = MOU16SETPTRPOS(a, b);
    6149     SetFS(sel);
    6150 
    6151     return yyrc;
    6152 } 
     6173    yyrc = MouSetPtrPos(a, b);
     6174    SetFS(sel);
     6175
     6176    return yyrc;
     6177}
    61536178
    61546179#undef  MouSetPtrPos
     
    61606185 USHORT sel = RestoreOS2FS();
    61616186
    6162     yyrc = MOU16SETPTRSHAPE(a, b, c);
    6163     SetFS(sel);
    6164 
    6165     return yyrc;
    6166 } 
     6187    yyrc = MouSetPtrShape(a, b, c);
     6188    SetFS(sel);
     6189
     6190    return yyrc;
     6191}
    61676192
    61686193#undef  MouSetPtrShape
     
    61746199 USHORT sel = RestoreOS2FS();
    61756200
    6176     yyrc = MOU16SETSCALEFACT(a, b);
    6177     SetFS(sel);
    6178 
    6179     return yyrc;
    6180 } 
     6201    yyrc = MouSetScaleFact(a, b);
     6202    SetFS(sel);
     6203
     6204    return yyrc;
     6205}
    61816206
    61826207#undef  MouSetScaleFact
     
    61886213 USHORT sel = RestoreOS2FS();
    61896214
    6190     yyrc = MOU16SETTHRESHOLD(a, b);
    6191     SetFS(sel);
    6192 
    6193     return yyrc;
    6194 } 
     6215    yyrc = MouSetThreshold(a, b);
     6216    SetFS(sel);
     6217
     6218    return yyrc;
     6219}
    61956220
    61966221#undef  MouSetThreshold
     
    62026227 USHORT sel = RestoreOS2FS();
    62036228
    6204     yyrc = MOU16SYNCH(a);
    6205     SetFS(sel);
    6206 
    6207     return yyrc;
    6208 } 
     6229    yyrc = MouSynch(a);
     6230    SetFS(sel);
     6231
     6232    return yyrc;
     6233}
    62096234
    62106235#undef  MouSynch
     
    62136238#endif
    62146239
    6215 #endif
     6240#ifdef __cplusplus
     6241} // extern "C"
     6242#endif
     6243
     6244#endif
Note: See TracChangeset for help on using the changeset viewer.