source: trunk/src/libsrc/lib330/libtokens.c @ 6881

Revision 6881, 28.0 KB checked in by kevin, 2 years ago (diff)

resolved 64 bit pointer of different size warnings found in comserv2

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*   Lib330 DP Token Processing
2     Copyright 2006-2010 Certified Software Corporation
3
4    This file is part of Lib330
5
6    Lib330 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 of the License, or
9    (at your option) any later version.
10
11    Lib330 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 Lib330; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
20Edit History:
21   Ed Date       By  Changes
22   -- ---------- --- ---------------------------------------------------
23    0 2006-10-01 rdr Created
24    1 2007-03-06 rdr Add call to purge_continuity.
25    2 2007-03-12 rdr Don't purge continuity here, wait until receive data.
26    3 2008-01-10 rdr Move LOG into DP LCQs. DPLCQ buffers come out of thrbuf
27                     instead of using getmem.
28    4 2009-07-30 rdr Move uppercase to libsupport.
29    5 2010-03-27 rdr Add Q335 support.
30    6 2011-07-24 rdr Fix bug in loading opaque token data.
31*/
32#ifndef libclient_h
33#include "libclient.h"
34#endif
35#ifndef libcmds_h
36#include "libcmds.h"
37#endif
38#ifndef libmsgs_h
39#include "libmsgs.h"
40#endif
41#ifndef libcvrt_h
42#include "libcvrt.h"
43#endif
44#ifndef libslider_h
45#include "libslider.h"
46#endif
47#ifndef q330cvrt_h
48#include "q330cvrt.h"
49#endif
50#ifndef OMIT_SEED
51#ifndef libopaque_h
52#include "libopaque.h"
53#endif
54#ifndef libfilters_h
55#include "libfilters.h"
56#endif
57#ifndef libctrldet_h
58#include "libctrldet.h"
59#endif
60#ifndef libarchive_h
61#include "libarchive.h"
62#endif
63#endif
64#ifndef libsampcfg_h
65#include "libsampcfg.h"
66#endif
67#ifndef libcont_h
68#include "libcont.h"
69#endif
70#ifndef libsupport_h
71#include "libsupport.h"
72#endif
73#ifndef libtokens_h
74#include "libtokens.h"
75#endif
76
77#ifndef OMIT_SEED
78void read_iir (paqstruc paqs, pbyte *p)
79begin
80  piirdef cur_iir ;
81  integer i ;
82  pq330 q330 ;
83  tsection_base *psb ;
84  integer len ;
85
86  q330 = paqs->owner ;
87  getbuf (q330, addr(cur_iir), sizeof(tiirdef)) ;
88  if (paqs->iirchain == NIL)
89    then
90      paqs->iirchain = cur_iir ;
91    else
92      paqs->iirchain = extend_link (paqs->iirchain, cur_iir) ;
93  cur_iir->iir_num = loadbyte (p) ;
94  len = loadbyte(p) ;
95  loadblock (p, len, addr(cur_iir->fname)) ;
96  cur_iir->fname[len] = 0 ; /* terminate string */
97  cur_iir->sects = loadbyte (p) ;
98  cur_iir->gain = loadsingle (p) ;
99  cur_iir->rate = loadsingle (p) ;
100  for (i = 1 ; i <= cur_iir->sects ; i++)
101    begin
102      psb = addr(cur_iir->filt[i]) ;
103      psb->ratio = loadsingle (p) ;
104      psb->poles = loadbyte (p) ;
105      if (psb->poles and 128)
106        then
107          begin
108            psb->poles = psb->poles and 127 ;
109            psb->highpass = TRUE ;
110          end
111      calc_section (addr(cur_iir->filt[i])) ;
112    end
113end
114
115void read_fir (paqstruc paqs, pbyte *p)
116begin
117  pfilter cur_fir ;
118  byte fnum ;
119  string31 ucfname, ucs ;
120  integer len ;
121
122  fnum = loadbyte (p) ;
123  len = loadbyte(p) ;
124  loadblock (p, len, addr(ucs)) ;
125  ucs[len] = 0 ;
126  lib330_upper(addr(ucs)) ;
127  cur_fir = paqs->firchain ;
128  while (cur_fir)
129    begin
130      strcpy(ucfname, cur_fir->fname) ;
131      lib330_upper(addr(ucfname)) ;
132      if (strcmp(ucfname, ucs) == 0)
133        then
134          begin
135            cur_fir->fir_num = fnum ;
136            return ;
137          end
138        else
139          cur_fir = cur_fir->link ;
140    end
141end
142
143void read_detector (paqstruc paqs, pbyte *p, boolean mh)
144begin
145  pdetector cur_def ;
146  tdet_mh dm ;
147  pq330 q330 ;
148  integer len ;
149
150  q330 = paqs->owner ;
151  getbuf (q330, addr(cur_def), sizeof(tdetector)) ;
152  if (paqs->defchain == NIL)
153    then
154      paqs->defchain = cur_def ;
155    else
156      paqs->defchain = extend_link (paqs->defchain, cur_def) ;
157  dm.num = loadbyte (p) ; /* detector number */
158  dm.filtnum = loadbyte (p) ; /* filter number */
159  dm.iw = loadbyte (p) ; /* iw parameter */
160  dm.nht = loadbyte (p) ; /* nht parameter */
161  dm.fhi = loadlongint (p) ; /* fhi/filhi parameter */
162  dm.flo = loadlongint (p) ; /* flo/fillo parameter */
163  dm.wa = loadword (p) ; /* wa parameter */
164  dm.spare = loadword (p) ; /* needed for this compiler */
165  if (mh)
166    then
167      begin
168        dm.tc = loadword (p) ; /* tc number */
169        dm.x1_2 = loadbyte (p) ; /* x1 parameter / 2 */
170        dm.x2_2 = loadbyte (p) ; /* x2 parameter / 2 */
171        dm.x3_2 = loadbyte (p) ; /* x3 parameter / 2 */
172        dm.xx = loadbyte (p) ; /* xx parameter */
173        dm.av = loadbyte (p) ; /* av parameter */
174      end
175  cur_def->detector_num = dm.num ;
176  if (dm.filtnum != 0xFF)
177    then
178      cur_def->detfilt = find_iir(paqs, dm.filtnum) ;
179  cur_def->uconst.iwin = dm.iw ;
180  cur_def->uconst.filhi = dm.fhi ;
181  cur_def->uconst.fillo = dm.flo ;
182  cur_def->uconst.wait_blk = dm.wa ;
183  cur_def->uconst.n_hits = dm.nht ;
184  if (mh)
185    then
186      begin
187        cur_def->uconst.xth1 = dm.x1_2 shl 1 ;
188        cur_def->uconst.xth2 = dm.x2_2 shl 1 ;
189        cur_def->uconst.xth3 = dm.x3_2 shl 1 ;
190        cur_def->uconst.xthx = dm.xx ;
191        cur_def->uconst.def_tc = dm.tc ;
192        cur_def->uconst.val_avg = dm.av ;
193        cur_def->dtype = MURDOCK_HUTT ;
194      end
195    else
196      cur_def->dtype = THRESHOLD ;
197  len = loadbyte(p) ;
198  loadblock (p, len, addr(cur_def->detname)) ;
199  cur_def->detname[len] = 0 ;
200end
201#endif
202
203void set_loc_name (plcq q)
204begin
205  integer i, lth ;
206  string3 s ;
207
208  lth = 0 ;
209  for (i = 0 ; i <= 1 ; i++)
210    if (q->location[i] != ' ')
211      then
212        s[lth++] = q->location[i] ;
213  s[lth] = 0 ;
214  strcpy(addr(q->slocation), s) ;
215  lth = 0 ;
216  for (i = 0 ; i <= 2 ; i++)
217    if (q->seedname[i] != ' ')
218      then
219        s[lth++] = q->seedname[i] ;
220  s[lth] = 0 ;
221  strcpy(addr(q->sseedname), s) ;
222end
223
224static void read_lcq (paqstruc paqs, pbyte *p)
225begin
226  plcq cur_lcq ;
227  byte b ;
228  longword mask ;
229  pq330 q330 ;
230  int16 real_rate ;
231  string95 s ;
232  string15 s2 ;
233#ifndef OMIT_SEED
234  plcq pt ;
235  pdownstream_packet pds ;
236  pdet_packet pdp ;
237  pdetector pd ;
238#endif
239
240  q330 = paqs->owner ;
241  getbuf (q330, addr(cur_lcq), sizeof(tlcq)) ;
242  if (paqs->lcqs == NIL)
243    then
244      paqs->lcqs = cur_lcq ;
245    else
246      paqs->lcqs = extend_link (paqs->lcqs, cur_lcq) ;
247  loadblock (p, 2, addr(cur_lcq->location)) ;
248  loadblock (p, 3, addr(cur_lcq->seedname)) ;
249  set_loc_name (cur_lcq) ;
250  cur_lcq->lcq_num = loadbyte (p) ;
251  if (cur_lcq->lcq_num > paqs->highest_lcqnum)
252    then
253      paqs->highest_lcqnum = cur_lcq->lcq_num ;
254  cur_lcq->raw_data_source = loadbyte (p) ;
255  cur_lcq->raw_data_field = loadbyte (p) ;
256  cur_lcq->lcq_opt = loadlongword (p) ;
257  cur_lcq->rate = loadint16 (p) ;
258  if (((cur_lcq->raw_data_source and DCM) == DC_D32) land (cur_lcq->raw_data_field == HIGH_FREQ_BIT))
259    then
260      begin
261        switch (q330->share.fixed.freq7 and 0x7F) begin
262          case 5 :
263            real_rate = 250 ;
264            break ;
265          case 8 :
266            real_rate = 500 ;
267            break ;
268          case 10 :
269            real_rate = 1000 ;
270            break ;
271          default :
272            real_rate = 0 ;
273            break ;
274        end
275        if (cur_lcq->rate != real_rate)
276          then
277            begin
278              seed2string(cur_lcq->location, cur_lcq->seedname, addr(s2)) ;
279              sprintf (s, "in Token:%d Actual:%d For %s", (integer)cur_lcq->rate,
280                       (integer)real_rate, s2) ;
281              libmsgadd(q330, LIBMSG_HFRATE, addr(s)) ;
282              cur_lcq->rate = real_rate ; /* correct */
283            end
284      end
285  cur_lcq->caldly = 60 ;
286#ifndef OMIT_SEED
287  getbuf (q330, addr(cur_lcq->com), sizeof(tcom_packet)) ;
288  cur_lcq->firfixing_gain = 1.000 ; /* default if not over-ridden */
289  cur_lcq->com->maxframes = 255 ; /* 16K! */
290  cur_lcq->com->frame = 1 ;
291  cur_lcq->com->next_compressed_sample = 1 ;
292#endif
293  if (cur_lcq->lcq_opt and LO_PEB)
294    then
295#ifndef OMIT_SEED
296      cur_lcq->pre_event_buffers =
297#endif
298                           loadword (p) ;
299  if (cur_lcq->lcq_opt and LO_GAP)
300    then
301      cur_lcq->gap_threshold = loadsingle (p) ;
302  if (cur_lcq->gap_threshold == 0.0)
303    then
304      cur_lcq->gap_threshold = 0.5 ;
305  set_gaps (cur_lcq) ;
306  if (cur_lcq->lcq_opt and LO_CALDLY)
307    then
308      cur_lcq->caldly = loadword (p) ;
309  if (cur_lcq->lcq_opt and LO_FRAME)
310    then
311#ifndef OMIT_SEED
312      cur_lcq->com->maxframes =
313#endif
314                        loadbyte (p) ;
315  if (cur_lcq->lcq_opt and LO_FIRMULT)
316    then
317#ifndef OMIT_SEED
318      cur_lcq->firfixing_gain =
319#endif
320                        loadsingle (p) ;
321  if (cur_lcq->lcq_opt and LO_AVG)
322    then
323      begin
324#ifndef OMIT_SEED
325        cur_lcq->avg_length = loadlongword (p) ;
326        b = loadbyte (p) ; /* iir filter number */
327        if (b != 0xFF)
328          then
329            cur_lcq->avg_source = find_iir(paqs, b) ;
330        getbuf (q330, addr(cur_lcq->avg), sizeof(tavg_packet)) ;
331#else
332        loadlongword (p) ;
333        loadbyte (p) ;
334#endif
335      end
336  if (cur_lcq->lcq_opt and LO_CDET)
337    then
338      begin
339        b = loadbyte (p) ; /* control detector number */ ;
340#ifndef OMIT_SEED
341        if (b != 0xFF)
342          then
343            cur_lcq->ctrl = (pcontrol_detector)((pntrint)0xFFFFFF00 or (pntrint)b) ; /* have to resolve these later */
344#endif
345      end
346  if (cur_lcq->lcq_opt and LO_DEC)
347    then
348      begin
349        b = loadbyte (p) ; /* Source LCQ NUMBER */
350#ifndef OMIT_SEED
351        pt = paqs->lcqs ;
352        while (pt)
353          if (pt->lcq_num == b)
354            then
355              begin
356                cur_lcq->prev_link = (pointer) pt ; /* where I get my data from */
357                getbuf (q330, addr(pds), sizeof(tdownstream_packet)) ;
358                pds->link = NIL ;
359                pds->derived_q = cur_lcq ;
360                pt->downstream_link = extend_link (pt->downstream_link, pds) ;
361                break ;
362              end
363            else
364              pt = pt->link ;
365        b = loadbyte (p) ; /* FIR FILTER */
366        if (b != 0xFF)
367          then
368            begin
369              cur_lcq->source_fir = find_fir (paqs, b) ;
370              if (cur_lcq->source_fir == NIL)
371                then
372                  begin
373                    seed2string(cur_lcq->location, cur_lcq->seedname, addr(s)) ;
374                    libmsgadd(q330, LIBMSG_DECNOTFOUND, addr(s)) ;
375                  end
376            end
377#endif
378      end
379  mask = LO_DET1 ;
380  while (mask <= LO_DET8)
381    begin
382      if (cur_lcq->lcq_opt and mask)
383        then
384          begin
385            b = loadbyte (p) ; /* base detector number */
386#ifndef OMIT_SEED
387            pd = paqs->defchain ;
388            while (pd)
389              if (pd->detector_num == b)
390                then
391                  break ;
392                else
393                  pd = pd->link ;
394            getbuf (q330, addr(pdp), sizeof(tdet_packet)) ;
395            pdp->detector_def = pd ;
396            pdp->det_num = loadbyte (p) ;
397            pdp->det_options = loadbyte (p) ;
398            pdp->parent = cur_lcq ;
399            cur_lcq->det = extend_link (cur_lcq->det, pdp) ;
400#endif
401          end
402        else
403          break ;
404      mask = mask shl 1 ;
405    end
406end
407
408static void read_dplcq (paqstruc paqs, pbyte *p)
409begin
410  plcq cur_lcq ;
411  tlocation loc ;
412  tseed_name name ;
413  boolean newone ;
414  pq330 q330 ;
415
416  q330 = paqs->owner ;
417  loadblock (p, 2, addr(loc)) ;
418  loadblock (p, 3, addr(name)) ;
419  cur_lcq = paqs->dplcqs ;
420  newone = FALSE ;
421  while (cur_lcq)
422    if ((memcmp(addr(cur_lcq->location), addr(loc), 2) == 0) land
423        (memcmp(addr(cur_lcq->seedname), addr(name), 3) == 0))
424      then
425        break ;
426      else
427        cur_lcq = cur_lcq->link ;
428  if (cur_lcq == NIL)
429    then
430      begin /* add new one */
431        newone = TRUE ;
432        getthrbuf (q330, addr(cur_lcq), sizeof(tlcq)) ;
433        if (paqs->dplcqs == NIL)
434          then
435            paqs->dplcqs = cur_lcq ;
436          else
437            paqs->dplcqs = extend_link (paqs->dplcqs, cur_lcq) ;
438      end
439  memcpy(addr(cur_lcq->location), addr(loc), 2) ;
440  memcpy(addr(cur_lcq->seedname), addr(name), 3) ;
441  set_loc_name (cur_lcq) ;
442  cur_lcq->lcq_num = loadbyte (p) ;
443  cur_lcq->lcq_num = 0xFF ; /* we don't actually use indexing for these lcqs */
444  cur_lcq->validated = TRUE ;
445  cur_lcq->raw_data_source = loadbyte (p) ;
446  cur_lcq->raw_data_field = loadbyte (p) ;
447  cur_lcq->lcq_opt = loadlongword (p) ;
448#ifndef OMIT_SEED
449  cur_lcq->firfixing_gain = 1.000 ; /* default if not over-ridden */
450  if (newone)
451    then
452      begin
453        getthrbuf (q330, addr(cur_lcq->com), sizeof(tcom_packet)) ;
454        cur_lcq->com->frame = 1 ;
455        cur_lcq->com->next_compressed_sample = 1 ;
456        cur_lcq->com->maxframes = 255 ;
457      end
458#endif
459  cur_lcq->caldly = 60 ;
460  cur_lcq->rate = loadint16 (p) ;
461  if (cur_lcq->lcq_opt and LO_GAP)
462    then
463      cur_lcq->gap_threshold = loadsingle (p) ;
464  if (cur_lcq->gap_threshold == 0.0)
465    then
466      cur_lcq->gap_threshold = 0.5 ;
467  set_gaps (cur_lcq) ;
468  if (cur_lcq->lcq_opt and LO_FRAME)
469    then
470#ifndef OMIT_SEED
471      cur_lcq->com->maxframes =
472#endif
473                        loadbyte (p) ;
474  init_dplcq (paqs, cur_lcq, newone) ;
475#ifndef OMIT_SEED
476  if (newone)
477    then
478      preload_archive (q330, FALSE, cur_lcq) ;
479#endif
480end
481
482#ifndef OMIT_SEED
483void read_control_detector (paqstruc paqs, pbyte *p)
484begin
485  pcontrol_detector cur_ctrl ;
486  pdop po ;
487  byte b ;
488  plcq pchan ;
489  pdet_packet pdp ;
490  boolean found ;
491  pq330 q330 ;
492  integer len ;
493
494  q330 = paqs->owner ;
495  getbuf (q330, addr(cur_ctrl), sizeof(tcontrol_detector)) ;
496  paqs->ctrlchain = extend_link (paqs->ctrlchain, cur_ctrl) ;
497  cur_ctrl->ctrl_num = loadbyte (p) ;
498  cur_ctrl->logmsg = (loadbyte (p) and 1) ;
499  len = loadbyte (p) ;
500  loadblock (p, len, addr(cur_ctrl->cdname)) ;
501  cur_ctrl->cdname[len] = 0 ;
502  repeat
503    b = loadbyte (p) ;
504    if (b == (DES_OP or DEO_DONE))
505      then
506        break ;
507    getbuf (q330, addr(po), sizeof(tdop)) ;
508    po->link = NIL ;
509    po->tok = b ;
510    po->point = NIL ;
511    switch (b and DES_OP) begin
512      case DES_DET :
513        pchan = paqs->lcqs ;
514        b = b and (not DES_OP) ;
515        found = FALSE ;
516        while ((lnot found) land (pchan))
517          begin
518            pdp = pchan->det ;
519            while (pdp)
520              if (pdp->det_num == b)
521                then
522                  break ;
523                else
524                  pdp = pdp->link ;
525            if (pdp)
526              then
527                begin
528                  found = TRUE ;
529                  po->point = pdp ;
530                end
531            pchan = pchan->link ;
532          end
533        break ;
534      case DES_CAL :
535        pchan = paqs->lcqs ;
536        b = b and (not DES_OP) ;
537        while (pchan)
538          if (pchan->lcq_num == b)
539            then
540              break ;
541            else
542              pchan = pchan->link ;
543        po->point = pchan ;
544        break ;
545    end
546    cur_ctrl->token_list = extend_link (cur_ctrl->token_list, po) ;
547  until FALSE) ;
548end
549
550void resolve_control_detectors (paqstruc paqs)
551begin
552  plcq cur_lcq ;
553  pcontrol_detector pc ;
554
555  cur_lcq = paqs->lcqs ;
556  while (cur_lcq)
557    begin
558      if (cur_lcq->ctrl)
559        then
560          begin
561            pc = paqs->ctrlchain ;
562            while (pc)
563              if (pc->ctrl_num == ((pntrint)cur_lcq->ctrl and 0xFF))
564                then
565                  break ;
566                else
567                  pc = pc->link ;
568            cur_lcq->ctrl = pc ;
569          end
570      cur_lcq = cur_lcq->link ;
571    end
572end
573#endif
574
575static void read_comm_events (paqstruc paqs, pbyte *p, pbyte stop)
576begin
577  string s ;
578  byte b ;
579  integer lth ;
580
581  while ((pntrint)*p < (pntrint)stop)
582    begin
583      b = loadbyte(p) ; /* comm event number */
584      lth = loadbyte(p) ;
585      loadblock (p, lth, addr(s)) ;
586      s[lth] = 0 ; /* null terminate */
587      if (b <= 31)
588        then
589          strncpy(addr(paqs->commevents[b].name), addr(s), COMMLENGTH) ;
590    end
591end
592
593static void read_dss (paqstruc paqs, pbyte *p)
594begin
595  tdss *pdss ;
596
597  pdss = addr(paqs->dss_def) ;
598  loadstring (p, 8, addr(pdss->high_pass)) ;
599  loadstring (p, 8, addr(pdss->mid_pass)) ;
600  loadstring (p, 8, addr(pdss->low_pass)) ;
601  pdss->timeout = loadlongint (p) ;
602  pdss->max_bps = loadlongint (p) ;
603  pdss->verbosity = loadbyte (p) ;
604  pdss->max_cpu_perc = loadbyte (p) ;
605  pdss->port_number = loadword (p) ;
606  pdss->max_mem = loadword (p) ;
607  pdss->reserved = loadword (p) ;
608end
609
610static void read_clock (paqstruc paqs, pbyte *p)
611begin
612  tclock *pclk ;
613  pq330 q330 ;
614
615  q330 = paqs->owner ;
616  pclk = addr(q330->qclock) ;
617  pclk->zone = loadlongint (p) ;
618  pclk->degrade_time = loadword (p) ;
619  pclk->q_locked = loadbyte (p) ;
620  pclk->q_track = loadbyte (p) ;
621  pclk->q_hold = loadbyte (p) ;
622  pclk->q_off = loadbyte (p) ;
623  pclk->q_spare = loadbyte (p) ;
624  pclk->q_high = loadbyte (p) ;
625  pclk->q_low = loadbyte (p) ;
626  pclk->q_never = loadbyte (p) ;
627  pclk->clock_filt = loadword (p) ;
628end
629
630static void read_log_tim (paqstruc paqs, pbyte *p)
631begin
632  tlog_tim *plt ;
633
634  plt = addr(paqs->log_tim) ;
635  loadblock (p, 2, addr(plt->log_location)) ;
636  loadblock (p, 3, addr(plt->log_seedname)) ;
637  loadblock (p, 2, addr(plt->tim_location)) ;
638  loadblock (p, 3, addr(plt->tim_seedname)) ;
639end
640
641static void read_cfgid (paqstruc paqs, pbyte *p)
642begin
643  tlog_cfg *plc ;
644
645  plc = addr(paqs->log_cfg) ;
646  loadblock (p, 2, addr(plc->cfg_location)) ;
647  loadblock (p, 3, addr(plc->cfg_seedname)) ;
648  plc->flags = loadbyte (p) ;
649  plc->interval = loadword (p) ;
650end
651
652#ifndef OMIT_SEED
653void add_msg_tim_lcqs (paqstruc paqs)
654begin
655  plcq cur_lcq ;
656  pq330 q330 ;
657  boolean newone ;
658
659  q330 = paqs->owner ;
660  cur_lcq = paqs->dplcqs ;
661  newone = FALSE ;
662  while (cur_lcq)
663    if ((memcmp(addr(cur_lcq->location), addr(paqs->log_tim.log_location), 2) == 0) land
664       (memcmp(addr(cur_lcq->seedname), addr(paqs->log_tim.log_seedname), 3) == 0))
665      then
666        break ;
667      else
668        cur_lcq = cur_lcq->link ;
669  if (cur_lcq == NIL)
670    then
671      begin /* add new one */
672        newone = TRUE ;
673        getthrbuf (q330, addr(cur_lcq), sizeof(tlcq)) ;
674        if (paqs->dplcqs == NIL)
675          then
676            paqs->dplcqs = cur_lcq ;
677          else
678            paqs->dplcqs = extend_link (paqs->dplcqs, cur_lcq) ;
679      end
680  paqs->msg_lcq = cur_lcq ;
681  memcpy(addr(cur_lcq->location), addr(paqs->log_tim.log_location), 2) ;
682  memcpy(addr(cur_lcq->seedname), addr(paqs->log_tim.log_seedname), 3) ;
683  set_loc_name (cur_lcq) ;
684  cur_lcq->raw_data_source = MESSAGE_STREAM ;
685  cur_lcq->lcq_num = 0xFF ; /* not used */
686  cur_lcq->validated = TRUE ;
687#ifndef OMIT_SEED
688  if (newone)
689    then
690      begin
691        getthrbuf (q330, addr(cur_lcq->com), sizeof(tcom_packet)) ;
692        cur_lcq->com->frame = 1 ;
693        cur_lcq->com->next_compressed_sample = 1 ;
694        cur_lcq->com->maxframes = 255 ;
695      end
696#endif
697  init_dplcq (paqs, cur_lcq, newone) ;
698#ifndef OMIT_SEED
699  if (newone)
700    then
701      preload_archive (q330, FALSE, cur_lcq) ;
702#endif
703  getbuf (q330, addr(cur_lcq), sizeof(tlcq)) ;
704  getbuf (q330, addr(cur_lcq->com), sizeof(tcom_packet)) ;
705  paqs->lcqs = extend_link (paqs->lcqs, cur_lcq) ;
706  paqs->tim_lcq = cur_lcq ;
707  memcpy(addr(cur_lcq->location), addr(paqs->log_tim.tim_location), 2) ;
708  memcpy(addr(cur_lcq->seedname), addr(paqs->log_tim.tim_seedname), 3) ;
709  set_loc_name (cur_lcq) ;
710  cur_lcq->raw_data_source = TIMING_STREAM ;
711  inc(paqs->highest_lcqnum) ;
712  cur_lcq->lcq_num = paqs->highest_lcqnum ;
713  if (q330->par_create.call_minidata)
714    then
715      cur_lcq->mini_filter = q330->par_create.opt_minifilter and (OMF_ALL or OMF_TIM) ;
716  if ((paqs->arc_size > 0) land (q330->par_create.call_aminidata))
717    then
718      cur_lcq->arc.amini_filter = q330->par_create.opt_aminifilter and (OMF_ALL or OMF_TIM) ;
719  getbuf (q330, addr(cur_lcq), sizeof(tlcq)) ;
720  getbuf (q330, addr(cur_lcq->com), sizeof(tcom_packet)) ;
721  paqs->lcqs = extend_link (paqs->lcqs, cur_lcq) ;
722  paqs->cfg_lcq = cur_lcq ;
723  memcpy(addr(cur_lcq->location), addr(paqs->log_cfg.cfg_location), 2) ;
724  memcpy(addr(cur_lcq->seedname), addr(paqs->log_cfg.cfg_seedname), 3) ;
725  set_loc_name (cur_lcq) ;
726  cur_lcq->raw_data_source = CFG_STREAM ;
727  inc(paqs->highest_lcqnum) ;
728  cur_lcq->lcq_num = paqs->highest_lcqnum ;
729  if (q330->par_create.call_minidata)
730    then
731      cur_lcq->mini_filter = q330->par_create.opt_minifilter and (OMF_ALL or OMF_CFG) ;
732  if ((paqs->arc_size > 0) land (q330->par_create.call_aminidata))
733    then
734      cur_lcq->arc.amini_filter = q330->par_create.opt_aminifilter and (OMF_ALL or OMF_CFG) ;
735end
736#endif
737
738pointer tonext (pointer base, integer offset)
739begin
740
741  return (pointer)((pntrint)base + offset) ;
742end
743
744void decode_cfg (pq330 q330)
745begin
746  byte tok ;
747  word next ;
748  integer i, lth ;
749  string s ;
750  string s1 ;
751  pbyte p, pend, pref ;
752  paqstruc paqs ;
753  plcq q ;
754  enum tacctype acctype ;
755  taccmstat *paccm ;
756
757  paqs = q330->aqstruc ;
758  for (i = 0 ; i <= CE_MAX - 1 ; i++)
759    sprintf(addr(paqs->commevents[i].name), "COMM:%d", i + 1) ;
760  q = paqs->dplcqs ;
761  while (q)
762    begin
763      q->validated = FALSE ;
764      q = q->link ;
765    end
766  p = (pointer)q330->cfgbuf ;
767  pend = p ;
768  incn(pend, q330->cfgsize) ;
769  while ((pntrint)p < (pntrint)pend)
770    begin
771      tok = loadbyte (addr(p)) ;
772      switch (tok) begin
773        case TF_NOP :
774          break ;
775        case TF_VERSION :
776          tok = loadbyte (addr(p)) ; /* token version number */
777          if (tok != T_VER)
778            then
779              begin
780                libmsgadd (q330, LIBMSG_INVTVER, "") ;
781                p = pend ; /* force leaving the loop */
782                break ;
783              end
784          break ;
785        case TF_NET_STAT :
786          loadblock (addr(p), 2, addr(q330->network)) ;
787          loadblock (addr(p), 5, addr(q330->station)) ;
788          break ;
789        case TF_NETSERV :
790          paqs->netport = loadword (addr(p)) ;
791          break ;
792        case TF_DSS :
793          read_dss (paqs, addr(p)) ;
794          break ;
795        case TF_WEB :
796          paqs->webport = loadword (addr(p)) ;
797          break ;
798        case TF_DATASERV :
799          paqs->dservport = loadword (addr(p)) ;
800          break ;
801        case TF_CLOCK :
802          read_clock (paqs, addr(p)) ;
803          break ;
804        case TF_MT :
805          read_log_tim (paqs, addr(p)) ;
806          break ;
807        case TF_CFG :
808          read_cfgid (paqs, addr(p)) ;
809          break ;
810        case T1_MHD :
811        case T1_THRD :
812          pref = p ;
813          next = loadbyte (addr(p)) ; /* total size */
814#ifndef OMIT_SEED
815          read_detector (paqs, addr(p), (tok == T1_MHD)) ;
816#endif
817          p = tonext(pref, next) ;
818          break ;
819        case T1_IIR :
820          pref = p ;
821          next = loadbyte (addr(p)) ; /* total size */
822#ifndef OMIT_SEED
823          read_iir (paqs, addr(p)) ;
824#endif
825          p = tonext(pref, next) ;
826          break ;
827        case T1_FIR :
828          pref = p ;
829          next = loadbyte (addr(p)) ; /* total size */
830#ifndef OMIT_SEED
831          read_fir (paqs, addr(p)) ;
832#endif
833          p = tonext(pref, next) ;
834          break ;
835        case T1_LCQ :
836          pref = p ;
837          next = loadbyte (addr(p)) ; /* total size */
838          read_lcq (paqs, addr(p)) ;
839          p = tonext(pref, next) ;
840          break ;
841        case T1_DPLCQ :
842          pref = p ;
843          next = loadbyte (addr(p)) ; /* total size */
844          read_dplcq (paqs, addr(p)) ;
845          p = tonext(pref, next) ;
846          break ;
847        case T1_CTRL :
848          pref = p ;
849          next = loadbyte (addr(p)) ;
850#ifndef OMIT_SEED
851          read_control_detector (paqs, addr(p)) ;
852#endif
853          p = tonext(pref, next) ;
854          break ;
855        case T1_NONCOMP :
856          pref = p ;
857          paqs->non_comp = TRUE ;
858          next = loadbyte (addr(p)) ;
859          p = tonext(pref, next) ;
860          break ;
861        case T2_CNAMES :
862          pref = p ;
863          next = loadword (addr(p)) ;
864          read_comm_events (paqs, addr(p), (pointer)((pntrint)pref + next)) ;
865          p = tonext(pref, next) ;
866          break ;
867        case T2_OPAQUE :
868          pref = p ;
869          next = loadword (addr(p)) ; /* get length */
870#ifndef OMIT_SEED
871          paqs->opaque_size = next - 2 ; /* don't count length word */
872          getbuf (q330, addr(paqs->opaque_buf), paqs->opaque_size) ;
873          loadblock (addr(p), paqs->opaque_size, paqs->opaque_buf) ;
874#endif
875          p = tonext(pref, next) ;
876          break ;
877        default :
878          if (tok >= 0x80)
879            then /* variable length */
880              if (tok >= 0xC0)
881                then
882                  begin /* two byte length */
883                    pref = p ;
884                    next = loadword (addr(p)) ;
885                    p = tonext(pref, next) ;
886                  end
887                else
888                  begin /* one byte length */
889                    pref = p ;
890                    next = loadbyte (addr(p)) ;
891                    p = tonext(pref, next) ;
892                  end
893          break ;
894      end
895    end
896#ifndef OMIT_SEED
897  add_msg_tim_lcqs (paqs) ;
898  resolve_control_detectors (paqs) ; /* lcqs didn't have anything to point to yet */
899#endif
900  q = paqs->dplcqs ;
901  while (q)
902    begin
903      if ((lnot q->validated) land (q->raw_data_source != MESSAGE_STREAM))
904        then
905          begin
906            for (acctype = AC_FIRST ; acctype <= AC_LAST ; acctype++)
907              begin
908                paccm = addr(q330->share.accmstats[acctype]) ;
909                if (paccm->ds_lcq == q)
910                  then
911                    paccm->ds_lcq = NIL ;
912              end
913            if (paqs->data_latency_lcq == q)
914              then
915                paqs->data_latency_lcq = NIL ;
916            else if (paqs->status_latency_lcq == q)
917              then
918                paqs->status_latency_lcq = NIL ;
919          end
920      q = q->link ;
921    end
922  lth = 0 ;
923  for (i = 0 ; i <= 4 ; i++)
924    if (q330->station[i] != ' ')
925      then
926        s[lth++] = q330->station[i] ;
927  s[lth] = 0 ; /* build string representation of station (3-5 characters) */
928  s1[0] = q330->network[0] ;
929  s1[1] = q330->network[1] ;
930  s1[2] = 0 ; /* build string representation of network (always 2 characters) */
931  sprintf (addr(q330->station_ident), "%s-%s", s1, s) ; /* network-station */
932  init_lcq (paqs) ;
933#ifndef OMIT_SEED
934  expand_control_detectors (paqs) ;
935#endif
936  check_continuity (q330) ;
937  if (paqs->data_timetag > 1.0) /* if non-zero continuity was restored, write cfg blks at start of session */
938    then
939      begin
940        libdatamsg (q330, LIBMSG_RESTCONT, "") ;
941        paqs->contingood = restore_continuity (q330) ;
942        if (lnot paqs->contingood)
943          then
944            libdatamsg (q330, LIBMSG_CONTNR, "") ;
945      end
946  paqs->last_data_qual = NO_LAST_DATA_QUAL ;
947  paqs->first_data = TRUE ;
948  q330->data_timer = 0 ;
949  q330->status_timer = 0 ;
950  if (lnot paqs->non_comp)
951    then
952      verify_mapping (q330) ;
953#ifndef OMIT_SEED
954  if (paqs->arc_size > 0)
955    then
956      preload_archive (q330, TRUE, NIL) ;
957  if ((paqs->data_timetag > 1) land (paqs->log_cfg.flags and LC_START))
958    then
959      start_cfgblks (paqs) ;
960#endif
961  new_state (q330, LIBSTATE_RUNWAIT) ;
962end
963
964void read_q330_cfg (pq330 q330, pbyte pb)
965begin
966  word w ;
967  tseghdr seghdr ;
968  pbyte p ;
969  tmem *pmem ;
970  string31 s ;
971
972  p = pb ; /* p now has location in received buffer */
973  pmem = addr(q330->mem_hdr) ;
974  loadseghdr (addr(p), addr(seghdr)) ;
975  w = pmem->count - 4 ; /* remove segment numbers */
976  q330->cfgnow = (seghdr.segnum - 1) * MAXSEG ;
977  memcpy (addr((*(q330->cfgbuf))[q330->cfgnow]), p, w) ;
978  q330->cfgsize = q330->cfgnow + w ;
979  if (seghdr.segnum == seghdr.segtotal)
980    then
981      begin
982        sprintf(s, "%d bytes", q330->cfgsize) ;
983        libmsgadd (q330, LIBMSG_TOKREAD, addr(s)) ;
984        new_state (q330, LIBSTATE_DECTOK) ;
985      end
986    else
987      begin
988        q330->cfgoffset = q330->cfgoffset + w + OVERHEAD ;
989        pmem = addr(q330->mem_req) ;
990        pmem->start = q330->cfgoffset ;
991        pmem->count = 0 ;
992        pmem->memtype = MT_CFG1 + q330->par_create.q330id_dataport ;
993        new_cmd (q330, C1_RQMEM, MAXSEG) ;
994      end
995end
996
997void cfg_start (pq330 q330)
998begin
999  tmem *pmem ;
1000
1001  pmem = addr(q330->mem_req) ;
1002  new_state (q330, LIBSTATE_READTOK) ;
1003  libmsgadd (q330, LIBMSG_READTOK, "") ;
1004  q330->data_timer = 0 ;
1005  pmem->start = 0 ;
1006  pmem->count = 0 ;
1007  pmem->memtype = MT_CFG1 + q330->par_create.q330id_dataport ;
1008  new_cmd (q330, C1_RQMEM, MAXSEG) ;
1009  q330->cfgsize = 0 ;
1010  q330->cfgnow = 0 ;
1011  q330->cfgoffset = 0 ;
1012end
Note: See TracBrowser for help on using the repository browser.