Return to ModuleList.m CVS log

Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Backspace

Annotation of Examples/AppKit/Backspace/ModuleList.m, revision 1.1.1.1

1.1       root        1: //
                      2: //  ModuleList.m
                      3: //
                      4: //     a simple storage class that holds all the information BackSpace needs
                      5: //  about each module.  This file contains 2 classes; one for the information
                      6: //  on a single module and one for a list to store those ModuleInfo's
                      7: //
                      8: //  You may freely copy, distribute, and reuse the code in this example.
                      9: //  NeXT disclaims any warranty of any kind, expressed or  implied, as to its
                     10: //  fitness for any particular use.
                     11: 
                     12: 
                     13: 
                     14: #import "ModuleList.h"
                     15: #import <stdlib.h>                     // for free() etc
                     16: #import <strings.h>                    // for strcasecmp()
                     17: #import <objc/hashtable.h>             // for NXCopyStringBuffer()
                     18: 
                     19: #define str_copy(str)  ((str == NULL) ? NULL : NXCopyStringBuffer(str))
                     20: #define str_free(str)  {if (str) free(str);}
                     21: 
                     22: 
                     23: @implementation ModuleInfo
                     24: - init
                     25: {      return [self initWithView:nil name:NULL path:NULL];
                     26: }
                     27: 
                     28: - initWithView:aView name:(const char *)aName path:(const char *)aPath
                     29: {
                     30:        [super init];
                     31:        view = aView;
                     32:        viewName = str_copy(aName);
                     33:        path = str_copy(aPath);
                     34:        return self;
                     35: }
                     36: 
                     37: - setView:newView
                     38: {
                     39:        id oldView = view;
                     40:        view = newView;
                     41:        return oldView;
                     42: }
                     43: 
                     44: - view
                     45: {      return view;
                     46: }
                     47: 
                     48: - setHeader:(struct mach_header *)h
                     49: {      header = h;
                     50:        return self;
                     51: }
                     52: 
                     53: - (struct mach_header *) header
                     54: {      return header;
                     55: }
                     56: 
                     57: - (const char *) viewName
                     58: {      return viewName;
                     59: }
                     60: 
                     61: - (const char *) path
                     62: {      return path;
                     63: }
                     64: 
                     65: - setPath: (const char *)p
                     66: {
                     67:        str_free(path);
                     68:        path = str_copy(p);
                     69:        return self;
                     70: }
                     71: 
                     72: - appendPath: (const char *)p
                     73: {
                     74:        if (altPaths)
                     75:        {
                     76:                altPaths = realloc(altPaths,strlen(altPaths)+strlen(p)+2);
                     77:                strcat(altPaths,"\t");
                     78:                strcat(altPaths,p);
                     79:        }
                     80:        else altPaths = str_copy(p);
                     81:        return self;
                     82: }
                     83: 
                     84: // if the path is bogus, this will set the path to the next one
                     85: // returns self if successful, nil if there is no additional path
                     86: - useNextPath
                     87: {
                     88:        char *p1, *p2;
                     89: 
                     90:        if (altPaths)
                     91:        {
                     92:                p1 = p2 = altPaths;
                     93:                while (*p1 && *p1 != '\t') p1++;
                     94:                if (*p1 == '\t')
                     95:                {
                     96:                        *p1=0;
                     97:                        path = realloc(path,strlen(p1)+1);
                     98:                        strcpy(path,p1);
                     99:                        while (*p2++ = *p1++);
                    100:                        altPaths = realloc(altPaths,strlen(altPaths)+1);
                    101:                }
                    102:                else            // last one
                    103:                {
                    104:                        str_free(path);
                    105:                        path = altPaths;
                    106:                        altPaths = NULL;
                    107:                }
                    108:                return self;
                    109:        }
                    110:        return nil;
                    111: }
                    112: 
                    113: - discardAltPaths
                    114: {
                    115:        str_free(altPaths);
                    116:        altPaths = NULL;
                    117:        return self;
                    118: }
                    119: 
                    120: - free
                    121: {
                    122:        [view free];
                    123:        str_free(viewName);
                    124:        str_free(path);
                    125:        str_free(altPaths);
                    126:        return [super free];
                    127: }
                    128: 
                    129: @end
                    130: 
                    131: @implementation ModuleList
                    132: 
                    133: - (const char *) nameAt: (int) i
                    134: {
                    135:        return [[self objectAt: i] viewName];
                    136: }
                    137: 
                    138: - viewAt: (int) i
                    139: {
                    140:        return [[self objectAt: i] view];
                    141: }
                    142: 
                    143: static int docompare(const void *x, const void *y)
                    144: {
                    145:        return strcasecmp([(id)(*(ModuleInfo **)x) viewName], [(id)(*(ModuleInfo **)y) viewName]);
                    146: }
                    147: 
                    148: - sort
                    149: {
                    150:        qsort((ModuleInfo **)dataPtr, numElements, sizeof(id), docompare);
                    151:        return self;
                    152: }
                    153: 
                    154: @end

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