![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Read_me CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / a / usr / src / misc|
Return to Read_me CVS log | Up to [MW Coherent from dump] / coherent / a / usr / src / misc |
1.1 root 1: misc/Read_me 10/11/90
2:
3: libmisc.a is a collection of miscellaneous useful user functions
4: which can be used by C programmers to increase productivity.
5:
6: misc.h
7: Is a header file with externs and #define's for the
8: various functions in libmisc.a
9:
10: char * alloc(n) unsigned n;
11: Malloc() n bytes and zero them, or put out a fatal error message.
12:
13: int approx(a, b) double a, b;
14: If a and b are within epsilon return 1 else 0. epsilon
15: is a visable double.
16:
17: char * ask(reply, msg, ...) char *reply *msg;
18: Puts out msg as a printf style format string using any
19: trailing arguments. Gets a line from stdin with gets()
20: and returns the address of reply. For example
21: sscanf(ask(buff, "%d numbers", 3), &a, &b, &c);
22: puts out the message "Enter: 3 numbers " gets a reply
23: in buff and hands that to sscanf().
24:
25: void banner(word, pad) char *word; int pad;
26: Prints word as a banner on stdout preceeded by pad
27: spaces. Each letter of the banner is composed of
28: occurances of itself.
29:
30: unsigned short crc16(p) char *p;
31: Takes the crc16 of the string p and returns it. Fast
32: and perfect for hash tables, diff algorithms etc.
33:
34: void fatal(msg, ...) char *msg;
35: Prints the msg as a printf style format string using
36: any trailing arguments. This is preceeded by
37: "\nfatal". fatal() then does exit(1).
38:
39: int is_fs(special) char *special;
40: Checks if a special file is a well formed file system.
41: Users should never put file systems on /dev/ram1 but
42: For multi system software like compress it is smart
43: to test.
44:
45: Return values:
46: -1 Not a device, cannot open, read or seek failed.
47: 0 No filesystem.
48: 1 Legal filesystem.
49:
50: char * lcase(str) char *str;
51: Converts str to lower case.
52:
53: char * match(string, pattern, fin) char *string, *pattern, **fin;
54: Like pnmatch() except match returns the address of the
55: pattern matched. fin is aimed past the end of the
56: pattern found. That is match finds a pattern and tells
57: you where it is.
58:
59: char * newcpy(str) char* str;
60: Creates a NUL terminated copy of str on the heap.
61: It calls fatal if there is no space.
62:
63: char * pathn(name, envpath, deflpath, access)
64: char *name, *envpath, *deflpath, *access;
65: example: pathn("helpfile", "LIBPATH", "/lib", "r")
66: Looks for helpfile using the environmental variable
67: LIBPATH if that isn't set, or the second parm is NULL
68: it uses the default path "/lib". The file found must
69: have read permission. pathn() returns the full path
70: to the file found.
71:
72: double picture (dble, format, output )
73: double dble; /* the number to format */
74: char *format; /* the format mask */
75: char *output; /* the output area. At least as large as format */
76:
77: The picture() function gives C users far better
78: numeric formatting ability than COBOL and BASIC users.
79:
80: 9 Provides a slot for a number.
81: 5.000 passed through a mask of '999 CR' gives '005 '
82: -5.000 passed through a mask of '999 CR' gives '005 CR'
83: Note: C & R are not special to picture. Trailing non special
84: characters print only if the number is negitave
85:
86: Z Provides a slot for a number but supresses lead zeros.
87: 1034.000 passed through a mask of 'ZZZ,ZZZ' gives ' 1,034'
88: Note: comma is not special to picture. Imbeded non special
89: characters print only if preceeded by significant digits
90:
91: J Provides a slot for a number but shrinks out lead zeros.
92: 1034.000 passed through a mask of 'JJJ,JJJ' gives '1,034'
93:
94: K Provides a slot for a number but shrinks out any zeros.
95: 70884.000 passed through a mask of 'K9/K9/K9' gives '7/8/84'
96:
97: $ Floats a dollar sign to the front of the displayed number.
98: 105.000 passed through a mask of '$ZZZ,ZZZ' gives ' $105'
99:
100: . Separates the number between decimal and integer portions.
101: 105.670 passed through a mask of 'Z,ZZZ.999' gives ' 105.670'
102:
103: T Provides a slot for a number but supresses trailing zeros.
104: 105.670 passed through a mask of 'Z,ZZ9.9TT' gives ' 105.67 '
105:
106: S Provides a slot for a number but shrinks out trailing zeros.
107: 105.670 passed through a mask of 'Z,ZZ9.9SS' gives ' 105.67'
108:
109: - Floats a - infront of negitive numbers
110: 105.000 passed through a mask of '-Z,ZZZ' gives ' 105'
111: -105.000 passed through a mask of '-Z,ZZZ' gives ' -105'
112:
113: ( Acts like - but prints a (
114: 105.000 passed through a mask of '(ZZZ)' gives ' 105 '
115: -5.000 passed through a mask of '(ZZZ)' gives ' (5)'
116:
117: + Floats a + or - infront of the number depending on its sign
118: 5.000 passed through a mask of '+ZZZ' gives ' +5'
119: -5.000 passed through a mask of '+ZZZ' gives ' -5'
120:
121: * Fills all lead spaces to its right
122: 104.100 passed through a mask of '*ZZZ,ZZZ.99' gives '*****104.10'
123: 104.100 passed through a mask of '*$ZZZ,ZZZ.99' gives '*****$104.10'
124:
125: Any overflow is returned by picture as a double precision number.
126: -1234.000 passed through a mask of '(ZZZ)' gives '(234)'
127: With an overflow of -1.0
128: 123.400 passed through a mask of '99' gives '23'
129: With an overflow of 1.0
130: 1200.000 passed through a mask of 'ZZ' gives '00'
131: With an overflow of 12.0
132:
133: long randl()
134: Returns a long random number uniformly distributed in
135: 1..2147483562. This comes from CACM V. 31 N 6. And is
136: the best algorithm I know as of this writing.
137: see srandl() in this section.
138:
139: char * replace(s1, pat, s3, all, matcher) char *s1, *pat, *s3, (matcher)();
140: Replaces one or all occurances of pat in s1 by s3 and
141: returns the result. The definition of match is set by matcher.
142: This calls the user defined function matcher(sw, pat, &fin). The
143: matcher must return the address of the pattern match and
144: it's end in &fin. match() is a valid example of matcher.
145: It replaces the first occurance, or all occurances of the
146: pattern and returns the new pattern. The new pattern has been
147: alloc()ed (see alloc).
148:
149: showflag(data, flags, output) long data; char *flags, *output;
150: Turns the bits in data to the flags in flags or '-'
151: in the string output which must be as long as flags.
152:
153: char * skip(s1, matcher, fin) char *s1, **fin; int (*matcher)();
154: Skip one or more characters not matching some criterion
155: such as isdigit(). Returns the first character skipped
156: points fin at the character after the skip.
157:
158: char * span(s1, matcher, fin) char *s1, **fin; int (*matcher)();
159: Span one or more characters matching some criterion
160: such as isdigit(). Returns the first character spanned
161: points fin at the character after the span.
162:
163: srandl(seed1, seed2) long seed1, seed2;
164: randl() needs two seeds this sets them. Used only
165: if you need to repeat a random number sequence.
166:
167: strchtr(from, to, c, def) char *from, *to; int c, def;
168: Look up the char c on the string from, return the corresponding
169: char on the string to if it is found otherwise return the char
170: def. example: strchr("abc", "xyz", c, d); if c == 'a' return
171: 'x', if c == 'b' return 'y' if c > 'c' return d.
172:
173:
174: strcmpl(s1, s2)
175: Case insensative string compare.
176:
177: #define strlcpy(to, from) memcpy(to, from, sizeof(to))
178:
179: ucase(s) char *s;
180: Convert a string to upper case.
181:
182: usage(s) char *s;
183: Put out a usage: message and exit(1)
184:
185: The following are part of a user virtual memory system for
186: Coherent. Sometimes users port programs such as compress to
187: Coherent which have a small number of very large arrays. Since
188: Coherent is a small model operating system changes need to be
189: made. The following functions are intended to expedite these
190: changes.
191:
192: void vinit(filename, ram) char *filename; unsigned ram;
193: Init the virtual system using filename for work
194: this may be a raw device such as /dev/rram1. ram
195: is the amount of buffer space to give the system
196: the more the better.
197:
198: void vshutdown()
199: Shut the virtual system, and make it restartable.
200:
201: unsigned vopen(amt) unsigned long amt;
202: Set up a virtual object. Say you want to emulate having
203: a 100000 byte array and a 50000 byte array. use
204: vid1 = vopen(100000L); vid2 = vopen(50000L);
205: This does some checking and tells the system that any
206: reference to vid2 will be between 100000 and 150000
207: on the virtual file.
208:
209: char *vfind(vid, disp, dirty) unsigned vid, dirty; unsigned long disp;
210: Find a character on the virtual system mark the blocks
211: dirty bit if the access is to write. Given the example in
212: vopen, if you want to find the 1000 th byte in vdi1
213: c = vfind(vdi1, 1000L, 0);
214: To change the 2000 th byte in vid2 to d.
215: *(vfind(vid2, 2000L, 1)) = d;
216: Note the dirty indicator tells the system of the change so
217: that the block will be written back before it is read over.
218: Blocks are 512 bytes long so int's or long's can be read
219: or written without multiple accesses to vfind.
220:
221: xdump(p, length) char *p;
222: Make a vertical hex dump of p for length on stdout. This
223: is a usefull debugging tool. Vertical hex prints as 3 lines
224: The top line is the display character or . if it's not
225: cleanly displayable. The next two lines are the hex digit.
226: The data is blocked in groups of four bytes.
227:
228: xopen(filename, acs)
229: Like fopen() but it calls fatal() if the open fails.
230:
231: yn(question, ...) char *question;
232: Ask a question with any trailing parms printf style and
233: get a y or n answer. Returns a 1 for 'Y' or 'y' a 0
234: for 'n' or 'N', reasks otherwise.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.