home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / prog_c / alint.lzh / ALINT / MANX.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-01  |  24.6 KB  |  545 lines
  1. /* This is the modified sl-aztec.c file which I call "manx.c".  It includes *
  2.  * most (but probably not all) standard library, Aztec C68K, and Amiga      *
  3.  * specific functions.  DOS 1.2 functions are missing.  Some of the return  * 
  4.  * types may be incorrect.  Please correct any errors you find, add any     * 
  5.  * of the missing functions, and let me know of any changes so I can be     *
  6.  * current also. Bixmail to althoff.                                        *
  7.  *                                        * 
  8.  * Modified 7/2/86 by althoff                            *
  9.  *                                        *
  10.  ****************************************************************************/ 
  11. typedef struct { 
  12. char *_bp;
  13. char *_bend;
  14. char *_buff;
  15. char _flags;
  16. char _unit;
  17. char _bytbuf;
  18. short _buflen;
  19. char *_tmpname;
  20. } FILE;
  21. extern FILE Cbuffs[];
  22. FILE *fopen();
  23. long ftell();
  24. typedef void *UNIV;
  25. typedef char *STRING;
  26. typedef FILE *STREAM;/*lint -e715 *//*lint -e530 *//*lint -e533 */
  27. /*lint -library *//*lint +fvr */
  28. long lseek();
  29. long fseek();
  30. int fwrite();
  31. int close();
  32. int creat();
  33. STRING strcpy();
  34. STRING strcat();
  35. int putc();
  36. int aputc();
  37. int unlink();
  38. int write();/*lint +fva 
  39. */
  40. int fprintf() {}
  41. int printf() {}
  42. int sprintf() {}
  43. int scanf() {}
  44. int fscanf() {}
  45. int sscanf() {}/*lint -fvr *//*lint -fva */
  46. s_y_s_t_e_m()
  47. {
  48. int argc;
  49. STRING *argv;
  50. main( argc, argv );
  51. }
  52. FILE Cbuffs[];
  53. void flsh_(f,n) STREAM f; int n; { }
  54. long cList;
  55. char ctp_[];
  56. int agetc(f) STREAM f; {}
  57. int aputc( c, f) int c; STREAM f; {}
  58. double atof(s) STRING s; { }
  59. int atoi(s) STRING s; { }
  60. long atol(s) STRING s; { }
  61. UNIV calloc( n, m ) unsigned n,m; { }
  62. int close(fd) int fd; { }
  63. int creat( fname, mode ) STRING fname; int mode; { }
  64. void exit(n) int n; { }
  65. int getc(f) STREAM f; {}
  66. int getchar();
  67. STRING gets( buf) UNIV buf; { }
  68. int getw(stream) FILE *stream;{}
  69. int putc( c, f) int c; STREAM f; {}
  70. double fabs(x) double x; { }
  71. void fclose(f) STREAM f; {}
  72. STRING fgets( buf, len, f ) STRING buf; int len; STREAM f; { }
  73. STREAM fopen( name, mode ) STRING name, mode; { }
  74. void fputs( s, f) STRING s; STREAM f; {}
  75. int fread( p, sz, n, f ) UNIV p; int sz, n; STREAM f; {}
  76. STREAM freopen(name,mode,fp) STRING name, mode; STREAM fp; { }
  77. void free(p) UNIV p; {}
  78. long fseek( f, off, type) STREAM f; long off; int type; { }
  79. long ftell( f ) STREAM f; { }
  80. int fwrite( p, sz, n, f) UNIV p; int sz, n; STREAM f; { }
  81.  
  82. long lseek( fd, off, base ) int fd, base; long off; { }
  83. UNIV malloc(n) unsigned n; { }
  84. void movmem( p, q, n) UNIV p, q; unsigned n; { }
  85. int open( name, mode ) STRING name; int mode; { }
  86. void puts( s ) STRING s; {}
  87. int read( fd, buf, count ) int fd, count; UNIV buf; { }
  88. UNIV realloc( p, size ) UNIV p; unsigned size; { }
  89. STRING strcat( s1, s2 ) STRING s1, s2; { }
  90. int strcmp( s1, s2 ) STRING s1, s2; { }
  91. STRING strcpy( s1, s2 ) STRING s1, s2; { }
  92. int strlen( s ) STRING s; { }
  93. STRING strncat( s1, s2, n ) STRING s1, s2; int n; { }
  94. int strncmp( s1, s2, n ) STRING s1, s2; int n; { }
  95. STRING strncpy( s1, s2, n ) STRING s1, s2; int n; { }
  96. int tolower(c) char c; { }
  97. int toupper(c) char c; { }
  98. int unlink( nm ) STRING nm; { }
  99. void ungetc(c,stream) FILE *stream;{ }
  100. int write( fd, buf, count) int fd, count; UNIV buf; { }
  101.  
  102.  
  103. long AbleICR(mask) long mask;{}
  104. void AbortIO(ioRequest) struct IORequest *ioRequest;{}
  105. void AddAnimOb(anOb,anKey,rPort) struct AnimOb *anOb, **anKey;
  106. struct RastPort *rPort;{}
  107. void AddBob(bob,rPort) struct Bob*bob; struct RastPort *rPort; {}
  108. void AddDevice(device) struct Device *device;{}
  109. void AddFont(textFont) struct TextFont *textFont;{}
  110. short AddFreeList(free,mem,len) struct FreeList *free;char *mem;long len;{}
  111. short AddGadget(pntr,gadget,position) struct Window *pntr;struct Gadget *gadget;
  112. long position;{}
  113. void AddHead(list,node) struct List *list; struct Node *node;{}
  114. struct Interrupt * AddICRVector(iCRBit, interrupt) long iCRBit;
  115. struct Interrupt *interrupt;{}
  116. void AddIntServer(intNum,interrupt) long intNum;struct Interrupt *interrupt;{}
  117. void AddLibrary(library) struct Library *library;{}
  118. void AddPort(port) struct MsgPort *port;{}
  119. void AddResource(resource) struct MiscResource *resource;{}
  120. void AddTail(list,node) struct List *list;struct Node *node;{}
  121. void AddTask(task,initialPC,finalPC) struct Task *task;long initialPC,finalPC;{}
  122. void AddTime(dest,source) struct TimeVal *dest, *source;{}
  123. void AddVSprite(vs,rPort)
  124. struct VSprite *vs; struct RastPort *rPort;{}
  125. long Alert(alertNum,parameters) long alertNum,parameters;{}
  126. void * AllocAbs(bytSiz,location) long bytSiz; char *location;{}
  127. long AllocCList(cLPool) long cLPool;{}
  128. struct MemList * AllocEntry(memList) struct MemList *memList;{}
  129. void * AllocMem(byteSize,requirements) long byteSize,requirements;{}
  130. long AllocPotBits(bits) long bits;{}
  131. void AllocRaster(width,height) long width,height;{}
  132. char * AllocRemember(rememberKey, size, flags) struct Remember *rememberKey;
  133. long size, flags;{}
  134. long AllocSignal(signalNum) long signalNum;{}
  135. long AllocTrap(trapNum) long trapNum;{}
  136. struct WBObject * AllocWBObject();
  137. void * Allocate(freeList,byteSize)struct List *freeList;long byteSize;{}
  138. void AlohaWorkBench(wbPort) struct MsgPort *wbPort;{}
  139. void AndRectRegion(region, rectangle)
  140. struct Region *region; struct Rectangle *rectangle;{}
  141. void Animate(key,rPort) struct AnimOb **key; struct RastPort *rPort;{}
  142. short AreaDraw(rp,x,y) struct RastPort *rp; long x,y;{}
  143. void AreaEnd(rp) struct RastPort *rp;{}
  144. short AreaMove(rp,x,y) struct RastPort *rp; long x,y;{}
  145. void AskFont(rp,textAttr)struct RastPort *rp; struct TextAttr *textAttr;{}
  146. long AskSoftStyle(rp) struct RastPort *rp;{}
  147. short AutoRequest(window,body,positive,negative,posFlags,negFlags,width,height)
  148. struct Window *window; struct IntuiText *body,*positive,*negative;
  149. long posFlags,negFlags,width,height;{}
  150. long AvailFonts(buffer,bufBytes,types)char *buffer;long bufBytes,types;{}
  151. long AvailMem(requirements) long requirements;{}
  152. void BeginIO(ioRequest) struct IORequest *ioRequest;{}
  153. void BeginRefresh(window) struct Window *window;{}
  154. void BeginUpdate(l) struct Layer *l;{}
  155. void BehindLayer(li,l) struct LayerInfo *li;struct Layer *l;{}
  156. long BltBitMap(srcBM,srcX,srcY,dstBM,dstX,dstY,sizX,sizY,minTerm,mask,tempA)
  157. struct BitMap *srcBM,*dstBM;long srcX,srcY,dstX,dstY,sizX,sizY,minTerm;{}
  158. long BltBitMapRastPort(srcBitMap,srcX,srcY,dstBitMap,dstX,dstY,sizX,sizY,
  159. minTerm)
  160. struct BitMap *srcBitMap,*dstBitMap;long srcX,srcY,dstX,dstY,sizX,sizY,
  161. minTerm;{}
  162. void BltClear(memBlock,byteCount,flags) char *memBlock;long byteCount,flags;{}
  163. void BltPattern(rp,buf,x1,y1,maxX,maxY,byteCnt)struct RastPort *rp;char *buf;
  164. long x1,y1,maxX,maxY,byteCnt;{}
  165. void BltTemplate(src,srcX,srcMod,dstRastPort,dstX,dstY,sizX,sizY)
  166. char *src;struct RastPort *dstRastPort;
  167. long srcX,srcMod,dstX,dstY,sizX,sizY;{}
  168. struct Window * BuildSysRequest(wind,body,positive,negative,flags,width,height)
  169. struct Window *wind;struct IntuiText *body,*positive, *negative;
  170. long flags,width,height;{}
  171. char * BumpRevision(newbuf,oldname) char *newbuf,*oldname;{}
  172. void CBump(c) struct UCopList *c;{}
  173. void CDInputHandler(events,consoleDevice) struct Events *events;
  174. struct Device *consoleDevice;{}
  175. void Cmove(c,a,v) struct UCopList *c; long *a,v;{}
  176. void CWait(c,v,h) struct UCopList *c; long v,h;{}
  177. void Cause(interrupt) struct Interrupt *interrupt;{}
  178. void ChangeSprite(vp,s,newdata) struct ViewPort *vp;struct SimpleSprite *s;
  179. struct spriteimage *newdata;{}
  180. struct IORequest* CheckIO(ioRequest) struct IORequest *ioRequest;{}
  181. short ClearDMRequest(window) struct Window *window;{}
  182. void ClearEOL(rp) struct RastPort *rp;{}
  183. void ClearMenuStrip(window) struct Window *window;{}
  184. void ClearPointer(window) struct Window *window;{}
  185. void ClearRegion(region) struct Region *region;{}
  186. void ClearScreen(rp) struct RastPort *rp;{}
  187. void ClipBlit(src,srcX,srcY,dst,dstX,dstY,xSize,ySize,mode)
  188. struct RastPort *src,*dst;long srcX,srcY,dstX,dstY,xSize,ySize,mode;{}
  189. void Close(file) struct fileHandle *file;{}
  190. void CloseDevice(ioRequest) struct IORequest *ioRequest;{}
  191. void CloseFont(font) struct Font *font;{}
  192. void CloseLibrary(library) struct Library *library;{}
  193. void CloseScreen(screen) struct Screen *screen;{}
  194. void CloseWindow(window) struct Window *window;{}
  195. void CloseWorkBench();
  196. short CmpTime(dest,source) struct TimeVal *dest,*source;{}
  197. long concatCList(sourceCList,destCList) long sourceCList,destCList;{}
  198. long CopyCList(cList) long cList;{}
  199. void CopySBitMap(layer) struct Layer *layer;{}
  200. void CreateBehindLayer(li,bm,x0,y0,x1,y1,flags) struct LayerInfo *li;
  201. struct BitMap *bm; long x0,y0,x1,y1,flags;{}
  202. struct Lock * CreateDir(name) char *name;{}
  203. struct MsgPort* CreatePort(name,pri) char *name; long pri;{}
  204. struct Process * CreateProc(name,pri,segment,stackSize) char *name;
  205. struct Segment *segment; long pri,stackSize;{}
  206. struct IOStdReq * CreateStdIO(mp) struct MsgPort *mp;{}
  207. struct Task * CreateTask(name,pri,start_pc,stksiz) char *name;
  208. long pri,start_pc,stksiz;{}
  209. void CreateUpfrontLayer(li,bm,x0,y0,x1,y1,flags) struct LayerInfo *li;
  210. struct BitMap *bm; long x0,y0,x1,y1,flags;{}
  211. struct Lock * CurrentDir(lock) struct Lock *lock;{}
  212. void CurrentTime(seconds,micros) unsigned long *seconds, *micros;{}
  213. long * DateStamp(v) long *v;{}
  214. void Deallocate(freeList,memoryBlock,byteSize) struct List *freeList;
  215. char *memoryBlock; long byteSize;{}
  216. void Debug();
  217. void Delay(timeout) long timeout;{}
  218. short DeleteFile(name) char *name;{}
  219. void DeleteLayer(li,l)struct LayerInfo *li;struct Layer *l;{}
  220. void DeletePort(port) struct MsgPort *port;{}
  221. void DeleteStdIO(iop) struct IOStdReq *iop;{}
  222. void DeleteTask(tp) struct Task *tp;{}
  223. struct Process * DeviceProc(name) char *name;{}
  224. void Disable();
  225. void DisownBlitter();
  226. void DisplayAlert(alertNumber,string,height)long alertNumber;
  227. char *string; long height;{}
  228. void DisplayBeep(screen) struct Screen *screen;{}
  229. void DisposeRegion(region) struct Region *region;{}
  230. void DoCollision(rPort) struct RastPort *rPort;{}
  231. long DoIO(ioRequest) struct IORequest *ioRequest;{}
  232. short DoubleClick(startSeconds,startMicros,currentSeconds,currentMicros)
  233. unsigned long startSeconds,startMicros,currentSeconds,currentMicros;{}
  234. void Draw(rp,x,y) struct RastPort *rp; long x,y;{}
  235. void DrawBorder(rp,b,leftOffset,topOffset) struct RastPort *rp;
  236. struct Border *b; long leftOffset, topOffset;{}
  237. void DrawGList(rPort,vPort)struct RastPort *rPort;struct ViewPort *vPort;{}
  238. void DrawImage(rp,image,leftOffset,topOffset)struct RastPort *rp;
  239. struct Image *image; long leftOffset,topOffset;{}
  240. struct Lock * DupLock(lock) struct Lock *lock;{}
  241. void Enable();
  242. void EndRefresh(window,complete) struct Window *window; long complete;{}
  243. void EndUpdate(l,flag) struct Layer *l; long flag;{}
  244. void Enqueue(list,node) struct List *list;struct Node *node;{}
  245. short ExNext(lock,fileInfoBlock) struct Lock *lock;
  246. struct FileInfoBlock *fileInfoBlock;{}
  247. short Examine(lock,fileInfoBlock)struct Lock *lock;
  248. struct FileInfoBlock *fileInfoBlock;{}
  249. short Execute(commandString,input,output) char *commandString;
  250. struct FileHandle *input, *output;{}
  251. void Exit(returnCode) long returnCode;{}
  252. struct Node * FindName(list,name) struct List *list;char *name;{}
  253. struct MsgPort * FindPort(name) char *name;{}
  254. struct Task* FindTask(name) char *name;{}
  255. char * FindToolType(toolTypeArray,typeName)char **toolTypeArray,*typeName;{}
  256. void Flood(rp,mode,x,y) struct RastPort *rp; long mode,x,y;{}
  257. void FlushCList(cList) long cList;{}
  258. void Forbid();
  259. void FreeCList(cList) long cList;{}
  260. void FreeCPrList(cprList) struct CprList *cprList;{}
  261. void FreeDiskObject(diskobj) struct DiskObject *diskobj;{}
  262. void FreeEntry(memList) struct MemList *memList;{}
  263. void FreeGBuffers(anOb,rPort,db)struct AnimOB *anOb;
  264. struct RastPort *rPort; long db;{}
  265. void FreeMem(memoryBlock,sizeBytes) char *memoryBlock; long sizeBytes;{}
  266. void FreePotBits(allocated) long allocated;{}
  267. void FreeRaster(p,width,height) char *p;long width,height;{}
  268. void FreeRemember(key,reallyForget) struct Remember *key;long reallyForget;{}
  269. void FreeSignal(signalNum) long signalNum;{}
  270. void FreeSprite(pick) long pick;{}
  271. void FreeSysRequest(wind) struct Window *wind;{}
  272. void FreeTrap(trapNum) long trapNum;{}
  273. void FreeVPortCopLists(viewPort) struct ViewPort *viewPort;{}
  274. void FreeWBObject(obj) struct WBObject *obj;{}
  275. long GetCC();
  276. long GetCLBuf(cList,buffer,maxlength) long cList;char *buffer;long maxlength;{}
  277. short GetCLChar(cList) long cList;{}
  278. short GetCLWord(cList) long cList;{}
  279. struct ColorMap * GetColorMap(entries) long entries;{}
  280. struct Preferences * GetDefPrefs(prefBuffer,size) char *prefBuffer;long size;{}
  281. struct DiskObject * GetDiskObject(name) char *name;{}
  282. void GetGBuffers(anOb,rPort,db) struct AnimOb *anOb;
  283. struct RastPort *rPort; long db;{}
  284. short GetIcon(name,icon,free) char *name;struct DiskObject *icon;
  285. struct FreeList *free;{}
  286. struct Message* GetMsg(port) struct MsgPort *port;{}
  287. struct Preferences* GetPrefs(buffer,size)struct Preferences *buffer;long size;{}
  288. short GetSprite(sprite,pick) struct SimpleSprite *sprite; long pick;{}
  289. struct WBObject * GetWBObject(name) char *name;{}
  290. long IncrCLMark(cList) long cList;{}
  291. short Info(lock,info_Data) struct Lock *lock;struct Info_Data *info_Data;{}
  292. void InitArea(areaInfo,buffer,maxVectors) struct AreaInfo *areaInfo;
  293. char *buffer; long maxVectors;{}
  294. void InitBitMap(bm,depth,width,height) struct BitMap *bm;
  295. long depth,width, height;{}
  296. long InitCLPool(cLPool,size) struct cLPool *cLPool; long size;{}
  297. void InitCode(startClass,version) long startClass, version;{}
  298. void InitGMasks(anOb) struct AnimOb *anOb;{}
  299. void InitGels(head,tail,gInfo)struct VSprite *head,*tail;
  300. struct GelsInfo *gInfo;{}
  301. void InitMasks(vs) struct VSprite *vs;{}
  302. void InitRastPort(rp) struct RastPort *rp;{}
  303. void InitRequester(req) struct Requester *req;{}
  304. void InitResident(resident,segList) long resident, segList;{}
  305. void InitStruct(initTable,memory,size) short *initTable;
  306. char *memory; long size;{}
  307. void InitTmpRas(tmpRas,buffer,size)struct TmpRas *tmpRas;
  308. char *buffer; long size;{}
  309. void InitVPort(vp) struct ViewPort *vp;{}
  310. void InitView(view) struct View *view;{}
  311. struct FileHandle * Input();
  312. void Insert(list,node,listNode) struct List *list;
  313. struct Node *node, *listNode;{}
  314. long IntuiTextLength(iText) struct IntuiText *iText;{}
  315. struct InputEvent* Intuition(inputEvent) struct InputEvent *inputEvent;{}
  316. long IoErr();
  317. short IsInteractive(file) struct FileHandle *file;{}
  318. struct MenuItem* ItemAddress(menuStrip,menuNumber) struct Menu *menuStrip;
  319. long menuNumber;{}
  320. void LoadRGB4(vp,colorMap,count) struct ViewPort *vp;
  321. struct ColorMap *colorMap; long count;{}
  322. struct Segment * LoadSeg(name) char *name;{}
  323. void LoadView(view) struct View *view;{}
  324. struct Lock * Lock(name,accessMode) char *name; long accessMode;{}
  325. void LockLayer(li,l) struct LayerInfo *li; struct Layer *l;{}
  326. void LockLayerInfo(li) struct LayerInfo *li;{}
  327. void LockLayerRom(layer) struct Layer *layer;{}
  328. void LockLayers(li) struct LayerInfo *li;{}
  329. struct Library * MakeLibrary(vectors,structure,libInit,dataSize,segList)
  330. void(*vectors[])(),(*libInit)(); short *structure;
  331. long dataSize; struct MemList *segList;{}
  332. void MakeScreen(screen) struct Screen *screen;{}
  333. void MakeVPort(view,viewPort) struct View *view;struct ViewPort *viewPort;{}
  334. long MarkClist(cList,offset) long cList; long offset;{}
  335. long MatchToolValue(typeString,value) char *typeString, *value;{}
  336. void ModifyIDCMP(wind,IDCMPFlags)struct Window *wind;long IDCMPFlags;{}
  337. void ModifyProp(gad,wind,req,flags,horizPot,vertPot,horizBody,verBody)
  338. struct Gadget *gad; struct Window *wind; struct Requester *req;
  339. long flags, horizPot, vertPot, horizBody, verBody;{}
  340. void Move(rp,x,y) struct RastPort *rp; long x,y;{}
  341. void MoveLayer(li,l,dx,dy) struct LayerInfo *li;struct Layer *l;long dx,dy;{}
  342. void MoveScreen(screen,deltaX,deltaY)struct Screen *screen;long deltaX,deltaY;{}
  343. void MoveSprite(vp,sprite,x,y) struct ViewPort *vp;
  344. struct SimpleSprite *sprite; long x,y;{}
  345. void MoveWindow(wind,deltaX,deltaY) struct Window *wind;long deltaX,deltaY;{}
  346. void MrgCop(view) struct View *view;{}
  347. void NewList(list) struct List *list;{}
  348. struct Region * NewRegion();
  349. void NotRegion(rgn) struct Region *rgn;{}
  350. void OffGadget(gad,wind,req) struct Gadget *gad;struct Window *wind;
  351. struct Requester *req;{}
  352. void OffMenu(wind,menuNumber) struct Window *wind; long menuNumber;{}
  353. void OnGadget(gad,wind,req) struct Gadget *gad;struct Window *wind;
  354. struct Requester *req;{}
  355. void OnMenu(wind,menuNumber) struct Window *wind; long menuNumber;{}
  356. struct FileHandle * Open(name,accessMode) char *name; long accessMode;{}
  357. long OpenDevice(name,unitNumber,ioRequest,flags) char *name;
  358. struct IORequest *ioRequest;
  359. long unitNumber,flags;{}
  360. struct Font * OpenDiskFont(textAttr) struct TextAttr *textAttr;{}
  361. struct Font * OpenFont(textAttr) struct TextAttr *textAttr;{}
  362. void OpenIntuition();
  363. struct Library * OpenLibrary(libName, version) char *libName;long version;{}
  364. struct MiscResource * OpenResource(resName) char *resName;{}
  365. struct Screen* OpenScreen(newScreen) struct NewScreen *newScreen;{}
  366. struct Window* OpenWindow(newWindow) struct NewWindow *newWindow;{}
  367. short OpenWorkbench();
  368. void OrRectRegion(region,rectangle) struct Region *region;
  369. struct Rectangle *rectangle;{}
  370. struct FileHandle * Output();
  371. void OwnBlitter();
  372. struct Lock * ParentDir(lock) struct Lock *lock;{}
  373. short PeekCLMark(cList) long cList;{}
  374. void Permit();
  375. void PolyDraw(rp,count,array) struct RastPort *rp; long count,array[][];{}
  376. void PrintText(rp,iText,leftEdge,topEdge) struct RastPort *rp;
  377. struct IntuiText *iText; long leftEdge,topEdge;{}
  378. long PutCLBuf(cList,buffer,length)char *buffer;long length,cList;{}
  379. long PutCLChar(cList,byte) long cList,byte;{}
  380. long PutCLWord(cList,word) long cList,word;{}
  381. short PutDiskObject(name,diskobj) char *name;struct DiskObject *diskobj;{}
  382. short PutIcon(name,icon) char *name; struct DiskObject *icon;{}
  383. void PutMsg(port,message) struct MsgPort *port; struct Message *message;{}
  384. short PutWBObject(name,object) char *name;struct WBObject *object;{}
  385. void QBSBlit(bsp) struct Blit *bsp;{}
  386. void QBlit(bp) struct Blit *bp;{}
  387. short RawKeyConvert(events,buffer,length,keyMap) struct InputEvent *events;
  388. char *buffer; long length; struct KeyMap *keyMap;{}
  389. long Read(file,buffer,length) struct FileHandle *file;char *buffer;
  390. long length;{}
  391. short ReadPixel(rp,x,y) struct RastPort *rp; long x,y;{}
  392. void RectFill(rp,xMin,yMin,xMax,yMax) struct RastPort *rp;
  393. long xMin,yMin,xMax,yMax;{}
  394. void RefreshGadgets(gad,wind,req) struct Gadgets *gad; struct Window *wind;
  395. struct Requester *req;{}
  396. void RemDevice(device) struct Device *device;{}
  397. void RemFont(textFont) struct TextFont *textFont;{}
  398. void RemHead(list) struct List *list;{}
  399. void RemBob(bob,rPort,vPort) struct Bob *bob; struct RastPort *rPort;
  400. struct ViewPort *vPort;{}
  401. void RemICRVector(iCRBit,interrupt)long iCRBit;struct Interrupt *interrupt;{}
  402. void RemIntServer(intNum,interrupt)long intNum;struct Interrupt *interrupt;{}
  403. long RemLibrary(library) struct Library *library;{}
  404. void RemPort(port) struct MsgPort *port;{}
  405. void RemResource(resource) struct MiscResource *resource;{}
  406. struct Node * RemTail(list) struct List *list;{}
  407. void RemTask(task) struct Task *task;{}
  408. void RemVSprite(vs) struct VSprite *vs;{}
  409. void RemakeDisplay();
  410. void Remove(list,node) struct List *list; struct Node *node;{}
  411. unsigned short RemoveGadget(wind,gad) struct Window *wind;struct Gadget *gad;{}
  412. short Rename(oldName,newName)char *oldName, *newName;{}
  413. void ReplyMsg(message) struct Message *message;{}
  414. void ReportMouse(wind,boolean) struct Window *wind;long boolean;{}
  415. short Request(req,wind) struct Requester *req; struct Window *wind;{}
  416. void RethinkDisplay();
  417. void ScreenToBack(screen) struct Screen *screen;{}
  418. void ScreenToFront(screen) struct Screen *screen;{}
  419. void ScrollLayer(li,l,dx,dy)struct LayerInfo *li;struct Layer *l;long dx,dy;{}
  420. void ScrollRaster(rp,dx,dy,xMin,yMin,xMax,yMax) struct RastPort *rp;
  421. long dx,dy,xMin,yMin,xMax,yMax;{}
  422. void ScrollVPort(vp) struct ViewPort *vp;{}
  423. long Seek(file,position,mode) struct FileHandle *file;long position,mode;{}
  424. void SendIO(ioRequest) struct IORequest *ioRequest;{}
  425. void SetAPen(rp,pen) struct RastPort *rp; long pen;{}
  426. void SetBPen(rp,pen) struct RastPort *rp; long pen;{}
  427. void SetCollision(num,routine,gInfo)long num,(*routine)();
  428. struct GelsInfo *gInfo;{}
  429. short SetComment(name,comment)char *name,*comment;{}
  430. short SetDMRequest(wind,DMRequester)struct Window *wind;
  431. struct Requester *DMRequester;{}
  432. void SetDrMd(rp,mode) struct RastPort *rp; long mode;{}
  433. long SetExcept(newSignals,signalMask)long newSignals,signalMask;{}
  434. long SetFont(rp,font) struct RastPort *rp; struct TextFont *font;{}
  435. long SetFunction(library,funcOffset,funcEntry)struct Library *library;
  436. long funcOffset; void (*funcEntry)();{}
  437. long SetICR(mask) long mask;{}
  438. struct Interrupt * SetIntVector(intNumber,interrupt)long intNumber;
  439. struct Indterrupt *interrupt;{}
  440. void SetMenuStrip(wind,menu) struct Window *wind; struct Menu *menu;{}
  441. void SetPointer(wind,sp,height,width,xOffset, yOffset)
  442. struct Window *wind; struct Sprite *sp;
  443. long height,width, xOffset, yOffset;{}
  444. void SetPrefs(p,size,realThing)struct Preferences *p;long size,realThing;{}
  445. short SetProtection(name,mask) char *name; long mask;{}
  446. void SetRGB4(vp,n,r,g,b)struct ViewPort *vp;long n,r,g,b;{}
  447. void SetRast(rp,pen) struct RastPort *rp; long pen;{}
  448. long SetSR(newSR,mask) long newSR, mask;{}
  449. long SetSignal(newSignals,signalMask)long newSignals,signalMask;{}
  450. long SetSoftStyle(rp,style,enable)struct RastPort *rp;long style,enable;{}
  451. short SetTaskPri(task,priority)struct Task *task; long priority;{}
  452. void SetWindowTitles(wind,windowTitle,screenTitle) struct Window *wind;
  453. char *windowTitle, *screenTitle;{}
  454. void ShowTitle(screen, showIt) struct Screen *screen; long showIt;{}
  455. void Signal(task,signals) struct Task *task; long signals;{}
  456. long SizeCList(cList) long cList;{}
  457. void SizeLayer(li,l,dx,dy) struct LayerInfo *li;struct Layer *l;long dx,dy;{}
  458. void SizeWindow(wind,deltaX,deltaY)struct Window *wind;long deltaX,deltaY;{}
  459. void SortGList(rPort) struct RastPort *rPort;{}
  460. long SplitCList(cList) long cList;{}
  461. long SubCList(cList,index,length) long cList,index, length;{}
  462. void SubTime(dest,source) struct TimeVal *dest, *source;{}
  463. void SumLibrary(library) struct Library *library;{}
  464. long SuperState();
  465. void SwapBitsRastPortClipRect(li)struct LayerInfo *li;{}
  466. void SyncSBitMap(layer) struct Layer *layer;{}
  467. long Text(rp,string,count) struct RastPort *rp; char *string; long count;{}
  468. long TextLength(rp,string,count) struct RastPort *rp;
  469. char *string; long count;{}
  470. long Translate(instring,inlen,outbuf,outlen) char *instring, *outbuf;
  471. long inlen, outlen;{}
  472. long UnGetCLChar(cList,byte) long cList,byte;{}
  473. long UnGetCLWord(cList,word) long cList,word;{}
  474. void UnLoadSeg(segment) struct Segment *segment;{}
  475. void UnLock(lock) struct Lock *lock;{}
  476. short UnPutCLChar(cList) long cList;{}
  477. short UnPutCLWord(cList) long cList;{}
  478. void UnlockLayer(l) struct Layer *l;{}
  479. void UnlockLayerInfo(li) struct LayerInfo *li;{}
  480. void UnlockLayerRom(layer) struct LayerInfo *layer;{}
  481. void UnlockLayers(li) struct LayerInfo *li;{}
  482. void UpfrontLayer(li,l) struct LayerInfo *li;struct Layer *l;{}
  483. void UserState(sysStack) long sysStack;{}
  484. short VBeamPos();
  485. struct View* ViewAddress();
  486. struct View* ViewPortAddress(wind) struct Window *wind;{}
  487. short WBenchToBack();
  488. short WBenchToFront();
  489. long Wait(signalSet) long signalSet;{}
  490. void WaitBOVP(viewPort) struct ViewPort *viewPort;{}
  491. void WaitBlit();
  492. short WaitForChar(file,timeout)struct FileHandle *file;long timeout;{}
  493. long WaitIO(ioRequest) struct IORequest *ioRequest;{}
  494. struct Message* WaitPort(port) struct MsgPort *port;{}
  495. void WaitTOF();
  496. struct Layer * WhichLayer(li,x,y)struct LayerInfo *li;long x,y;{}
  497. short WindowLimits(wind,minWidth,minHeight,maxWidth,maxHeight)
  498. struct Window *wind; long minWidth,minHeight,maxWidth,maxHeight;{}
  499. void WindowToBack(wind) struct Window *wind;{}
  500. void WindowToFront(wind) struct Window *wind;{}
  501. long Write(file,buffer,length) struct FileHandle *file; char *buffer;
  502. long length;{}
  503. void WritePixel(rp,x,y)struct RastPort *rp;long x,y;{}
  504. void WritePotgo(word,mask) long word,mask;{}
  505. void XorRectRegion(region,rectangle)struct Region *region;
  506. struct Rectangle *rectangle;{}/*lint -restore */
  507. /*lint -e715 -e533 */
  508. int access(filename, mode) char *filename; int mode;{}
  509. void assert(expr) int expr; {}
  510. void *sbrk(size) unsigned int size; {}/*lint -e??? */
  511. void execl(name,arg0,arg1,arg2,...,argn,) char *name,*arg0,*arg1,*arg2,...;{}
  512. void execlp(name,arg0,arg1,arg2,...,argn,) char *nam,*arg0,*arg1,*arg2,...;{}
  513. int fexecl(name,arg0,arg1,arg2,...,argn,) char *name,*arg0,*arg1,*arg2,...,;{}
  514. /*lint -restore */
  515. /*lint -e715 -e533 */
  516. void execv(name,argv) char *name,*argv[];{}
  517. void execvp(name,argv) char *name,*argv[];{}
  518. int fexecv(name,argv) char *name, *argv[]; {}
  519. char *getenv(name) char *name; {}
  520. char *mktemp(template) char *template; {}
  521. int perror(s) char *s;{}
  522. char *scdir(pat) char *pat;{}
  523. void scr_beep();
  524. void scr_bs();
  525. void scr_tab();
  526. void scr_lf();
  527. void scr_cursup();
  528. void scr_cursrt();
  529. void scr_cr();
  530. void scr_clear();
  531. void scr_home();
  532. void scr_eol();
  533. void scr_linsert();
  534. void scr_ldelete();
  535. void scr_cinsert();
  536. void scr_cdelete();
  537. void scr_curs(lin,col) int lin, col; {}
  538. long time(tloc) long *tloc;{} 
  539. char *ctime(clock) long *clock;{}
  540. struct tm *localtime(clock) long *clock;{}
  541. struct tm *gmtime(clock) long *clock;{}
  542. char *asctime(t) struct tm *t; {}
  543. FILE *tmpfile();
  544. char *tmpnam(s) char *s; {}/*lint -restore */
  545.