| // |
| // ANTLRHashMap.m |
| // ANTLR |
| // |
| // Copyright (c) 2010 Alan Condit |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions |
| // are met: |
| // 1. Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // 2. Redistributions in binary form must reproduce the above copyright |
| // notice, this list of conditions and the following disclaimer in the |
| // documentation and/or other materials provided with the distribution. |
| // 3. The name of the author may not be used to endorse or promote products |
| // derived from this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #define SUCCESS (0) |
| #define FAILURE (-1) |
| |
| #import "ANTLRHashMap.h" |
| |
| static NSInteger itIndex; |
| |
| /* |
| * Start of ANTLRHashMap |
| */ |
| @implementation ANTLRHashMap |
| |
| @synthesize Scope; |
| @synthesize LastHash; |
| |
| +(id)newANTLRHashMap |
| { |
| ANTLRHashMap *aNewANTLRHashMap; |
| |
| aNewANTLRHashMap = [[ANTLRHashMap alloc] init]; |
| return( aNewANTLRHashMap ); |
| } |
| |
| +(id)newANTLRHashMapWithLen:(NSInteger)aBuffSize |
| { |
| ANTLRHashMap *aNewANTLRHashMap; |
| |
| aNewANTLRHashMap = [[ANTLRHashMap alloc] initWithLen:aBuffSize]; |
| return( aNewANTLRHashMap ); |
| } |
| |
| -(id)init |
| { |
| NSInteger idx; |
| |
| if ((self = [super init]) != nil) { |
| fNext = nil; |
| BuffSize = HASHSIZE; |
| Scope = 0; |
| if ( fNext != nil ) { |
| Scope = ((ANTLRHashMap *)fNext)->Scope+1; |
| for( idx = 0; idx < BuffSize; idx++ ) { |
| ptrBuffer[idx] = ((ANTLRHashMap *)fNext)->ptrBuffer[idx]; |
| } |
| } |
| mode = 0; |
| } |
| return( self ); |
| } |
| |
| -(id)initWithLen:(NSInteger)aBuffSize |
| { |
| NSInteger idx; |
| |
| if ((self = [super init]) != nil) { |
| fNext = nil; |
| BuffSize = aBuffSize; |
| Scope = 0; |
| if ( fNext != nil ) { |
| Scope = ((ANTLRHashMap *)fNext)->Scope+1; |
| for( idx = 0; idx < BuffSize; idx++ ) { |
| ptrBuffer[idx] = ((ANTLRHashMap *)fNext)->ptrBuffer[idx]; |
| } |
| } |
| mode = 0; |
| } |
| return( self ); |
| } |
| |
| -(void)dealloc |
| { |
| ANTLRMapElement *tmp, *rtmp; |
| NSInteger idx; |
| |
| if ( self.fNext != nil ) { |
| for( idx = 0; idx < BuffSize; idx++ ) { |
| tmp = ptrBuffer[idx]; |
| while ( tmp && tmp != [((ANTLRHashMap *)fNext) getptrBufferEntry:idx] ) { |
| rtmp = tmp; |
| // tmp = [tmp getfNext]; |
| tmp = (ANTLRMapElement *)tmp.fNext; |
| [rtmp dealloc]; |
| } |
| } |
| } |
| [super dealloc]; |
| } |
| |
| - (NSInteger)count |
| { |
| id anElement; |
| NSInteger aCnt = 0; |
| |
| for (NSInteger i = 0; i < BuffSize; i++) { |
| if ((anElement = ptrBuffer[i]) != nil) { |
| aCnt++; |
| } |
| } |
| return aCnt; |
| } |
| |
| - (NSInteger) size |
| { |
| id anElement; |
| NSInteger aSize = 0; |
| |
| for (NSInteger i = 0; i < BuffSize; i++) { |
| if ((anElement = ptrBuffer[i]) != nil) { |
| aSize += sizeof(id); |
| } |
| } |
| return aSize; |
| } |
| |
| |
| -(void)deleteANTLRHashMap:(ANTLRMapElement *)np |
| { |
| ANTLRMapElement *tmp, *rtmp; |
| NSInteger idx; |
| |
| if ( self.fNext != nil ) { |
| for( idx = 0; idx < BuffSize; idx++ ) { |
| tmp = ptrBuffer[idx]; |
| while ( tmp && tmp != (ANTLRLinkBase *)[((ANTLRHashMap *)fNext) getptrBufferEntry:idx] ) { |
| rtmp = tmp; |
| tmp = [tmp getfNext]; |
| [rtmp dealloc]; |
| } |
| } |
| } |
| } |
| |
| -(ANTLRHashMap *)PushScope:(ANTLRHashMap **)map |
| { |
| NSInteger idx; |
| ANTLRHashMap *htmp; |
| |
| htmp = [ANTLRHashMap newANTLRHashMap]; |
| if ( *map != nil ) { |
| ((ANTLRHashMap *)htmp)->fNext = *map; |
| [htmp setScope:[((ANTLRHashMap *)htmp->fNext) getScope]+1]; |
| for( idx = 0; idx < BuffSize; idx++ ) { |
| htmp->ptrBuffer[idx] = ((ANTLRHashMap *)htmp->fNext)->ptrBuffer[idx]; |
| } |
| } |
| // gScopeLevel++; |
| *map = htmp; |
| return( htmp ); |
| } |
| |
| -(ANTLRHashMap *)PopScope:(ANTLRHashMap **)map |
| { |
| NSInteger idx; |
| ANTLRMapElement *tmp; |
| ANTLRHashMap *htmp; |
| |
| htmp = *map; |
| if ( (*map)->fNext != nil ) { |
| *map = (ANTLRHashMap *)htmp->fNext; |
| for( idx = 0; idx < BuffSize; idx++ ) { |
| if ( htmp->ptrBuffer[idx] == nil || |
| htmp->ptrBuffer[idx] == (*map)->ptrBuffer[idx] ) { |
| break; |
| } |
| tmp = htmp->ptrBuffer[idx]; |
| /* |
| * must deal with parms, locals and labels at some point |
| * can not forget the debuggers |
| */ |
| htmp->ptrBuffer[idx] = [tmp getfNext]; |
| [ tmp dealloc]; |
| } |
| *map = (ANTLRHashMap *)htmp->fNext; |
| // gScopeLevel--; |
| } |
| return( htmp ); |
| } |
| |
| #ifdef USERDOC |
| /* |
| * HASH hash entry to get index to table |
| * NSInteger hash( ANTLRHashMap *self, char *s ); |
| * |
| * Inputs: char *s string to find |
| * |
| * Returns: NSInteger hashed value |
| * |
| * Last Revision 9/03/90 |
| */ |
| #endif |
| -(NSInteger)hash:(NSString *)s /* form hash value for string s */ |
| { |
| NSInteger hashval; |
| const char *tmp; |
| |
| tmp = [s cStringUsingEncoding:NSASCIIStringEncoding]; |
| for( hashval = 0; *tmp != '\0'; ) |
| hashval += *tmp++; |
| self->LastHash = hashval % BuffSize; |
| return( self->LastHash ); |
| } |
| |
| #ifdef USERDOC |
| /* |
| * FINDSCOPE search hashed list for entry |
| * ANTLRHashMap *findscope( ANTLRHashMap *self, NSInteger scope ); |
| * |
| * Inputs: NSInteger scope -- scope level to find |
| * |
| * Returns: ANTLRHashMap pointer to ptrBuffer of proper scope level |
| * |
| * Last Revision 9/03/90 |
| */ |
| #endif |
| -(ANTLRHashMap *)findscope:(NSInteger)scope |
| { |
| if ( self->Scope == scope ) { |
| return( self ); |
| } |
| else if ( fNext ) { |
| return( [((ANTLRHashMap *)fNext) findscope:scope] ); |
| } |
| return( nil ); /* not found */ |
| } |
| |
| #ifdef USERDOC |
| /* |
| * LOOKUP search hashed list for entry |
| * ANTLRMapElement *lookup( ANTLRHashMap *self, char *s, NSInteger scope ); |
| * |
| * Inputs: char *s string to find |
| * |
| * Returns: ANTLRMapElement * pointer to entry |
| * |
| * Last Revision 9/03/90 |
| */ |
| #endif |
| -(id)lookup:(NSString *)s Scope:(NSInteger)scope |
| { |
| ANTLRMapElement *np; |
| |
| for( np = self->ptrBuffer[[self hash:s]]; np != nil; np = [np getfNext] ) { |
| if ( [s isEqualToString:[np getName]] ) { |
| return( np ); /* found it */ |
| } |
| } |
| return( nil ); /* not found */ |
| } |
| |
| #ifdef USERDOC |
| /* |
| * INSTALL search hashed list for entry |
| * NSInteger install( ANTLRHashMap *self, ANTLRMapElement *sym, NSInteger scope ); |
| * |
| * Inputs: ANTLRMapElement *sym -- symbol ptr to install |
| * NSInteger scope -- level to find |
| * |
| * Returns: Boolean TRUE if installed |
| * FALSE if already in table |
| * |
| * Last Revision 9/03/90 |
| */ |
| #endif |
| -(ANTLRMapElement *)install:(ANTLRMapElement *)sym Scope:(NSInteger)scope |
| { |
| ANTLRMapElement *np; |
| |
| np = [self lookup:[sym getName] Scope:scope ]; |
| if ( np == nil ) { |
| [sym retain]; |
| [sym setFNext:self->ptrBuffer[ self->LastHash ]]; |
| self->ptrBuffer[ self->LastHash ] = sym; |
| return( self->ptrBuffer[ self->LastHash ] ); |
| } |
| return( nil ); /* not found */ |
| } |
| |
| #ifdef USERDOC |
| /* |
| * RemoveSym search hashed list for entry |
| * NSInteger RemoveSym( ANTLRHashMap *self, char *s ); |
| * |
| * Inputs: char *s string to find |
| * |
| * Returns: NSInteger indicator of SUCCESS OR FAILURE |
| * |
| * Last Revision 9/03/90 |
| */ |
| #endif |
| -(NSInteger)RemoveSym:(NSString *)s |
| { |
| ANTLRMapElement *np, *tmp; |
| NSInteger idx; |
| |
| idx = [self hash:s]; |
| for ( tmp = self->ptrBuffer[idx], np = self->ptrBuffer[idx]; np != nil; np = [np getfNext] ) { |
| if ( [s isEqualToString:[np getName]] ) { |
| tmp = [np getfNext]; /* get the next link */ |
| [np dealloc]; |
| return( SUCCESS ); /* report SUCCESS */ |
| } |
| tmp = [np getfNext]; // BAD!!!!!! |
| } |
| return( FAILURE ); /* not found */ |
| } |
| |
| -(void)delete_chain:(ANTLRMapElement *)np |
| { |
| if ( [np getfNext] != nil ) |
| [self delete_chain:[np getfNext]]; |
| [np dealloc]; |
| } |
| |
| #ifdef DONTUSEYET |
| -(NSInteger)bld_symtab:(KW_TABLE *)toknams |
| { |
| NSInteger i; |
| ANTLRMapElement *np; |
| |
| for( i = 0; *(toknams[i].name) != '\0'; i++ ) { |
| // install symbol in ptrBuffer |
| np = [ANTLRMapElement newANTLRMapElement:[NSString stringWithFormat:@"%s", toknams[i].name]]; |
| // np->fType = toknams[i].toknum; |
| [self install:np Scope:0]; |
| } |
| return( SUCCESS ); |
| } |
| #endif |
| |
| -(ANTLRMapElement *)getptrBufferEntry:(NSInteger)idx |
| { |
| return( ptrBuffer[idx] ); |
| } |
| |
| -(ANTLRMapElement **)getptrBuffer |
| { |
| return( ptrBuffer ); |
| } |
| |
| -(void)setptrBuffer:(ANTLRMapElement *)np Index:(NSInteger)idx |
| { |
| if ( idx < BuffSize ) { |
| [np retain]; |
| ptrBuffer[idx] = np; |
| } |
| } |
| |
| -(NSInteger)getScope |
| { |
| return( Scope ); |
| } |
| |
| -(void)setScopeScope:(NSInteger)i |
| { |
| Scope = i; |
| } |
| |
| - (ANTLRMapElement *)getTType:(NSString *)name |
| { |
| return [self lookup:name Scope:0]; |
| } |
| |
| /* |
| * works only for maplist indexed not by name but by TokenNumber |
| */ |
| - (ANTLRMapElement *)getNameInList:(NSInteger)ttype |
| { |
| ANTLRMapElement *np; |
| NSInteger aTType; |
| |
| aTType = ttype % BuffSize; |
| for( np = self->ptrBuffer[ttype]; np != nil; np = [np getfNext] ) { |
| if ( [np.index integerValue] == ttype ) { |
| return( np ); /* found it */ |
| } |
| } |
| return( nil ); /* not found */ |
| } |
| |
| - (ANTLRLinkBase *)getName:(NSString *)name |
| { |
| return [self lookup:name Scope:0]; /* nil if not found */ |
| } |
| |
| - (void)putNode:(NSString *)name TokenType:(NSInteger)ttype |
| { |
| ANTLRMapElement *np; |
| |
| // install symbol in ptrBuffer |
| np = [ANTLRMapElement newANTLRMapElementWithName:[NSString stringWithString:name] Type:ttype]; |
| // np->fType = toknams[i].toknum; |
| [self install:np Scope:0]; |
| } |
| |
| - (NSInteger)getMode |
| { |
| return mode; |
| } |
| |
| - (void)setMode:(NSInteger)aMode |
| { |
| mode = aMode; |
| } |
| |
| - (void) addObject:(id)aRule |
| { |
| NSInteger idx; |
| |
| idx = [self count]; |
| if ( idx >= BuffSize ) { |
| idx %= BuffSize; |
| } |
| ptrBuffer[idx] = aRule; |
| } |
| |
| /* this may have to handle linking into the chain |
| */ |
| - (void) insertObject:(id)aRule atIndex:(NSInteger)idx |
| { |
| if ( idx >= BuffSize ) { |
| idx %= BuffSize; |
| } |
| if (aRule != ptrBuffer[idx]) { |
| if (ptrBuffer[idx] != nil) [ptrBuffer[idx] release]; |
| [aRule retain]; |
| } |
| ptrBuffer[idx] = aRule; |
| } |
| |
| - (id)objectAtIndex:(NSInteger)idx |
| { |
| if ( idx >= BuffSize ) { |
| idx %= BuffSize; |
| } |
| return ptrBuffer[idx]; |
| } |
| |
| /* this will never link into the chain |
| */ |
| - (void) setObject:(id)aRule atIndex:(NSInteger)idx |
| { |
| if ( idx >= BuffSize ) { |
| idx %= BuffSize; |
| } |
| if (aRule != ptrBuffer[idx]) { |
| if (ptrBuffer[idx] != nil) [ptrBuffer[idx] release]; |
| [aRule retain]; |
| } |
| ptrBuffer[idx] = aRule; |
| } |
| |
| - (void)putName:(NSString *)name Node:(id)aNode |
| { |
| ANTLRMapElement *np; |
| |
| np = [self lookup:name Scope:0 ]; |
| if ( np == nil ) { |
| np = [ANTLRMapElement newANTLRMapElementWithName:name Node:aNode]; |
| if (ptrBuffer[LastHash] != nil) |
| [ptrBuffer[LastHash] release]; |
| [np retain]; |
| np.fNext = ptrBuffer[ LastHash ]; |
| ptrBuffer[ LastHash ] = np; |
| } |
| return; |
| } |
| |
| - (NSEnumerator *)objectEnumerator |
| { |
| NSEnumerator *anEnumerator; |
| |
| itIndex = 0; |
| return anEnumerator; |
| } |
| |
| - (BOOL)hasNext |
| { |
| if (self && [self count] < BuffSize-1) { |
| return YES; |
| } |
| return NO; |
| } |
| |
| - (ANTLRMapElement *)nextObject |
| { |
| if (self && itIndex < BuffSize-1) { |
| return ptrBuffer[itIndex]; |
| } |
| return nil; |
| } |
| |
| @end |
