home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / PasLibIntf.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  5.6 KB  |  252 lines  |  [TEXT/MPS ]
  1. {*-------------------------------------------------------------------------------*
  2.  |                                                                                 |
  3.  |                          <<< Pascal Library Interface >>>                         |
  4.  |                                                                                 |
  5.  |                      Copyright Apple Computer, Inc. 1986, 1992                  |
  6.  |                               All rights reserved.                              |
  7.  |                                                                                 |
  8.  *-------------------------------------------------------------------------------*}
  9.  
  10. {
  11.  Interface to the Pascal I/O and Memory Manager Library.
  12.  Built-in procedure and function declarations are marked with
  13.  the (* *) comment characters
  14. }
  15.  
  16. {$IFC UNDEFINED UsingIncludes}
  17. {$SETC UsingIncludes := 0}
  18. {$ENDC}
  19.  
  20. {$IFC NOT UsingIncludes}
  21.     UNIT PasLibIntf;
  22.       INTERFACE
  23. {$ENDC}
  24.  
  25. {$IFC UNDEFINED __PasLibIntf__}
  26. {$SETC __PasLibIntf__ := 1}
  27.  
  28. {$I+}
  29. {$SETC PASLIBINTFIncludes := UsingIncludes}
  30. {$SETC UsingIncludes := 1}
  31. {$IFC UNDEFINED __TYPES__ }
  32. {$I Types.p}
  33. {$ENDC}
  34.  
  35. {$IFC UNDEFINED __FILES__ }
  36. {$I Files.p}
  37. {$ENDC}
  38.  
  39. {$IFC UNDEFINED __ALIASES__}
  40. {$I Aliases.p}
  41. {$ENDC}
  42.  
  43. {$SETC UsingIncludes := PASLIBINTFIncludes}
  44.  
  45.     TYPE
  46.       PASCALPOINTER = ^INTEGER; { Universal POINTER type }
  47.       PASCALFILE = FILE; { Universal FILE type }
  48. (*
  49.  *      PASCALBLOCK =    { Universal block of chars }
  50.  *            PACKED ARRAY [0..511] OF CHAR;
  51.  *)
  52.  
  53.     CONST
  54.       { <StdIO.h> PLSetVBuf styles }
  55.       _IOFBF = $00; { File buffering }
  56.       _IOLBF = $40; { Line buffering }
  57.       _IONBF = $04; { No buffering }
  58.  
  59. {
  60.  Mac Pascal heap management
  61. }
  62.  
  63.     PROCEDURE PLHeapInit(sizepheap: LONGINT; heapDelta: LONGINT;
  64.                          memerrProc: UNIV PASCALPOINTER; allowNonCont: BOOLEAN;
  65.                          forDispose: BOOLEAN);
  66. {
  67.  The following procedure is obsolete, use PLHeapInit
  68. }
  69.  
  70.     PROCEDURE PLInitHeap(sizepheap: LONGINT; memerrProc: UNIV PASCALPOINTER;
  71.                          allowNonCont: BOOLEAN; allowDispose: BOOLEAN);
  72.  
  73.     PROCEDURE PLSetNonCont(allowNonCont: BOOLEAN);
  74.  
  75.     PROCEDURE PLSetMErrProc(memerrProc: UNIV PASCALPOINTER);
  76.  
  77.     PROCEDURE PLSetHeapType(forDispose: BOOLEAN);
  78.  
  79.     PROCEDURE PLSetHeapCheck(DoIt: BOOLEAN);
  80.  
  81. {
  82.  File I/O
  83. }
  84.  
  85. (*
  86.  *      PROCEDURE
  87.  *        RESET(VAR fvar:  UNIV PASCALFILE; OPT fname: STRING);
  88.  *        BUILTIN;
  89.  *
  90.  *      PROCEDURE
  91.  *        REWRITE(VAR fvar: UNIV PASCALFILE; OPT fname: STRING);
  92.  *        BUILTIN;
  93.  *
  94.  *      PROCEDURE
  95.  *        OPEN(VAR fvar:    UNIV PASCALFILE; fname: STRING);
  96.  *        BUILTIN;
  97.  *)
  98.  
  99.     PROCEDURE PLSetVBuf(VAR fvar: TEXT; buffer: UNIV PASCALPOINTER;
  100.                         style: INTEGER; bufsize: INTEGER);
  101. (*
  102.  *      FUNCTION
  103.  *        BLOCKREAD(
  104.  *          VAR fvar: FILE;
  105.  *          VAR buffer: UNIV PASCALBLOCK;
  106.  *          nBlocks: INTEGER;
  107.  *          OPT stBlock:INTEGER
  108.  *        ):
  109.  *        INTEGER;
  110.  *        BUILTIN;
  111.  *
  112.  *      FUNCTION
  113.  *        BLOCKWRITE(
  114.  *          VAR fvar: FILE;
  115.  *          VAR buffer: UNIV PASCALBLOCK;
  116.  *          nBlocks: INTEGER;
  117.  *          OPT stBlock:INTEGER
  118.  *        ):
  119.  *        INTEGER;
  120.  *        BUILTIN;
  121.  *
  122.  *      FUNCTION
  123.  *        BYTEREAD(
  124.  *          VAR fvar: FILE;
  125.  *          VAR buffer: UNIV PASCALBLOCK;
  126.  *          nBytes:  LONGINT;
  127.  *          OPT stByte: LONGINT
  128.  *        ):
  129.  *        LONGINT;
  130.  *        BUILTIN;
  131.  *
  132.  *      FUNCTION
  133.  *        BYTEWRITE(
  134.  *          VAR fvar: FILE;
  135.  *          VAR buffer: UNIV PASCALBLOCK;
  136.  *          nBytes:  LONGINT;
  137.  *          OPT stByte: LONGINT
  138.  *        ):
  139.  *        LONGINT;
  140.  *        BUILTIN;
  141.  *
  142.  *      FUNCTION
  143.  *        EOF(OPT VAR fvar: UNIV PASCALFILE):
  144.  *        BOOLEAN;
  145.  *        BUILTIN;
  146.  *
  147.  *      FUNCTION
  148.  *        EOLN(OPT VAR fvar: TEXT):
  149.  *        BOOLEAN;
  150.  *        BUILTIN;
  151.  *
  152.  *      PROCEDURE
  153.  *        READ(VAR fvar: TEXT; OPT EXPR_LIST);
  154.  *        BUILTIN;
  155.  *
  156.  *      PROCEDURE
  157.  *        READLN(OPT VAR fvar: TEXT; OPT EXPR_LIST);
  158.  *        BUILTIN;
  159.  *
  160.  *      PROCEDURE
  161.  *        WRITE(VAR fvar: TEXT; OPT EXPR_LIST);
  162.  *        BUILTIN;
  163.  *
  164.  *      PROCEDURE
  165.  *        WRITELN(OPT VAR fvar: TEXT; OPT EXPR_LIST);
  166.  *        BUILTIN;
  167.  *
  168.  *      PROCEDURE
  169.  *        GET(VAR fvar: UNIV PASCALFILE);
  170.  *        BUILTIN;
  171.  *
  172.  *      PROCEDURE
  173.  *        PUT(VAR fvar: UNIV PASCALFILE);
  174.  *        BUILTIN;
  175.  *
  176.  *      PROCEDURE
  177.  *        SEEK(VAR fvar: UNIV PASCALFILE; recno: LONGINT);
  178.  *        BUILTIN;
  179.  *)
  180.  
  181.     FUNCTION PLFilePos(VAR fvar: UNIV PASCALFILE): LONGINT;
  182.  
  183.     PROCEDURE PLFlush(VAR fvar: TEXT);
  184.  
  185.     PROCEDURE PLCrunch(VAR fvar: UNIV PASCALFILE);
  186.     
  187. {
  188.  Directory operations.
  189. }
  190.  
  191.     PROCEDURE PLPurge(fname: STRING);
  192.  
  193.     PROCEDURE PLRename(oldFname, newFname: STRING);
  194.  
  195. {
  196.  Miscellaneous Operations
  197. }
  198.  
  199.     FUNCTION TrapAvailable(trap: INTEGER): BOOLEAN;
  200.  
  201.     FUNCTION ResolveFolderAliases (volume: INTEGER; directory: LONGINT;
  202.                                    path: Str255; resolveLeafName: BOOLEAN;
  203.                                    VAR theSpec: FSSpec; VAR isFolder, hadAlias,
  204.                                    leafIsAlias: BOOLEAN): OSErr; C;
  205.  
  206.     FUNCTION MakeResolvedFSSpec (volume: INTEGER; directory: LONGINT;
  207.                                  path: Str255; VAR theSpec: FSSpec; VAR isFolder,
  208.                                  hadAlias, leafIsAlias: BOOLEAN): OSErr; C;
  209.     
  210.     FUNCTION IEResolvePath (VAR rawPath: Str255; VAR resolvedPath: Str255;
  211.                             VAR isFolder, hadAlias: BOOLEAN): OSErr;
  212.  
  213.     FUNCTION MakeResolvedPath (volume: INTEGER; directory: LONGINT; path: Str255;
  214.                                resolveLeafAlias: BOOLEAN; VAR buffer: Str255;
  215.                                VAR isFolder, hadAlias, leafIsAlias: BOOLEAN):
  216.                                OSErr; C;
  217.  
  218. {
  219.  C string functions for Pascal strings
  220. }
  221.      FUNCTION PLStrCmp(string1, string2: STR255): INTEGER;
  222.  
  223.     FUNCTION PLStrnCmp(string1, string2: STR255; n: INTEGER): INTEGER;
  224.  
  225.     FUNCTION PLStrCpy(VAR string1: STR255; string2: STR255): STRINGPTR;
  226.  
  227.     FUNCTION PLStrnCpy(VAR string1: STR255; string2: STR255; n: INTEGER): STRINGPTR;
  228.  
  229.     FUNCTION PLStrCat(VAR string1: STR255; string2: STR255): STRINGPTR;
  230.  
  231.     FUNCTION PLStrnCat(VAR string1: STR255; string2: STR255; n: INTEGER): STRINGPTR;
  232.  
  233.     FUNCTION PLStrChr(string1: STR255; c: CHAR): PTR;
  234.  
  235.     FUNCTION PLStrrChr(string1: STR255; c: CHAR): PTR;
  236.  
  237.     FUNCTION PLStrPBrk(string1, string2: STR255): PTR;
  238.  
  239.     FUNCTION PLStrSpn(string1, string2: STR255): INTEGER;
  240.  
  241.     FUNCTION PLStrStr(string1, string2: STR255): PTR;
  242.  
  243.     FUNCTION PLStrLen(string1: STR255): INTEGER;
  244.     
  245.     FUNCTION PLPos(STRING1: STR255; STRING2: STR255): INTEGER;
  246.  
  247. {$ENDC}    { __PasLibIntf__ }
  248.  
  249. {$IFC NOT UsingIncludes}
  250.     END.
  251. {$ENDC}
  252.