source: git/Singular/newstruct.cc @ 3877fe

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