Return to malloc.3 CVS log

Up to [CSRG BSD Unix] / 43BSDReno / share / man / man3f

Annotation of 43BSDReno/share/man/man3f/malloc.3, revision 1.1.1.1

1.1       root        1: .\" Copyright (c) 1985 Regents of the University of California.
                      2: .\" All rights reserved.  The Berkeley software License Agreement
                      3: .\" specifies the terms and conditions for redistribution.
                      4: .\"
                      5: .\"    @(#)malloc.3f   6.1 (Berkeley) 5/15/85
                      6: .\"
                      7: .TH MALLOC 3F  "May 15, 1985"
                      8: .UC 6
                      9: .SH NAME
                     10: malloc, free, falloc \- memory allocator
                     11: .SH SYNOPSIS
                     12: .nf
                     13: .B subroutine malloc (size, addr)
                     14: .B integer size, addr
                     15: .PP
                     16: .B subroutine free (addr)
                     17: .B integer addr
                     18: .PP
                     19: .B
                     20: subroutine falloc (nelem, elsize, clean, basevec, addr, offset)
                     21: .B
                     22: integer nelem, elsize, clean, addr, offset
                     23: .fi
                     24: .SH DESCRIPTION
                     25: .IR Malloc , \ falloc
                     26: and
                     27: .I free
                     28: provide a general-purpose memory allocation package.
                     29: .I Malloc
                     30: returns in
                     31: .I addr
                     32: the address of a block of at least
                     33: .I size
                     34: bytes beginning on an even-byte boundary.
                     35: .PP
                     36: .I Falloc
                     37: allocates space for an array of
                     38: .I nelem
                     39: elements of size
                     40: .I elsize
                     41: and returns the address of the block in
                     42: .I addr.
                     43: It zeros the block if
                     44: .I clean
                     45: is 1.
                     46: It returns in
                     47: .I offset
                     48: an index such that the storage may be addressed as
                     49: .I basevec(offset+1) ... basevec(offset+nelem).
                     50: .I Falloc
                     51: gets extra bytes so that after address arithmetic,
                     52: all the objects so addressed are within the block.
                     53: .PP
                     54: The argument to
                     55: .I free
                     56: is the address of a block previously allocated by
                     57: .I malloc
                     58: or
                     59: .IR falloc ;
                     60: this space is made available for further allocation,
                     61: but its contents are left undisturbed.
                     62: To free blocks allocated by
                     63: .I falloc,
                     64: use
                     65: .I addr
                     66: in calls to
                     67: .I free,
                     68: do not use
                     69: .I basevec(offset+1).
                     70: .PP
                     71: Needless to say, grave disorder will result if the space assigned by
                     72: .IR malloc or falloc
                     73: is overrun or if some random number is handed to
                     74: .IR free .
                     75: .SH DIAGNOSTICS
                     76: .I Malloc
                     77: and
                     78: .I falloc
                     79: set
                     80: .I addr
                     81: to 0 if there is no available memory or if the arena
                     82: has been detectably corrupted by storing outside the bounds of a block.
                     83: .PP
                     84: The following example shows how to obtain memory and use it within a
                     85: subprogram:
                     86: .nf
                     87: 
                     88:       integer addr, work(1), offset
                     89:          ...
                     90:       call falloc ( n, 4, 0, work, addr, offset )
                     91:       do 10 i = 1, n
                     92:       work(offset+i) = ...
                     93: 10    continue
                     94: .fi
                     95: .PP
                     96: The next example reads in dimension information,
                     97: allocates space for two arrays and two vectors,
                     98: and calls subroutine
                     99: .I doit
                    100: to do the computations:
                    101: .nf
                    102: 
                    103:       integer addr, dummy(1), offs
                    104:       read *, k, l, m
                    105:       indm1   = 1
                    106:       indm2   = indm1 + k*l
                    107:       indm3   = indm2 + l*m
                    108:       indsym  = indm3 + k*m
                    109:       lsym = n*(n+1)/2
                    110:       indv  = indsym + lsym
                    111:       indtot = indv + m
                    112:       call falloc ( indtot, 4, 0, dummy, addr, offs )
                    113:       call doit( dummy(indm1+offs), dummy(indm2+offs),
                    114:      .           dummy(indm3+offs), dummy(indsym+offs),
                    115:      .           dummy(indv +offs), m, n, lsym )
                    116:       end
                    117:       subroutine doit( arr1, arr2, arr3, vsym, vec, m, n, lsym )
                    118:       real arr1(k,l), arr2(l,m), arr3(k,m), vsym(lsym), v2(m)
                    119:          ...
                    120: .fi
                    121: .SH FILES
                    122: /usr/lib/libU77.a
                    123: .SH SEE ALSO
                    124: malloc(3)

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.