1 files changed, 162 insertions, 161 deletions
diff --git a/noncore/todayplugins/stockticker/libstocks/csv.c b/noncore/todayplugins/stockticker/libstocks/csv.c
index 99a44e4..27bcce6 100644
--- a/noncore/todayplugins/stockticker/libstocks/csv.c
+++ b/noncore/todayplugins/stockticker/libstocks/csv.c
@@ -9,7 +9,7 @@
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
-         * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
@@ -19,6 +19,7 @@
 */
 #define __CSV_C__
+#ifdef __UNIX__
 #include <string.h>
 #include <stdlib.h>
@@ -126,152 +127,152 @@ stock *parse_csv_file(char *csv)
      test = line;
      valid = 0;
      while ( (test = strstr(test, "N/A")) )
-        {
+  {
-          valid ++;
+    valid ++;
-          test = test +3;
+    test = test +3;
-        }
+  }
      
      if (valid < 6)
-        {
+  {
-          /* This Symbol is valid */
+    /* This Symbol is valid */
-          StockPtr = malloc_stock();
+    StockPtr = malloc_stock();
-          
+    
-          ptr = csv_strtok(line, ",");
+    ptr = csv_strtok(line, ",");
-          if (!ptr) return 0;
+    if (!ptr) return 0;
-          symbol = (char *)malloc(strlen(ptr)+1);
+    symbol = (char *)malloc(strlen(ptr)+1);
-          if (symbol==NULL)
+    if (symbol==NULL)
-            {
+      {
-              fprintf(stderr,"Memory allocating error (%s line %d)\n"
+        fprintf(stderr,"Memory allocating error (%s line %d)\n"
-                      ,__FILE__, __LINE__);
+          ,__FILE__, __LINE__);
-              exit(1);
+        exit(1);
-            }
+      }
-          strcpy((char *)(symbol), ptr);
+    strcpy((char *)(symbol), ptr);
-          StockPtr->Symbol = symbol;
+    StockPtr->Symbol = symbol;
-          ptr = csv_strtok(NULL, ",");
+    ptr = csv_strtok(NULL, ",");
-          if (!ptr) return 0;
+    if (!ptr) return 0;
-          name = (char *)malloc(strlen(ptr)+1);
+    name = (char *)malloc(strlen(ptr)+1);
-          if (name==NULL)
+    if (name==NULL)
-            {
+      {
-              fprintf(stderr,"Memory allocating error (%s line %d)\n"
+        fprintf(stderr,"Memory allocating error (%s line %d)\n"
-                      ,__FILE__, __LINE__);
+          ,__FILE__, __LINE__);
-              exit(1);
+        exit(1);
-            }
+      }
-          strcpy((char *)(name), ptr);
+    strcpy((char *)(name), ptr);
-          StockPtr->Name = name;
+    StockPtr->Name = name;
-          ptr = csv_strtok(NULL, ",");
+    ptr = csv_strtok(NULL, ",");
-          if (!ptr) return 0;
+    if (!ptr) return 0;
-          sscanf(ptr,"%f",&(StockPtr->CurrentPrice));
+    sscanf(ptr,"%f",&(StockPtr->CurrentPrice));
-          ptr = csv_strtok(NULL, ",");
+    ptr = csv_strtok(NULL, ",");
-          if (!ptr) return 0;
+    if (!ptr) return 0;
-          date = (char *)malloc(strlen(ptr)+1);
+    date = (char *)malloc(strlen(ptr)+1);
-          if (date==NULL)
+    if (date==NULL)
-            {
+      {
-              fprintf(stderr,"Memory allocating error (%s line %d)\n"
+        fprintf(stderr,"Memory allocating error (%s line %d)\n"
-                      ,__FILE__, __LINE__);
+          ,__FILE__, __LINE__);
-              exit(1);
+        exit(1);
-            }
+      }
-          strcpy((char *)(date), ptr);
+    strcpy((char *)(date), ptr);
-          StockPtr->Date = date;
+    StockPtr->Date = date;
-          ptr = csv_strtok(NULL, ",");
+    ptr = csv_strtok(NULL, ",");
-          if (!ptr) return 0;
+    if (!ptr) return 0;
-          time = (char *)malloc(strlen(ptr)+1);
+    time = (char *)malloc(strlen(ptr)+1);
-          if (time==NULL)
+    if (time==NULL)
-            {
+      {
-              fprintf(stderr,"Memory allocating error (%s line %d)\n"
+        fprintf(stderr,"Memory allocating error (%s line %d)\n"
-                      ,__FILE__, __LINE__);
+          ,__FILE__, __LINE__);
-              exit(1);
+        exit(1);
-            }
+      }
-          strcpy((char *)(time), ptr);
+    strcpy((char *)(time), ptr);
-          StockPtr->Time = time;
+    StockPtr->Time = time;
-          
+    
-          ptr = csv_strtok(NULL, ",");
+    ptr = csv_strtok(NULL, ",");
-          if (!ptr) return 0;
+    if (!ptr) return 0;
-          sscanf(ptr,"%f",&(StockPtr->Variation));      
+    sscanf(ptr,"%f",&(StockPtr->Variation));      
-          
+    
-          StockPtr->Pourcentage = 100 * StockPtr->Variation /
+    StockPtr->Pourcentage = 100 * StockPtr->Variation /
-            (StockPtr->CurrentPrice - StockPtr->Variation);
+      (StockPtr->CurrentPrice - StockPtr->Variation);
-          StockPtr->LastPrice = StockPtr->CurrentPrice - StockPtr->Variation;
+    StockPtr->LastPrice = StockPtr->CurrentPrice - StockPtr->Variation;
-          ptr = csv_strtok(NULL, ",");
+    ptr = csv_strtok(NULL, ",");
-          if (!ptr) return 0;
+    if (!ptr) return 0;
-          sscanf(ptr,"%f",&(StockPtr->OpenPrice));      
+    sscanf(ptr,"%f",&(StockPtr->OpenPrice));      
-          ptr = csv_strtok(NULL, ",");
+    ptr = csv_strtok(NULL, ",");
-          if (!ptr) return 0;
+    if (!ptr) return 0;
-          sscanf(ptr,"%f",&(StockPtr->MaxPrice));      
+    sscanf(ptr,"%f",&(StockPtr->MaxPrice));      
-          ptr = csv_strtok(NULL, ",");
+    ptr = csv_strtok(NULL, ",");
-          if (!ptr) return 0;
+    if (!ptr) return 0;
-          sscanf(ptr,"%f",&(StockPtr->MinPrice));      
+    sscanf(ptr,"%f",&(StockPtr->MinPrice));      
  
-          ptr = csv_strtok(NULL, ",");
+    ptr = csv_strtok(NULL, ",");
-          if (!ptr) return 0;
+    if (!ptr) return 0;
-          StockPtr->Volume = atoi(ptr);
+    StockPtr->Volume = atoi(ptr);
-          if( !FirstStockPtr ) 
+    if( !FirstStockPtr ) 
-            {
+      {
-              FirstStockPtr = StockPtr;
+        FirstStockPtr = StockPtr;
-              StockPtr->PreviousStock = 0;
+        StockPtr->PreviousStock = 0;
-            }
+      }
-          
+    
-          StockPtr->NextStock = 0;
+    StockPtr->NextStock = 0;
-        
+  
-          if (LastStockPtr) 
+    if (LastStockPtr) 
-            {
+      {
-              LastStockPtr->NextStock = StockPtr;
+        LastStockPtr->NextStock = StockPtr;
-              StockPtr->PreviousStock = LastStockPtr;
+        StockPtr->PreviousStock = LastStockPtr;
-            }
+      }
-          
+    
-          LastStockPtr = StockPtr;
+    LastStockPtr = StockPtr;
-          
+    
-        }
+  }
      else
-        {
+  {
-          /* this symbol is not valid */
+    /* this symbol is not valid */
-          /* Set the stock struct just with Symbol, all other are NULL */
+    /* Set the stock struct just with Symbol, all other are NULL */
-          /* This can be used to see if the symbol has been reached are not */
+    /* This can be used to see if the symbol has been reached are not */
-          StockPtr = malloc_stock();
+    StockPtr = malloc_stock();
-          
+    
-          ptr = csv_strtok(line, ",");
+    ptr = csv_strtok(line, ",");
-          if (!ptr) return 0;
+    if (!ptr) return 0;
-          symbol = (char *)malloc(strlen(ptr)+1);
+    symbol = (char *)malloc(strlen(ptr)+1);
-          if (symbol==NULL)
+    if (symbol==NULL)
-            {
+      {
-              fprintf(stderr,"Memory allocating error (%s line %d)\n"
+        fprintf(stderr,"Memory allocating error (%s line %d)\n"
-                      ,__FILE__, __LINE__);
+          ,__FILE__, __LINE__);
-              exit(1);
+        exit(1);
-            }
+      }
-          strcpy((char *)(symbol), ptr);
+    strcpy((char *)(symbol), ptr);
-          StockPtr->Symbol = symbol;
+    StockPtr->Symbol = symbol;
-          if( !FirstStockPtr ) 
+    if( !FirstStockPtr ) 
-            {
+      {
-              FirstStockPtr = StockPtr;
+        FirstStockPtr = StockPtr;
-              StockPtr->PreviousStock = 0;
+        StockPtr->PreviousStock = 0;
-            }
+      }
-          
+    
-          StockPtr->NextStock = 0;
+    StockPtr->NextStock = 0;
-        
+  
-          if (LastStockPtr) 
+    if (LastStockPtr) 
-            {
+      {
-              LastStockPtr->NextStock = StockPtr;
+        LastStockPtr->NextStock = StockPtr;
-              StockPtr->PreviousStock = LastStockPtr;
+        StockPtr->PreviousStock = LastStockPtr;
-            }
+      }
-          
+    
-          LastStockPtr = StockPtr;
+    LastStockPtr = StockPtr;
-        }
+  }
      end_line++;
      line = end_line; 
@@ -321,7 +322,7 @@ stock *parse_csv_history_file(char *csv_file)
      *end_line = 0;
      StockPtr = malloc_stock();
-          
+    
      /* Date */
      ptr = strtok(line, ",");
      if (!ptr) return 0;
@@ -340,11 +341,11 @@ stock *parse_csv_history_file(char *csv_file)
      date = (char *)malloc(DATE_LENGTH);
      if (date==NULL)
-        {
+  {
-          fprintf(stderr,"Memory allocating error (%s line %d)\n"
+    fprintf(stderr,"Memory allocating error (%s line %d)\n"
-                  ,__FILE__, __LINE__);
+      ,__FILE__, __LINE__);
-          exit(1);
+    exit(1);
-        }
+  }
      sprintf(date,"%.2d%.2d%.2d", year, month, day);
      StockPtr->Date = date;    
      
@@ -372,25 +373,25 @@ stock *parse_csv_history_file(char *csv_file)
      ptr = strtok(NULL, ",");
      if (!ptr) 
-        /* It seems to be an indice */
+  /* It seems to be an indice */
-        /* No volume for indices */
+  /* No volume for indices */
-        StockPtr->Volume = 0;
+  StockPtr->Volume = 0;
      else
-        StockPtr->Volume = atoi(ptr);
+  StockPtr->Volume = atoi(ptr);
      if( !FirstStockPtr ) 
-        {
+  {
-          FirstStockPtr = StockPtr;
+    FirstStockPtr = StockPtr;
-          StockPtr->PreviousStock = 0;
+    StockPtr->PreviousStock = 0;
-        }
+  }
      
      StockPtr->NextStock = 0;
      
      if (LastStockPtr) 
-        {
+  {
-          LastStockPtr->NextStock = StockPtr;
+    LastStockPtr->NextStock = StockPtr;
-          StockPtr->PreviousStock = LastStockPtr;
+    StockPtr->PreviousStock = LastStockPtr;
-        }
+  }
      
      LastStockPtr = StockPtr;

diff --git a/noncore/todayplugins/stockticker/libstocks/csv.c b/noncore/todayplugins/stockticker/libstocks/csv.c index 99a44e4..27bcce6 100644 --- a/noncore/todayplugins/stockticker/libstocks/csv.c +++ b/noncore/todayplugins/stockticker/libstocks/csv.c
@@ -9,7 +9,7 @@
9	*	9	*
10	* This library is distributed in the hope that it will be useful,	10	* This library is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13	* Library General Public License for more details.	13	* Library General Public License for more details.
14	*	14	*
15	* You should have received a copy of the GNU Library General Public	15	* You should have received a copy of the GNU Library General Public
@@ -19,6 +19,7 @@
19	*/	19	*/
20		20
21	#define __CSV_C__	21	#define __CSV_C__
		22	#ifdef __UNIX__
22		23
23	#include <string.h>	24	#include <string.h>
24	#include <stdlib.h>	25	#include <stdlib.h>
@@ -126,152 +127,152 @@ stock parse_csv_file(char csv)
126	test = line;	127	test = line;
127	valid = 0;	128	valid = 0;
128	while ( (test = strstr(test, "N/A")) )	129	while ( (test = strstr(test, "N/A")) )
129	{	130	{
130	valid ++;	131	valid ++;
131	test = test +3;	132	test = test +3;
132	}	133	}
133		134
134	if (valid < 6)	135	if (valid < 6)
135	{	136	{
136	/* This Symbol is valid */	137	/* This Symbol is valid */
137		138
138	StockPtr = malloc_stock();	139	StockPtr = malloc_stock();
139		140
140	ptr = csv_strtok(line, ",");	141	ptr = csv_strtok(line, ",");
141	if (!ptr) return 0;	142	if (!ptr) return 0;
142		143
143	symbol = (char *)malloc(strlen(ptr)+1);	144	symbol = (char *)malloc(strlen(ptr)+1);
144	if (symbol==NULL)	145	if (symbol==NULL)
145	{	146	{
146	fprintf(stderr,"Memory allocating error (%s line %d)\n"	147	fprintf(stderr,"Memory allocating error (%s line %d)\n"
147	,__FILE__, __LINE__);	148	,__FILE__, __LINE__);
148	exit(1);	149	exit(1);
149	}	150	}
150	strcpy((char *)(symbol), ptr);	151	strcpy((char *)(symbol), ptr);
151	StockPtr->Symbol = symbol;	152	StockPtr->Symbol = symbol;
152		153
153	ptr = csv_strtok(NULL, ",");	154	ptr = csv_strtok(NULL, ",");
154	if (!ptr) return 0;	155	if (!ptr) return 0;
155		156
156	name = (char *)malloc(strlen(ptr)+1);	157	name = (char *)malloc(strlen(ptr)+1);
157	if (name==NULL)	158	if (name==NULL)
158	{	159	{
159	fprintf(stderr,"Memory allocating error (%s line %d)\n"	160	fprintf(stderr,"Memory allocating error (%s line %d)\n"
160	,__FILE__, __LINE__);	161	,__FILE__, __LINE__);
161	exit(1);	162	exit(1);
162	}	163	}
163	strcpy((char *)(name), ptr);	164	strcpy((char *)(name), ptr);
164	StockPtr->Name = name;	165	StockPtr->Name = name;
165		166
166	ptr = csv_strtok(NULL, ",");	167	ptr = csv_strtok(NULL, ",");
167	if (!ptr) return 0;	168	if (!ptr) return 0;
168	sscanf(ptr,"%f",&(StockPtr->CurrentPrice));	169	sscanf(ptr,"%f",&(StockPtr->CurrentPrice));
169		170
170	ptr = csv_strtok(NULL, ",");	171	ptr = csv_strtok(NULL, ",");
171	if (!ptr) return 0;	172	if (!ptr) return 0;
172		173
173	date = (char *)malloc(strlen(ptr)+1);	174	date = (char *)malloc(strlen(ptr)+1);
174	if (date==NULL)	175	if (date==NULL)
175	{	176	{
176	fprintf(stderr,"Memory allocating error (%s line %d)\n"	177	fprintf(stderr,"Memory allocating error (%s line %d)\n"
177	,__FILE__, __LINE__);	178	,__FILE__, __LINE__);
178	exit(1);	179	exit(1);
179	}	180	}
180	strcpy((char *)(date), ptr);	181	strcpy((char *)(date), ptr);
181	StockPtr->Date = date;	182	StockPtr->Date = date;
182		183
183	ptr = csv_strtok(NULL, ",");	184	ptr = csv_strtok(NULL, ",");
184	if (!ptr) return 0;	185	if (!ptr) return 0;
185		186
186	time = (char *)malloc(strlen(ptr)+1);	187	time = (char *)malloc(strlen(ptr)+1);
187	if (time==NULL)	188	if (time==NULL)
188	{	189	{
189	fprintf(stderr,"Memory allocating error (%s line %d)\n"	190	fprintf(stderr,"Memory allocating error (%s line %d)\n"
190	,__FILE__, __LINE__);	191	,__FILE__, __LINE__);
191	exit(1);	192	exit(1);
192	}	193	}
193	strcpy((char *)(time), ptr);	194	strcpy((char *)(time), ptr);
194	StockPtr->Time = time;	195	StockPtr->Time = time;
195		196
196	ptr = csv_strtok(NULL, ",");	197	ptr = csv_strtok(NULL, ",");
197	if (!ptr) return 0;	198	if (!ptr) return 0;
198	sscanf(ptr,"%f",&(StockPtr->Variation));	199	sscanf(ptr,"%f",&(StockPtr->Variation));
199		200
200	StockPtr->Pourcentage = 100 * StockPtr->Variation /	201	StockPtr->Pourcentage = 100 * StockPtr->Variation /
201	(StockPtr->CurrentPrice - StockPtr->Variation);	202	(StockPtr->CurrentPrice - StockPtr->Variation);
202		203
203	StockPtr->LastPrice = StockPtr->CurrentPrice - StockPtr->Variation;	204	StockPtr->LastPrice = StockPtr->CurrentPrice - StockPtr->Variation;
204		205
205	ptr = csv_strtok(NULL, ",");	206	ptr = csv_strtok(NULL, ",");
206	if (!ptr) return 0;	207	if (!ptr) return 0;
207	sscanf(ptr,"%f",&(StockPtr->OpenPrice));	208	sscanf(ptr,"%f",&(StockPtr->OpenPrice));
208		209
209	ptr = csv_strtok(NULL, ",");	210	ptr = csv_strtok(NULL, ",");
210	if (!ptr) return 0;	211	if (!ptr) return 0;
211	sscanf(ptr,"%f",&(StockPtr->MaxPrice));	212	sscanf(ptr,"%f",&(StockPtr->MaxPrice));
212		213
213	ptr = csv_strtok(NULL, ",");	214	ptr = csv_strtok(NULL, ",");
214	if (!ptr) return 0;	215	if (!ptr) return 0;
215	sscanf(ptr,"%f",&(StockPtr->MinPrice));	216	sscanf(ptr,"%f",&(StockPtr->MinPrice));
216		217
217	ptr = csv_strtok(NULL, ",");	218	ptr = csv_strtok(NULL, ",");
218	if (!ptr) return 0;	219	if (!ptr) return 0;
219	StockPtr->Volume = atoi(ptr);	220	StockPtr->Volume = atoi(ptr);
220		221
221	if( !FirstStockPtr )	222	if( !FirstStockPtr )
222	{	223	{
223	FirstStockPtr = StockPtr;	224	FirstStockPtr = StockPtr;
224	StockPtr->PreviousStock = 0;	225	StockPtr->PreviousStock = 0;
225	}	226	}
226		227
227	StockPtr->NextStock = 0;	228	StockPtr->NextStock = 0;
228		229
229	if (LastStockPtr)	230	if (LastStockPtr)
230	{	231	{
231	LastStockPtr->NextStock = StockPtr;	232	LastStockPtr->NextStock = StockPtr;
232	StockPtr->PreviousStock = LastStockPtr;	233	StockPtr->PreviousStock = LastStockPtr;
233	}	234	}
234		235
235	LastStockPtr = StockPtr;	236	LastStockPtr = StockPtr;
236		237
237	}	238	}
238	else	239	else
239	{	240	{
240	/* this symbol is not valid */	241	/* this symbol is not valid */
241	/* Set the stock struct just with Symbol, all other are NULL */	242	/* Set the stock struct just with Symbol, all other are NULL */
242	/* This can be used to see if the symbol has been reached are not */	243	/* This can be used to see if the symbol has been reached are not */
243		244
244	StockPtr = malloc_stock();	245	StockPtr = malloc_stock();
245		246
246	ptr = csv_strtok(line, ",");	247	ptr = csv_strtok(line, ",");
247	if (!ptr) return 0;	248	if (!ptr) return 0;
248		249
249	symbol = (char *)malloc(strlen(ptr)+1);	250	symbol = (char *)malloc(strlen(ptr)+1);
250	if (symbol==NULL)	251	if (symbol==NULL)
251	{	252	{
252	fprintf(stderr,"Memory allocating error (%s line %d)\n"	253	fprintf(stderr,"Memory allocating error (%s line %d)\n"
253	,__FILE__, __LINE__);	254	,__FILE__, __LINE__);
254	exit(1);	255	exit(1);
255	}	256	}
256	strcpy((char *)(symbol), ptr);	257	strcpy((char *)(symbol), ptr);
257	StockPtr->Symbol = symbol;	258	StockPtr->Symbol = symbol;
258		259
259	if( !FirstStockPtr )	260	if( !FirstStockPtr )
260	{	261	{
261	FirstStockPtr = StockPtr;	262	FirstStockPtr = StockPtr;
262	StockPtr->PreviousStock = 0;	263	StockPtr->PreviousStock = 0;
263	}	264	}
264		265
265	StockPtr->NextStock = 0;	266	StockPtr->NextStock = 0;
266		267
267	if (LastStockPtr)	268	if (LastStockPtr)
268	{	269	{
269	LastStockPtr->NextStock = StockPtr;	270	LastStockPtr->NextStock = StockPtr;
270	StockPtr->PreviousStock = LastStockPtr;	271	StockPtr->PreviousStock = LastStockPtr;
271	}	272	}
272		273
273	LastStockPtr = StockPtr;	274	LastStockPtr = StockPtr;
274	}	275	}
275		276
276	end_line++;	277	end_line++;
277	line = end_line;	278	line = end_line;
@@ -321,7 +322,7 @@ stock parse_csv_history_file(char csv_file)
321	*end_line = 0;	322	*end_line = 0;
322		323
323	StockPtr = malloc_stock();	324	StockPtr = malloc_stock();
324		325
325	/* Date */	326	/* Date */
326	ptr = strtok(line, ",");	327	ptr = strtok(line, ",");
327	if (!ptr) return 0;	328	if (!ptr) return 0;
@@ -340,11 +341,11 @@ stock parse_csv_history_file(char csv_file)
340		341
341	date = (char *)malloc(DATE_LENGTH);	342	date = (char *)malloc(DATE_LENGTH);
342	if (date==NULL)	343	if (date==NULL)
343	{	344	{
344	fprintf(stderr,"Memory allocating error (%s line %d)\n"	345	fprintf(stderr,"Memory allocating error (%s line %d)\n"
345	,__FILE__, __LINE__);	346	,__FILE__, __LINE__);
346	exit(1);	347	exit(1);
347	}	348	}
348	sprintf(date,"%.2d%.2d%.2d", year, month, day);	349	sprintf(date,"%.2d%.2d%.2d", year, month, day);
349	StockPtr->Date = date;	350	StockPtr->Date = date;
350		351
@@ -372,25 +373,25 @@ stock parse_csv_history_file(char csv_file)
372		373
373	ptr = strtok(NULL, ",");	374	ptr = strtok(NULL, ",");
374	if (!ptr)	375	if (!ptr)
375	/* It seems to be an indice */	376	/* It seems to be an indice */
376	/* No volume for indices */	377	/* No volume for indices */
377	StockPtr->Volume = 0;	378	StockPtr->Volume = 0;
378	else	379	else
379	StockPtr->Volume = atoi(ptr);	380	StockPtr->Volume = atoi(ptr);
380		381
381	if( !FirstStockPtr )	382	if( !FirstStockPtr )
382	{	383	{
383	FirstStockPtr = StockPtr;	384	FirstStockPtr = StockPtr;
384	StockPtr->PreviousStock = 0;	385	StockPtr->PreviousStock = 0;
385	}	386	}
386		387
387	StockPtr->NextStock = 0;	388	StockPtr->NextStock = 0;
388		389
389	if (LastStockPtr)	390	if (LastStockPtr)
390	{	391	{
391	LastStockPtr->NextStock = StockPtr;	392	LastStockPtr->NextStock = StockPtr;
392	StockPtr->PreviousStock = LastStockPtr;	393	StockPtr->PreviousStock = LastStockPtr;
393	}	394	}
394		395
395	LastStockPtr = StockPtr;	396	LastStockPtr = StockPtr;
396		397