Branch data Line data Source code
1 : : /*
2 : : * strlist.cpp - string list class implementation
3 : : *
4 : : * Copyright (C) 2003, 2004, 2005, 2006 Stefan Jahn <stefan@lkcc.org>
5 : : *
6 : : * This is free software; you can redistribute it and/or modify
7 : : * it under the terms of the GNU General Public License as published by
8 : : * the Free Software Foundation; either version 2, or (at your option)
9 : : * any later version.
10 : : *
11 : : * This software is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : * GNU General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU General Public License
17 : : * along with this package; see the file COPYING. If not, write to
18 : : * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
19 : : * Boston, MA 02110-1301, USA.
20 : : *
21 : : * $Id$
22 : : *
23 : : */
24 : :
25 : : #if HAVE_CONFIG_H
26 : : # include <config.h>
27 : : #endif
28 : :
29 : : #include <stdio.h>
30 : : #include <stdlib.h>
31 : : #include <string.h>
32 : :
33 : : #include "strlist.h"
34 : :
35 : : namespace qucs {
36 : :
37 : : // Constructor creates an instance of the strlist class.
38 : 592624 : strlist::strlist () {
39 : 592624 : root = NULL;
40 : 592624 : txt = NULL;
41 : 592624 : }
42 : :
43 : : /* This copy constructor creates a instance of the strlist class based
44 : : on the given strlist. */
45 : 137300 : strlist::strlist (const strlist & o) {
46 : : struct strlist_t * s;
47 : 137300 : root = NULL;
48 : 137300 : txt = NULL;
49 [ + + ][ # # ]: 152497 : for (s = o.root; s != NULL; s = s->next) append (s->str);
50 : 137300 : }
51 : :
52 : : // Destructor deletes an instance of the strlist class.
53 : 729923 : strlist::~strlist () {
54 : : struct strlist_t * next;
55 [ + + ][ # # ]: 1044058 : while (root) {
56 : 314135 : next = root->next;
57 [ + - ][ # # ]: 314135 : if (root->str) free (root->str);
58 : 314135 : free (root);
59 : 314135 : root = next;
60 : : }
61 [ + + ][ # # ]: 729923 : if (txt) free (txt);
62 : 729923 : }
63 : :
64 : : // This function adds a string to the list.
65 : 278494 : void strlist::add (const char * const str) {
66 : : struct strlist_t * s;
67 : 278494 : s = (struct strlist_t *) calloc (sizeof (struct strlist_t), 1);
68 : 278494 : s->next = root;
69 [ + - ]: 278494 : s->str = str ? strdup (str) : NULL;
70 : 278494 : root = s;
71 : 278494 : }
72 : :
73 : : // The function adds the given string list to the list.
74 : 809 : void strlist::add (const strlist * const lst) {
75 [ + + ]: 809 : if (lst)
76 [ + + ]: 28 : for (int i = lst->length () - 1; i >= 0; i--)
77 : 14 : add (lst->get (i));
78 : 809 : }
79 : :
80 : : // The function apends the given string list to the list.
81 : 27 : void strlist::append (const strlist * const lst) {
82 [ + + ][ + + ]: 39 : if (lst) for (int i = 0; i < lst->length (); i++)
83 : 12 : append (lst->get (i));
84 : 27 : }
85 : :
86 : : // This function append a string to the list.
87 : 35642 : void strlist::append (const char * const str) {
88 : : struct strlist_t * s;
89 : 35642 : s = (struct strlist_t *) calloc (sizeof (struct strlist_t), 1);
90 : 35642 : s->next = NULL;
91 [ + - ]: 35642 : s->str = str ? strdup (str) : NULL;
92 [ + + ]: 35642 : if (root) {
93 : : struct strlist_t * e;
94 [ + + ]: 35730 : for (e = root; e->next != NULL; e = e->next) ;
95 : 16824 : e->next = s;
96 : : }
97 : : else {
98 : 18818 : root = s;
99 : : }
100 : 35642 : }
101 : :
102 : : // This function counts the string in the list.
103 : 1104705 : int strlist::length (void) const {
104 : 1104705 : int res = 0;
105 [ + + ]: 1309788 : for (struct strlist_t * s = root; s != NULL; s = s->next) res++;
106 : 1104705 : return res;
107 : : }
108 : :
109 : : // This function finds the specified string in the list.
110 : 378219 : int strlist::contains (const char * const str) const {
111 : 378219 : int res = 0;
112 [ + + ]: 671874 : for (struct strlist_t * s = root; s != NULL; s = s->next) {
113 [ + - ][ + - ]: 293655 : if (s->str != NULL && str != NULL && !strcmp (s->str, str))
[ + + ]
114 : 90454 : res++;
115 : : }
116 : 378219 : return res;
117 : : }
118 : :
119 : : /* The returns the position of the first occurrence of the specified
120 : : string in the list or -1 if it does not contains the string. */
121 : 118 : int strlist::index (char * str) {
122 : 118 : int res = 0;
123 [ + + ]: 158 : for (struct strlist_t * s = root; s != NULL; s = s->next, res++) {
124 [ + - ][ + - ]: 40 : if (s->str != NULL && str != NULL && !strcmp (s->str, str))
[ - + ]
125 : 0 : return res;
126 : : }
127 : 118 : return -1;
128 : : }
129 : :
130 : : /* This function returns the string positioned at the specified
131 : : location in the string list. */
132 : 51801 : char * strlist::get (int pos) const {
133 : 51801 : struct strlist_t * s = root;
134 [ + + ][ + - ]: 94210 : for (int i = 0; i < pos && s != NULL; s = s->next, i++) ;
[ + + ]
135 [ + - ]: 51801 : return s ? s->str : NULL;
136 : : }
137 : :
138 : : /* This function returns the string positioned at the end of the
139 : : string list. */
140 : 0 : char * strlist::last (void) const {
141 : : struct strlist_t * s;
142 [ # # ][ # # ]: 0 : for (s = root; s != NULL && s->next != NULL; s = s->next) ;
[ # # ]
143 [ # # ]: 0 : return s ? s->str : NULL;
144 : : }
145 : :
146 : : /* This function returns the string positioned at the beginning of the
147 : : string list. */
148 : 0 : char * strlist::first (void) const {
149 : 0 : struct strlist_t * s = root;
150 [ # # ]: 0 : return s ? s->str : NULL;
151 : : }
152 : :
153 : : /* The function removes each occurrence of the given string list entry
154 : : from the string list object. */
155 : 127879 : void strlist::del (strlist * cand) {
156 [ + - ]: 127879 : if (cand == NULL) return;
157 : : struct strlist_t * next;
158 : 0 : strlist * res = new strlist ();
159 [ # # ]: 0 : while (root) {
160 : 0 : next = root->next;
161 [ # # ]: 0 : if (cand->contains (root->str) == 0) res->append (root->str);
162 [ # # ]: 0 : if (root->str) free (root->str);
163 : 0 : free (root);
164 : 0 : root = next;
165 : : }
166 : 0 : *this = *res;
167 : : }
168 : :
169 : : /* The function joins the given string lists to each other and returns
170 : : the resulting list. */
171 : 135557 : strlist * strlist::join (strlist * pre, strlist * post) {
172 [ + + ][ + - ]: 135557 : strlist * res = pre ? new strlist (*pre) : new strlist ();
173 [ + + ][ + + ]: 142563 : for (int i = 0; post != NULL && i < post->length (); i++)
[ + + ]
174 : 7006 : res->append (post->get (i));
175 : 135557 : return res;
176 : : }
177 : :
178 : : /* The function returns a space seperated string representation of the
179 : : string list instance. */
180 : 119 : char * strlist::toString (const char * concat) {
181 [ + + ]: 119 : if (txt) { free (txt); txt = NULL; }
182 : 119 : int size = 0;
183 [ + + ]: 269 : for (struct strlist_t * s = root; s != NULL; s = s->next) {
184 [ + - ]: 150 : char * t = s->str ? s->str : (char *) "(null)";
185 : 150 : int len = strlen (t);
186 : 150 : size += len + strlen (concat) + 1;
187 [ + + ]: 150 : txt = (char *) (txt ? realloc (txt, size) : malloc (size));
188 [ + + ]: 150 : txt = (s == root) ? strcpy (txt, t) : strcat (txt, t);
189 : 150 : txt = strcat (txt, concat);
190 : : }
191 [ + - ]: 119 : if (txt) txt[strlen (txt) - 1] = '\0';
192 [ + - ]: 119 : return txt ? txt : (char *) "";
193 : : }
194 : :
195 : : // Constructor for string list iterator.
196 : 0 : strlistiterator::strlistiterator (strlist & s) {
197 : 0 : _strlist = &s;
198 : 0 : toLast ();
199 : 0 : toFirst ();
200 : 0 : }
201 : :
202 : : // Another constructor for string list iterator.
203 : 930 : strlistiterator::strlistiterator (strlist * s) {
204 : 930 : _strlist = s;
205 : 930 : toLast ();
206 : 930 : toFirst ();
207 : 930 : }
208 : :
209 : : // Default constructor for string list iterator.
210 : 1 : strlistiterator::strlistiterator () {
211 : 1 : _strlist = NULL;
212 : 1 : _first = _last = _current = NULL;
213 : 1 : }
214 : :
215 : : // Destructor for string list iterator.
216 : 931 : strlistiterator::~strlistiterator () {
217 : 931 : }
218 : :
219 : : // Returns number of items this iterator operates on.
220 : 0 : int strlistiterator::count (void) {
221 : 0 : return _strlist->length ();
222 : : }
223 : :
224 : : // Sets the current to the first item in the iterator list.
225 : 930 : char * strlistiterator::toFirst (void) {
226 : 930 : _current = _first = _strlist->root;
227 [ + - ]: 930 : return _current ? _current->str : NULL;
228 : : }
229 : :
230 : : // Sets the current to the last item in the iterator list.
231 : 930 : char * strlistiterator::toLast (void) {
232 [ + - ][ + + ]: 1172 : for (_last = _strlist->root; _last && _last->next; _last = _last->next) ;
[ + + ]
233 : 930 : _current = _last;
234 [ + - ]: 930 : return _current ? _current->str : NULL;
235 : : }
236 : :
237 : : // Makes the succeeding item current and returns the new current item.
238 : 1172 : char * strlistiterator::operator++ (void) {
239 : 1172 : _current = _current->next;
240 [ + + ]: 1172 : return _current ? _current->str : NULL;
241 : : }
242 : :
243 : : // Returns the current iterator item.
244 : 3278 : char * strlistiterator::current (void) {
245 [ + + ]: 3278 : return _current ? _current->str : NULL;
246 : : }
247 : :
248 : : // Returns the first iterator item.
249 : 0 : char * strlistiterator::first (void) {
250 [ # # ]: 0 : return _first ? _first->str : NULL;
251 : : }
252 : :
253 : : // Returns the last iterator item.
254 : 0 : char * strlistiterator::last (void) {
255 [ # # ]: 0 : return _last ? _last->str : NULL;
256 : : }
257 : :
258 : : } // namespace qucs
|
