1//
2//  HashRule.m
3//  ANTLR
4//
5// Copyright (c) 2010 Alan Condit
6// All rights reserved.
7//
8// Redistribution and use in source and binary forms, with or without
9// modification, are permitted provided that the following conditions
10// are met:
11// 1. Redistributions of source code must retain the above copyright
12//    notice, this list of conditions and the following disclaimer.
13// 2. Redistributions in binary form must reproduce the above copyright
14//    notice, this list of conditions and the following disclaimer in the
15//    documentation and/or other materials provided with the distribution.
16// 3. The name of the author may not be used to endorse or promote products
17//    derived from this software without specific prior written permission.
18//
19// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30#define SUCCESS (0)
31#define FAILURE (-1)
32#define ANTLR_MEMO_RULE_UNKNOWN -1
33
34#import "HashRule.h"
35
36/*
37 * Start of HashRule
38 */
39@implementation HashRule
40
41@synthesize LastHash;
42
43+(id)newHashRule
44{
45    return [[HashRule alloc] init];
46}
47
48+(id)newHashRuleWithLen:(NSInteger)aBuffSize
49{
50    return [[HashRule alloc] initWithLen:aBuffSize];
51}
52
53-(id)init
54{
55    self = [super initWithLen:HASHSIZE];
56    if ( self != nil ) {
57    }
58    return( self );
59}
60
61-(id)initWithLen:(NSInteger)aBuffSize
62{
63    self = [super initWithLen:aBuffSize];
64    if ( self != nil ) {
65        mode = 0;
66    }
67    return( self );
68}
69
70-(void)dealloc
71{
72#ifdef DEBUG_DEALLOC
73    NSLog( @"called dealloc in HashRule" );
74#endif
75    RuleMemo *tmp, *rtmp;
76    int Index;
77
78    if ( self.fNext != nil ) {
79        for( Index = 0; Index < BuffSize; Index++ ) {
80            tmp = ptrBuffer[Index];
81            while ( tmp && tmp != ptrBuffer[Index] ) {
82                rtmp = tmp;
83                if ([tmp isKindOfClass:[LinkBase class]])
84                    tmp = (RuleMemo *)tmp.fNext;
85                else
86                    tmp = nil;
87                [rtmp release];
88            }
89        }
90    }
91    [super dealloc];
92}
93
94- (NSInteger)count
95{
96    NSInteger aCnt = 0;
97
98    for (int i = 0; i < BuffSize; i++) {
99        if ( ptrBuffer[i] != nil ) {
100            aCnt++;
101        }
102    }
103    return aCnt;
104}
105
106- (NSInteger) length
107{
108    return BuffSize;
109}
110
111- (NSInteger) size
112{
113    NSInteger aSize = 0;
114
115    for (int i = 0; i < BuffSize; i++) {
116        if ( ptrBuffer[i] != nil ) {
117            aSize += sizeof(id);
118        }
119    }
120    return aSize;
121}
122
123
124-(void)deleteHashRule:(RuleMemo *)np
125{
126    RuleMemo *tmp, *rtmp;
127    int Index;
128
129    if ( self.fNext != nil ) {
130        for( Index = 0; Index < BuffSize; Index++ ) {
131            tmp = ptrBuffer[Index];
132            while ( tmp && tmp != ptrBuffer[Index ] ) {
133                rtmp = tmp;
134                if ([tmp isKindOfClass:[LinkBase class]])
135                    tmp = (RuleMemo *)tmp.fNext;
136                else
137                    tmp = nil;
138                [rtmp release];
139            }
140        }
141    }
142}
143
144-(void)delete_chain:(RuleMemo *)np
145{
146    if ( np.fNext != nil )
147        [self delete_chain:np.fNext];
148    [np release];
149}
150
151-(RuleMemo **)getPtrBuffer
152{
153    return( ptrBuffer );
154}
155
156-(void)setPtrBuffer:(RuleMemo **)np
157{
158    ptrBuffer = np;
159}
160
161- (ACNumber *)getRuleMemoStopIndex:(NSInteger)aStartIndex
162{
163    RuleMemo *aRule;
164    ACNumber *stopIndex;
165    NSInteger anIndex;
166
167    anIndex = ( aStartIndex >= BuffSize ) ? aStartIndex % BuffSize : aStartIndex;
168    if ((aRule = ptrBuffer[anIndex]) == nil) {
169        return nil;
170    }
171    stopIndex = [aRule getStopIndex:aStartIndex];
172    return stopIndex;
173}
174
175- (void)putRuleMemo:(RuleMemo *)aRule AtStartIndex:(NSInteger)aStartIndex
176{
177    NSInteger anIndex;
178
179    anIndex = (aStartIndex >= BuffSize) ? aStartIndex %= BuffSize : aStartIndex;
180    if ( ptrBuffer[anIndex] == nil ) {
181        ptrBuffer[anIndex] = aRule;
182        [aRule retain];
183    }
184    else {
185        do {
186            if ( [aRule.startIndex integerValue] == aStartIndex ) {
187                [aRule setStartIndex:aRule.stopIndex];
188                return;
189            }
190            aRule = aRule.fNext;
191        } while ( aRule != nil );
192    }
193}
194
195- (void)putRuleMemoAtStartIndex:(NSInteger)aStartIndex StopIndex:(NSInteger)aStopIndex
196{
197    RuleMemo *aRule, *newRule;
198    NSInteger anIndex;
199    NSInteger aMatchIndex;
200
201    anIndex = (aStartIndex >= BuffSize) ? aStartIndex % BuffSize : aStartIndex;
202    aRule = ptrBuffer[anIndex];
203    if ( aRule == nil ) {
204        aRule = [RuleMemo newRuleMemoWithStartIndex:[ACNumber numberWithInteger:aStartIndex]
205                                                    StopIndex:[ACNumber numberWithInteger:aStopIndex]];
206        [aRule retain];
207        ptrBuffer[anIndex] = aRule;
208    }
209    else {
210        aMatchIndex = [aRule.startIndex integerValue];
211        if ( aStartIndex > aMatchIndex ) {
212            if ( aRule != ptrBuffer[anIndex] ) {
213                [aRule retain];
214            }
215            aRule.fNext = ptrBuffer[anIndex];
216            ptrBuffer[anIndex] = aRule;
217            return;
218        }
219        while (aRule.fNext != nil) {
220            aMatchIndex = [((RuleMemo *)aRule.fNext).startIndex integerValue];
221            if ( aStartIndex > aMatchIndex ) {
222                newRule = [RuleMemo newRuleMemoWithStartIndex:[ACNumber numberWithInteger:aStartIndex]
223                                                              StopIndex:[ACNumber numberWithInteger:aStopIndex]];
224                [newRule retain];
225                newRule.fNext = aRule.fNext;
226                aRule.fNext = newRule;
227                return;
228            }
229            if ( aMatchIndex == aStartIndex ) {
230                [aRule setStartIndex:aRule.stopIndex];
231                return;
232            }
233            aRule = aRule.fNext;
234        }
235    }
236}
237
238- (NSInteger)getLastHash
239{
240    return LastHash;
241}
242
243- (void)setLastHash:(NSInteger)aHash
244{
245    LastHash = aHash;
246}
247
248- (NSInteger)getMode
249{
250    return mode;
251}
252
253- (void)setMode:(NSInteger)aMode
254{
255    mode = aMode;
256}
257
258- (void) insertObject:(RuleMemo *)aRule atIndex:(NSInteger)anIndex
259{
260    NSInteger Index;
261
262    Index = ( anIndex >= BuffSize ) ? anIndex % BuffSize : anIndex;
263    if (aRule != ptrBuffer[Index]) {
264        if ( ptrBuffer[Index] ) [ptrBuffer[Index] release];
265        [aRule retain];
266    }
267    ptrBuffer[Index] = aRule;
268}
269
270- (RuleMemo *)objectAtIndex:(NSInteger)anIndex
271{
272    NSInteger anIdx;
273
274    anIdx = ( anIndex >= BuffSize ) ? anIndex % BuffSize : anIndex;
275    return ptrBuffer[anIdx];
276}
277
278
279@end
280