![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HFSUtilities.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / hfs / hfscommon / Misc|
Return to HFSUtilities.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / hfs / hfscommon / Misc |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: File: HFSUtilities.c
27:
28: Contains: xxx put contents here xxx
29:
30: Version: HFS Plus 1.0
31:
32: Copyright: � 1997 by Apple Computer, Inc., all rights reserved.
33:
34: File Ownership:
35:
36: DRI: Don Brady
37:
38: Other Contacts: Mark Day, Deric Horn
39:
40: Technology: xxx put technology here xxx
41:
42: Writers:
43:
44: (DSH) Deric Horn
45: (msd) Mark Day
46: (djb) Don Brady
47:
48: Change History (most recent first):
49:
50: <Rhap> 3/31/98 djb Sync up with final HFSVolumes.h header file.
51: <CS13> 9/9/97 msd Make PascalBinaryCompare and UnicodeBinaryCompare faster.
52: <CS12> 9/7/97 djb Conditionalize DebugStrs to DEBUG_BUILD.
53: <CS11> 9/4/97 msd Add U64SetU routine.
54: <CS10> 8/18/97 DSH Conditionalizedout Math64 routines already compiled for DFA.
55: <CS9> 7/22/97 msd LocalToUTC and UTCToLocal are now functions (not macros) so that
56: they can pin their outputs.
57: <CS8> 7/21/97 djb Add U64Add and U64Subtract (used by instrumentation).
58: <CS7> 7/18/97 msd Include LowMemPriv.h.
59: <CS6> 7/16/97 DSH FilesInternal.i renamed FileMgrInternal.i to avoid name
60: collision
61: <CS5> 7/8/97 DSH Loading PrecompiledHeaders from define passed in on C line
62: <CS4> 6/9/97 msd Add GetTimeUTC and GetTimeLocal.
63: <CS3> 5/23/97 djb Fixing ClearMemory bug - it was clearing an extra byte!
64: <CS2> 5/16/97 msd Include FilesInternal.h
65: <CS1> 4/24/97 djb first checked in
66: <HFS1> 3/31/97 djb first checked in
67: */
68:
69: #if ( PRAGMA_LOAD_SUPPORTED )
70: #pragma load PrecompiledHeaders
71: #else
72: #if TARGET_OS_MAC
73: #include <Types.h>
74: #include <LowMemPriv.h>
75: #else
76: #include "../headers/system/MacOSStubs.h"
77: #endif /* TARGET_OS_MAC */
78: #endif /* PRAGMA_LOAD_SUPPORTED */
79:
80:
81: #include "../headers/HFSVolumes.h"
82: #include "../headers/FileMgrInternal.h"
83:
84:
85: /*-------------------------------------------------------------------------------
86: Routine: ClearMemory - clear a block of memory
87:
88: -------------------------------------------------------------------------------*/
89:
90: void ClearMemory( void* start, UInt32 length )
91: {
92: UInt32 zero = 0;
93: UInt32* dataPtr;
94: UInt8* bytePtr;
95: UInt32 fragCount; // serves as both a length and quadlong count
96: // for the beginning and main fragment
97:
98: if ( length == 0 )
99: return;
100:
101: // is request less than 4 bytes?
102: if ( length < 4 ) // length = 1,2 or 3
103: {
104: bytePtr = (UInt8 *) start;
105:
106: do
107: {
108: *bytePtr++ = zero; // clear one byte at a time
109: }
110: while ( --length );
111:
112: return;
113: }
114:
115: // are we aligned on an odd boundry?
116: fragCount = (UInt32) start & 3;
117:
118: if ( fragCount ) // fragCount = 1,2 or 3
119: {
120: bytePtr = (UInt8 *) start;
121:
122: do
123: {
124: *bytePtr++ = zero; // clear one byte at a time
125: ++fragCount;
126: --length;
127: }
128: while ( (fragCount < 4) && (length > 0) );
129:
130: if ( length == 0 )
131: return;
132:
133: dataPtr = (UInt32*) (((UInt32) start & 0xFFFFFFFC) + 4); // make it long word aligned
134: }
135: else
136: {
137: dataPtr = (UInt32*) ((UInt32) start & 0xFFFFFFFC); // make it long word aligned
138: }
139:
140: // At this point dataPtr is long aligned
141:
142: // are there odd bytes to copy?
143: fragCount = length & 3;
144:
145: if ( fragCount )
146: {
147: bytePtr = (UInt8 *) ((UInt32) dataPtr + (UInt32) length - 1); // point to last byte
148:
149: length -= fragCount; // adjust remaining length
150:
151: do
152: {
153: *bytePtr-- = zero; // clear one byte at a time
154: }
155: while ( --fragCount );
156:
157: if ( length == 0 )
158: return;
159: }
160:
161: // At this point length is a multiple of 4
162:
163: #if DEBUG_BUILD
164: if ( length < 4 )
165: DebugStr("\p ClearMemory: length < 4");
166: #endif
167:
168: // fix up beginning to get us on a 64 byte boundary
169: fragCount = length & (64-1);
170:
171: #if DEBUG_BUILD
172: if ( fragCount < 4 && fragCount > 0 )
173: DebugStr("\p ClearMemory: fragCount < 4");
174: #endif
175:
176: if ( fragCount )
177: {
178: length -= fragCount; // subtract fragment from length now
179: fragCount >>= 2; // divide by 4 to get a count, for DBRA loop
180: do
181: {
182: // clear 4 bytes at a time...
183: *dataPtr++ = zero;
184: }
185: while (--fragCount);
186: }
187:
188: // Are we finished yet?
189: if ( length == 0 )
190: return;
191:
192: // Time to turn on the fire hose
193: length >>= 6; // divide by 64 to get count
194: do
195: {
196: // spray 64 bytes at a time...
197: *dataPtr++ = zero; *dataPtr++ = zero; *dataPtr++ = zero; *dataPtr++ = zero;
198: *dataPtr++ = zero; *dataPtr++ = zero; *dataPtr++ = zero; *dataPtr++ = zero;
199: *dataPtr++ = zero; *dataPtr++ = zero; *dataPtr++ = zero; *dataPtr++ = zero;
200: *dataPtr++ = zero; *dataPtr++ = zero; *dataPtr++ = zero; *dataPtr++ = zero;
201: }
202: while (--length);
203: }
204:
205:
206: //_______________________________________________________________________
207:
208: Boolean UnicodeBinaryCompare( ConstHFSUniStr255Param ustr1, ConstHFSUniStr255Param ustr2 )
209: {
210: UInt16 len;
211: const UniChar *u1;
212: const UniChar *u2;
213:
214: len = ustr1->length;
215:
216: if ( len != ustr2->length )
217: return false;
218:
219: u1 = ustr1->unicode;
220: u2 = ustr2->unicode;
221:
222: ++len; // adjust for pre-decrement in loop
223:
224: // Keep going until we run out of characters, or find one that differs
225: while (--len && *(u1++) == *(u2++))
226: ;
227:
228: // Return true iff we ran out of characters
229: return len==0;
230: }
231:
232: //_______________________________________________________________________
233:
234: Boolean PascalBinaryCompare( ConstStr31Param pstr1, ConstStr31Param pstr2 )
235: {
236: unsigned length;
237:
238: length = *pstr1;
239: if (*(pstr1++) != *(pstr2++)) // lengths must match
240: return false;
241:
242: ++length; // adjust for pre-decrement in loop
243:
244: // Keep going until we run out of characters, or find one that differs
245: while (--length && *(pstr1++) == *(pstr2++))
246: ;
247:
248: // Return true iff we ran out of characters
249: return length==0;
250: }
251:
252: #if TARGET_OS_MAC
253:
254: #if (FORDISKFIRSTAID)
255:
256: UInt32 LocalToUTC(UInt32 localTime)
257: {
258: return localTime;
259: }
260: UInt32 UTCToLocal(UInt32 utcTime)
261: {
262: return utcTime;
263: }
264:
265: #else /* not for Disk First Aid */
266:
267: UInt32 LocalToUTC(register UInt32 localTime)
268: {
269: register UInt32 utc;
270:
271: //
272: // An input of zero means "never". In that case, don't adjust it.
273: //
274: if (localTime == 0)
275: return 0;
276:
277: //
278: // Compute Universal Time
279: //
280: utc = localTime - ((FSVarsRec*) LMGetFSMVars())->offsetToUTC;
281:
282: //
283: // If we wrapped around, then use the most extreme
284: // value closest to the localTime input.
285: //
286: if ((utc ^ localTime) & 0xFF000000 == 0xFF000000) {
287: if (localTime & 0xFF000000)
288: utc = 0xFFFFFFFF; // pin to maximum value
289: else
290: utc = 0; // pin to minimum value
291: }
292:
293: return utc;
294: }
295:
296:
297: UInt32 UTCToLocal(register UInt32 utcTime)
298: {
299: register UInt32 local;
300:
301: //
302: // An input of zero means "never". In that case, don't adjust it.
303: //
304: if (utcTime == 0)
305: return 0;
306:
307: //
308: // Compute Universal Time
309: //
310: local = utcTime + ((FSVarsRec *) LMGetFSMVars())->offsetToUTC;
311:
312: //
313: // If we wrapped around, then use the most extreme
314: // value closest to the utcTime input.
315: //
316: if ((local ^ utcTime) & 0xFF000000 == 0xFF000000) {
317: if (utcTime & 0xFF000000)
318: local = 0xFFFFFFFF; // pin to maximum value
319: else
320: local = 0; // pin to minimum value
321: }
322:
323: return local;
324: }
325: #endif
326: #endif /* TARGE_OS_MAC */
327:
328:
329: #if TARGET_OS_MAC
330: UInt32 GetTimeUTC(void)
331: {
332: UInt32 localTime;
333:
334: GetDateTime(&localTime);
335: return LocalToUTC(localTime);
336: }
337:
338:
339: UInt32 GetTimeLocal(void)
340: {
341: UInt32 localTime;
342:
343: GetDateTime(&localTime);
344: return localTime;
345: }
346: #endif /* TARGET_OS_MAC */
347:
348:
349: #ifndef __MATH64__
350:
351: UInt64 U64Add (UInt64 x, UInt64 y)
352: {
353: UInt64 result;
354:
355: result.lo = x.lo + y.lo;
356: result.hi = x.hi + y.hi;
357:
358: // Now see if there was a carry out of the low half. If there was a carry
359: // out, then the unsigned interpretation of the result will be less than
360: // the unsigned interpretation of both addends.
361:
362: if (((UInt32) result.lo) < ((UInt32) x.lo))
363: ++result.hi; // was carry; add it to upper half
364:
365: return(result); // pass the answer back
366: }
367:
368:
369: UInt64 U64Subtract (UInt64 left, UInt64 right)
370: {
371: UInt64 result;
372:
373: result.lo = left.lo - right.lo;
374: result.hi = left.hi - right.hi;
375:
376: // Now see if there was a borrow from the low half. There will be one if
377: // the unsigned interpretation of right.lo is greater than the unsigned
378: // interpretation of left.lo.
379:
380: if (((UInt32) right.lo) > ((UInt32) left.lo))
381: --result.hi; // was borrow; subtract from upper half
382:
383: return(result); // pass the answer back
384: }
385:
386: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.