source: git/Singular/newstruct.cc @ 5edb77

spielwiese
Last change on this file since 5edb77 was 5edb77, checked in by Hans Schoenemann <hannes@…>, 11 years ago
fix: iiMake_proc (gcc 4.7)
  • Property mode set to 100644
File size: 18.6 KB
Line 
1#include <ctype.h>
2
3#include "config.h"
4#include <kernel/mod2.h>
5#include <Singular/ipid.h>
6#include <Singular/blackbox.h>
7#include <Singular/lists.h>
8#include <Singular/ipid.h>
9#include <Singular/ipshell.h>
10#include <Singular/newstruct.h>
11
12struct newstruct_member_s;
13typedef struct newstruct_member_s *newstruct_member;
14struct  newstruct_member_s
15{
16  newstruct_member next;
17  char *         name;
18  int            typ;
19  int            pos;
20};
21
22struct newstruct_proc_s;
23typedef struct newstruct_proc_a *newstruct_proc;
24struct  newstruct_proc_a
25{
26  newstruct_proc next;
27  int            t; /*tok id */
28  int            args; /* number of args */
29  procinfov      p;
30};
31
32struct newstruct_desc_s
33{
34  newstruct_member member;
35  newstruct_desc   parent;
36  newstruct_proc   procs;
37  int            size; // number of mebers +1
38  int            id;   // the type id assigned to this bb
39};
40
41int newstruct_desc_size()
42{
43  return sizeof(newstruct_desc_s);
44}
45
46char * newstruct_String(blackbox *b, void *d)
47{
48  if (d==NULL) return omStrDup("oo");
49  else
50  {
51    newstruct_desc ad=(newstruct_desc)(b->data);
52
53    newstruct_proc p=ad->procs;
54    while((p!=NULL)&&(p->t!=STRING_CMD))
55      p=p->next;
56
57    if (p!=NULL)
58    {
59      BOOLEAN sl;
60      sleftv tmp;
61      memset(&tmp,0,sizeof(tmp));
62      tmp.rtyp=ad->id;
63      void * newstruct_Copy(blackbox*, void *); //forward declaration
64      tmp.data=(void*)newstruct_Copy(b,d);
65      idrec hh;
66      memset(&hh,0,sizeof(hh));
67      hh.id=Tok2Cmdname(p->t);
68      hh.typ=PROC_CMD;
69      hh.data.pinf=p->p;
70      sl=iiMake_proc(&hh,NULL,&tmp);
71
72      if (sl&& (iiRETURNEXPR.Typ() == STRING_CMD))
73      {
74        char *res = omStrDup((char*)iiRETURNEXPR.Data());
75        iiRETURNEXPR.CleanUp();
76        iiRETURNEXPR.Init();
77        return res;
78      }
79      iiRETURNEXPR.CleanUp();
80      iiRETURNEXPR.Init();
81    }
82
83    lists l=(lists)d;
84    newstruct_member a=ad->member;
85    StringSetS("");
86    loop
87    {
88      StringAppendS(a->name);
89      char *tmp=omStrDup(StringAppendS("="));
90      if ((!RingDependend(a->typ))
91      || ((l->m[a->pos-1].data==(void *)currRing)
92         && (currRing!=NULL)))
93      {
94        if (l->m[a->pos].rtyp==LIST_CMD)
95        {
96          StringAppendS("<list>");
97        }
98        else
99        {
100          StringSetS("");
101          char *tmp2=omStrDup(l->m[a->pos].String());
102          StringSetS(tmp);
103          if ((strlen(tmp2)>80)||(strchr(tmp2,'\n')!=NULL))
104          {
105            StringAppend("<%s>",Tok2Cmdname(l->m[a->pos].rtyp));
106          }
107          else StringAppendS(tmp2);
108          omFree(tmp2);
109        }
110      }
111      else StringAppendS("??");
112      omFree(tmp);
113      if (a->next==NULL) break;
114      StringAppendS("\n");
115      if(errorreported) break;
116      a=a->next;
117    }
118    return omStrDup(StringAppendS(""));
119  }
120}
121lists lCopy_newstruct(lists L)
122{
123  lists N=(lists)omAlloc0Bin(slists_bin);
124  int n=L->nr;
125  ring save_ring=currRing;
126  N->Init(n+1);
127  for(;n>=0;n--)
128  {
129    if (RingDependend(L->m[n].rtyp))
130    {
131      assume((L->m[n-1].rtyp==RING_CMD) || (L->m[n-1].data==NULL));
132      if(L->m[n-1].data!=NULL)
133      {
134        if (L->m[n-1].data!=(void*)currRing)
135          rChangeCurrRing((ring)(L->m[n-1].data));
136        N->m[n].Copy(&L->m[n]);
137      }
138      else
139      {
140        N->m[n].rtyp=L->m[n].rtyp;
141        N->m[n].data=idrecDataInit(L->m[n].rtyp);
142      }
143    }
144    else if(L->m[n].rtyp==LIST_CMD)
145    {
146      N->m[n].rtyp=L->m[n].rtyp;
147      N->m[n].data=(void *)lCopy((lists)(L->m[n].data));
148    }
149    else if(L->m[n].rtyp>MAX_TOK)
150    {
151      N->m[n].rtyp=L->m[n].rtyp;
152      blackbox *b=getBlackboxStuff(N->m[n].rtyp);
153      N->m[n].data=(void *)b->blackbox_Copy(b,L->m[n].data);
154    }
155    else
156      N->m[n].Copy(&L->m[n]);
157  }
158  if (currRing!=save_ring) rChangeCurrRing(save_ring);
159  return N;
160}
161void * newstruct_Copy(blackbox*, void *d)
162{
163  lists n1=(lists)d;
164  return (void*)lCopy_newstruct(n1);
165}
166
167// Used by newstruct_Assign for overloaded '='
168BOOLEAN newstruct_equal(int op, leftv l, leftv r)
169{
170  blackbox *ll=getBlackboxStuff(op);
171  assume(ll->data != NULL);
172  newstruct_desc nt=(newstruct_desc)ll->data;
173  newstruct_proc p=nt->procs;
174
175  while( (p!=NULL) && ((p->t!='=')||(p->args!=1)) ) p=p->next;
176
177  if (p!=NULL)
178  {
179    BOOLEAN sl;
180    idrec hh;
181    memset(&hh,0,sizeof(hh));
182    hh.id=Tok2Cmdname(p->t);
183    hh.typ=PROC_CMD;
184    hh.data.pinf=p->p;
185    sleftv tmp;
186    memset(&tmp,0,sizeof(sleftv));
187    tmp.Copy(r);
188    sl = iiMake_proc(&hh, NULL, &tmp);
189    if (!sl)
190    {
191      if (iiRETURNEXPR.Typ() == op)
192      {
193        l->Copy(&iiRETURNEXPR);
194        iiRETURNEXPR.Init();
195        return FALSE;
196      }
197      iiRETURNEXPR.CleanUp();
198      iiRETURNEXPR.Init();
199    }
200  }
201  return TRUE;
202}
203
204BOOLEAN newstruct_Assign(leftv l, leftv r)
205{
206  if (r->Typ()>MAX_TOK)
207  {
208    blackbox *rr=getBlackboxStuff(r->Typ());
209    if (l->Typ()!=r->Typ())
210    {
211      newstruct_desc rrn=(newstruct_desc)rr->data;
212
213      if (!rrn)
214      {
215        Werror("custom type %s(%d) cannot be assigned to newstruct %s(%d)",
216               Tok2Cmdname(r->Typ()), r->Typ(), Tok2Cmdname(l->Typ()), l->Typ());
217        return TRUE;
218      }
219
220      newstruct_desc rrp=rrn->parent;
221      while ((rrp!=NULL)&&(rrp->id!=l->Typ())) rrp=rrp->parent;
222      if (rrp!=NULL)
223      {
224        if (l->rtyp==IDHDL)
225        {
226          IDTYP((idhdl)l->data)=r->Typ();
227        }
228        else
229        {
230          l->rtyp=r->Typ();
231        }
232      }
233      else                      // unrelated types - look for custom conversion
234      {
235        sleftv tmp;
236        BOOLEAN newstruct_Op1(int, leftv, leftv);  // forward declaration
237        if (! newstruct_Op1(l->Typ(), &tmp, r))  return newstruct_Assign(l, &tmp);
238      }
239    }
240    if (l->Typ()==r->Typ())
241    {
242      if (l->Data()!=NULL)
243      {
244        lists n1=(lists)l->Data();
245        n1->Clean(); n1=NULL;
246      }
247      lists n2=(lists)r->Data();
248      n2=lCopy_newstruct(n2);
249      if (l->rtyp==IDHDL)
250      {
251        IDDATA((idhdl)l->data)=(char *)n2;
252      }
253      else
254      {
255        l->data=(void *)n2;
256      }
257      return FALSE;
258    }
259  }
260
261  else
262  {
263    assume(l->Typ() > MAX_TOK);
264    sleftv tmp;
265    if(!newstruct_equal(l->Typ(), &tmp, r)) return newstruct_Assign(l, &tmp);
266  }
267  Werror("assign %s(%d) = %s(%d)",
268        Tok2Cmdname(l->Typ()),l->Typ(),Tok2Cmdname(r->Typ()),r->Typ());
269  return TRUE;
270}
271
272BOOLEAN newstruct_Op1(int op, leftv res, leftv arg)
273{
274  // interpreter: arg is newstruct
275  blackbox *a=getBlackboxStuff(arg->Typ());
276  newstruct_desc nt=(newstruct_desc)a->data;
277  newstruct_proc p=nt->procs;
278
279  while((p!=NULL) &&( (p->t!=op) || (p->args!=1) )) p=p->next;
280
281  if (p!=NULL)
282  {
283    BOOLEAN sl;
284    sleftv tmp;
285    memset(&tmp,0,sizeof(sleftv));
286    tmp.Copy(arg);
287    idrec hh;
288    memset(&hh,0,sizeof(hh));
289    hh.id=Tok2Cmdname(p->t);
290    hh.typ=PROC_CMD;
291    hh.data.pinf=p->p;
292    sl=iiMake_proc(&hh,NULL,&tmp);
293    if (sl) return TRUE;
294    else
295    {
296      res->Copy(&iiRETURNEXPR);
297      iiRETURNEXPR.Init();
298      return FALSE;
299    }
300  }
301  return blackboxDefaultOp1(op,res,arg);
302}
303
304
305
306BOOLEAN newstruct_Op2(int op, leftv res, leftv a1, leftv a2)
307{
308  // interpreter: a1 or a2 is newstruct
309  blackbox *a=getBlackboxStuff(a1->Typ());
310  newstruct_desc nt;
311  lists al=(lists)a1->Data();
312  if (a!=NULL)
313  {
314    nt=(newstruct_desc)a->data;
315    switch(op)
316    {
317      case '.':
318      {
319        if (a2->name!=NULL)
320        {
321          BOOLEAN search_ring=FALSE;
322          newstruct_member nm=nt->member;
323          while ((nm!=NULL)&&(strcmp(nm->name,a2->name)!=0)) nm=nm->next;
324          if ((nm==NULL) && (strncmp(a2->name,"r_",2)==0))
325          {
326            nm=nt->member;
327            while ((nm!=NULL)&&(strcmp(nm->name,a2->name+2)!=0)) nm=nm->next;
328            if ((nm!=NULL)&&(RingDependend(nm->typ)))
329              search_ring=TRUE;
330            else
331              nm=NULL;
332          }
333          if (nm==NULL)
334          {
335            Werror("member %s nor found", a2->name);
336            return TRUE;
337          }
338          if (search_ring)
339          {
340            ring r;
341            res->rtyp=RING_CMD;
342            res->data=al->m[nm->pos-1].data;
343            r=(ring)res->data;
344            if (r==NULL) { res->data=(void *)currRing; r=currRing; }
345            if (r!=NULL) r->ref++;
346            else Werror("ring of this member is not set and no basering found");
347            return r==NULL;
348          }
349          else if (RingDependend(nm->typ))
350          {
351            if (al->m[nm->pos].data==NULL)
352            {
353              // NULL belongs to any ring
354              ring r=(ring)al->m[nm->pos-1].data;
355              if (r!=NULL)
356              {
357                r->ref--;
358                al->m[nm->pos-1].data=NULL;
359                al->m[nm->pos-1].rtyp=DEF_CMD;
360              }
361            }
362            else
363            {
364              //Print("checking ring at pos %d for dat at pos %d\n",nm->pos-1,nm->pos);
365              if ((al->m[nm->pos-1].data!=(void *)currRing)
366              &&(al->m[nm->pos-1].data!=(void*)0L))
367              {
368                Werror("different ring %lx(data) - %lx(basering)",
369                  (long unsigned)(al->m[nm->pos-1].data),(long unsigned)currRing);
370                return TRUE;
371              }
372            }
373            if ((currRing!=NULL)&&(al->m[nm->pos-1].data==NULL))
374            {
375              // remember the ring, if not already set
376              al->m[nm->pos-1].data=(void *)currRing;
377              al->m[nm->pos-1].rtyp=RING_CMD;
378              currRing->ref++;
379            }
380          }
381          Subexpr r=(Subexpr)omAlloc0Bin(sSubexpr_bin);
382          r->start = nm->pos+1;
383          memcpy(res,a1,sizeof(sleftv));
384          memset(a1,0,sizeof(sleftv));
385          if (res->e==NULL) res->e=r;
386          else
387          {
388            Subexpr sh=res->e;
389            while (sh->next != NULL) sh=sh->next;
390            sh->next=r;
391          }
392          return FALSE;
393        }
394        else
395        {
396          WerrorS("name expected");
397          return TRUE;
398        }
399      }
400    }
401  }
402  else
403  {
404    a=getBlackboxStuff(a2->Typ());
405    nt=(newstruct_desc)a->data;
406    al=(lists)a2->Data();
407  }
408  newstruct_proc p=nt->procs;
409  while((p!=NULL) && ( (p->t!=op) || (p->args!=2) )) p=p->next;
410  if (p!=NULL)
411  {
412    BOOLEAN sl;
413    sleftv tmp;
414    memset(&tmp,0,sizeof(sleftv));
415    tmp.Copy(a1);
416    tmp.next=(leftv)omAlloc0(sizeof(sleftv));
417    tmp.next->Copy(a2);
418    idrec hh;
419    memset(&hh,0,sizeof(hh));
420    hh.id=Tok2Cmdname(p->t);
421    hh.typ=PROC_CMD;
422    hh.data.pinf=p->p;
423    sl=iiMake_proc(&hh,NULL,&tmp);
424    if (sl) return TRUE;
425    else
426    {
427      res->Copy(&iiRETURNEXPR);
428      iiRETURNEXPR.Init();
429      return FALSE;
430    }
431  }
432  return blackboxDefaultOp2(op,res,a1,a2);
433}
434
435// BOOLEAN opM(int op, leftv res, leftv args)
436BOOLEAN newstruct_OpM(int op, leftv res, leftv args)
437{
438  // interpreter: args->1. arg is newstruct
439  blackbox *a=getBlackboxStuff(args->Typ());
440  newstruct_desc nt=(newstruct_desc)a->data;
441  switch(op)
442  {
443    case STRING_CMD:
444    {
445      res->data=(void *)a->blackbox_String(a,args->Data());
446      res->rtyp=STRING_CMD;
447      return FALSE;
448    }
449    default:
450      break;
451  }
452  newstruct_proc p=nt->procs;
453
454  while((p!=NULL) &&( (p->t!=op) || (p->args!=4) )) p=p->next;
455
456  if (p!=NULL)
457  {
458    BOOLEAN sl;
459    sleftv tmp;
460    memset(&tmp,0,sizeof(sleftv));
461    tmp.Copy(args);
462    idrec hh;
463    memset(&hh,0,sizeof(hh));
464    hh.id=Tok2Cmdname(p->t);
465    hh.typ=PROC_CMD;
466    hh.data.pinf=p->p;
467    sl=iiMake_proc(&hh,NULL,&tmp);
468    if (sl) return TRUE;
469    else
470    {
471      res->Copy(&iiRETURNEXPR);
472      iiRETURNEXPR.Init();
473      return FALSE;
474    }
475  }
476  return blackbox_default_OpM(op,res,args);
477}
478
479void lClean_newstruct(lists l)
480{
481  if (l->nr>=0)
482  {
483    int i;
484    ring r=NULL;
485    for(i=l->nr;i>=0;i--)
486    {
487      if ((i>0) && (l->m[i-1].rtyp==RING_CMD))
488        r=(ring)(l->m[i-1].data);
489      else
490        r=NULL;
491      l->m[i].CleanUp(r);
492    }
493    omFreeSize((ADDRESS)l->m, (l->nr+1)*sizeof(sleftv));
494    l->nr=-1;
495  }
496  omFreeBin((ADDRESS)l,slists_bin);
497}
498
499void newstruct_destroy(blackbox *b, void *d)
500{
501  if (d!=NULL)
502  {
503    lists n=(lists)d;
504    lClean_newstruct(n);
505  }
506}
507
508void *newstruct_Init(blackbox *b)
509{
510  newstruct_desc n=(newstruct_desc)b->data;
511  lists l=(lists)omAlloc0Bin(slists_bin);
512  l->Init(n->size);
513  newstruct_member nm=n->member;
514  while (nm!=NULL)
515  {
516    l->m[nm->pos].rtyp=nm->typ;
517    l->m[nm->pos].data=idrecDataInit(nm->typ);
518    nm=nm->next;
519  }
520  return l;
521}
522
523BOOLEAN newstruct_CheckAssign(blackbox *b, leftv L, leftv R)
524{
525  int lt=L->Typ();
526  int rt=R->Typ();
527  if ((lt!=DEF_CMD)&&(lt!=rt))
528  {
529    Werror("can not assign %s(%d) to member of type %s(%d)",
530            Tok2Cmdname(rt),rt,
531            Tok2Cmdname(lt),lt);
532    return TRUE;
533  }
534  return FALSE;
535}
536
537/* check internal structure:
538* BOOLEAN newstruct_Check(blackbox *b, void *d)
539{
540  newstruct_desc n=(newstruct_desc)b->data;
541  lists l=(lists)d;
542  newstruct_member nm=n->member;
543  while (nm!=NULL)
544  {
545    if ((l->m[nm->pos].rtyp!=nm->typ)
546    &&( nm->typ!=DEF_CMD))
547    {
548      Werror("type change in member %s (%s(%d) -> %s(%d))",nm->name,
549          Tok2Cmdname(nm->typ),nm->typ,
550          Tok2Cmdname(l->m[nm->pos].rtyp),l->m[nm->pos].rtyp);
551      return TRUE;
552    }
553    nm=nm->next;
554  }
555  return FALSE;
556}
557*/
558
559BOOLEAN newstruct_serialize(blackbox *b, void *d, si_link f)
560{
561  newstruct_desc dd=(newstruct_desc)b->data;
562  sleftv l;
563  memset(&l,0,sizeof(l));
564  l.rtyp=STRING_CMD;
565  l.data=(void*)getBlackboxName(dd->id);
566  f->m->Write(f, &l);
567  lists ll=(lists)d;
568  memset(&l,0,sizeof(l));
569  l.rtyp=LIST_CMD;
570  l.data=ll;
571  f->m->Write(f, &l);
572  return FALSE;
573}
574
575BOOLEAN newstruct_deserialize(blackbox **b, void **d, si_link f)
576{
577  // newstruct is serialiazed as a list,
578  // just read a list and take data,
579  // rtyp must be set correctly (to the blackbox id) by routine calling
580  // newstruct_deserialize
581  leftv l=f->m->Read(f);
582  //newstruct_desc n=(newstruct_desc)b->data;
583  //TODO: check compatibility of list l->data with description in n
584  *d=l->data;
585  return FALSE;
586}
587
588void newstruct_Print(blackbox *b,void *d)
589{
590  newstruct_desc dd=(newstruct_desc)b->data;
591  newstruct_proc p=dd->procs;
592  while((p!=NULL)&&(p->t!=PRINT_CMD))
593    p=p->next;
594  if (p!=NULL)
595  {
596    BOOLEAN sl;
597    sleftv tmp;
598    memset(&tmp,0,sizeof(tmp));
599    tmp.rtyp=dd->id;
600    tmp.data=(void*)newstruct_Copy(b,d);
601    idrec hh;
602    memset(&hh,0,sizeof(hh));
603    hh.id=Tok2Cmdname(p->t);
604    hh.typ=PROC_CMD;
605    hh.data.pinf=p->p;
606    sl=iiMake_proc(&hh,NULL,&tmp);
607    if (!sl) iiRETURNEXPR.CleanUp();
608    iiRETURNEXPR.Init();
609  }
610  else
611    blackbox_default_Print(b,d);
612}
613void newstruct_setup(const char *n, newstruct_desc d )
614{
615  blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
616  // all undefined entries will be set to default in setBlackboxStuff
617  // the default Print is quite useful,
618  // all other are simply error messages
619  b->blackbox_destroy=newstruct_destroy;
620  b->blackbox_String=newstruct_String;
621  b->blackbox_Print=newstruct_Print;//blackbox_default_Print;
622  b->blackbox_Init=newstruct_Init;
623  b->blackbox_Copy=newstruct_Copy;
624  b->blackbox_Assign=newstruct_Assign;
625  b->blackbox_Op1=newstruct_Op1;
626  b->blackbox_Op2=newstruct_Op2;
627  //b->blackbox_Op3=blackbox_default_Op3;
628  b->blackbox_OpM=newstruct_OpM;
629  b->blackbox_CheckAssign=newstruct_CheckAssign;
630  b->blackbox_serialize=newstruct_serialize;
631  b->blackbox_deserialize=newstruct_deserialize;
632  b->data=d;
633  b->properties=1; // list_like
634  int rt=setBlackboxStuff(b,n);
635  d->id=rt;
636  //Print("create type %d (%s)\n",rt,n);
637}
638
639static newstruct_desc scanNewstructFromString(const char *s, newstruct_desc res)
640{
641  char *ss=omStrDup(s);
642  char *p=ss;
643  char *start;
644  int t;
645  char c;
646  newstruct_member elem;
647
648  idhdl save_ring=currRingHdl;
649  currRingHdl=(idhdl)1; // fake ring detection
650  loop
651  {
652    // read type:
653    while (*p==' ') p++;
654    start=p;
655    while (isalpha(*p)) p++;
656    *p='\0';
657    IsCmd(start,t);
658    if (t==0)
659    {
660      Werror("unknown type `%s`",start);
661      omFree(ss);
662      omFree(res);
663      currRingHdl=save_ring;
664      return NULL;
665    }
666    if (RingDependend(t))
667      res->size++;    // one additional field for the ring (before the data)
668    //Print("found type %s at real-pos %d",start,res->size);
669    elem=(newstruct_member)omAlloc0(sizeof(*elem));
670    // read name:
671    p++;
672    while (*p==' ') p++;
673    start=p;
674    while (isalpha(*p)) p++;
675    c=*p;
676    *p='\0';
677    elem->typ=t;
678    elem->pos=res->size;
679    if (*start=='\0') /*empty name*/
680    {
681      WerrorS("empty name for element");
682      goto error_in_newstruct_def;
683    }
684    elem->name=omStrDup(start);
685    //Print(" name:%s\n",start);
686    elem->next=res->member;
687    res->member=elem;
688    res->size++;
689
690    // next ?
691    *p=c;
692    while (*p==' ') p++;
693    if (*p!=',')
694    {
695      if (*p!='\0')
696      {
697        Werror("unknown character in newstruct:>>%s<<",p);
698        goto error_in_newstruct_def;
699      }
700      break; // end-of-list
701    }
702    p++;
703  }
704  omFree(ss);
705  currRingHdl=save_ring;
706  //Print("new type with %d elements\n",res->size);
707  return res;
708error_in_newstruct_def:
709   omFree(elem);
710   omFree(ss);
711   omFree(res);
712   currRingHdl=save_ring;
713   return NULL;
714}
715newstruct_desc newstructFromString(const char *s)
716{
717  newstruct_desc res=(newstruct_desc)omAlloc0(sizeof(*res));
718  res->size=0;
719
720  return scanNewstructFromString(s,res);
721}
722newstruct_desc newstructChildFromString(const char *parent, const char *s)
723{
724  // find parent:
725  int parent_id=0;
726  blackboxIsCmd(parent,parent_id);
727  if (parent_id<MAX_TOK)
728  {
729    Werror(">>%s< not found",parent);
730    return NULL;
731  }
732  blackbox *parent_bb=getBlackboxStuff(parent_id);
733  // check for the correct type:
734  if (parent_bb->blackbox_destroy!=newstruct_destroy)
735  {
736    Werror(">>%s< is not a user defined type",parent);
737    return NULL;
738  }
739  // setup for scanNewstructFromString:
740  newstruct_desc res=(newstruct_desc)omAlloc0(sizeof(*res));
741  newstruct_desc parent_desc=(newstruct_desc)parent_bb->data;
742  res->size=parent_desc->size;
743  res->member=parent_desc->member;
744  res->parent=parent_desc;
745
746  return scanNewstructFromString(s,res);
747}
748void newstructShow(newstruct_desc d)
749{
750  newstruct_member elem;
751  Print("id: %d\n",d->id);
752  elem=d->member;
753  while (elem!=NULL)
754  {
755    Print(">>%s<< at pos %d, type %d\n",elem->name,elem->pos,elem->typ);
756    elem=elem->next;
757  }
758}
759
760BOOLEAN newstruct_set_proc(const char *bbname,const char *func, int args,procinfov pr)
761{
762  int id=0;
763  blackboxIsCmd(bbname,id);
764  blackbox *bb=getBlackboxStuff(id);
765  newstruct_desc desc=(newstruct_desc)bb->data;
766  newstruct_proc p=(newstruct_proc)omAlloc(sizeof(*p));
767  p->next=desc->procs; desc->procs=p;
768
769  idhdl save_ring=currRingHdl;
770  currRingHdl=(idhdl)1; // fake ring detection
771
772  if(!IsCmd(func,p->t))
773  {
774    int t=0;
775    if (func[1]=='\0') p->t=func[0];
776    else if((t=iiOpsTwoChar(func))!=0)
777    {
778      p->t=t;
779    }
780    else
781    {
782      Werror(">>%s<< is not a kernel command",func);
783      currRingHdl = save_ring;
784      return TRUE;
785    }
786  }
787  p->args=args;
788  p->p=pr; pr->ref++;
789  currRingHdl = save_ring;
790  return FALSE;
791}
Note: See TracBrowser for help on using the repository browser.