home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dev / vbcc / parse_expr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-12-30  |  18.3 KB  |  771 lines
  1. /*  $VER: vbcc (parse_expr.c) V0.5  */
  2.  
  3. #include "vbc.h"
  4.  
  5. static char FILE_[]=__FILE__;
  6.  
  7. np expression(void)
  8. /*  Komma-Ausdruecke  */
  9. {
  10.   np left,right,new;
  11.   left=assignment_expression();
  12.   if(!left->flags) return 0;
  13.   killsp();
  14.   while(*s==','){
  15.     s++;
  16.     killsp();
  17.     right=assignment_expression();
  18.     new=mymalloc(NODES);
  19.     new->left=left;
  20.     new->right=right;
  21.     new->ntyp=0;
  22.     new->flags=KOMMA;
  23.     left=new;
  24.     killsp();
  25.   }
  26.   return left;
  27. }
  28. np assignment_expression(void)
  29. /*  Zuweisungsausdruecke  */
  30. {
  31.   np left,new;int c=0;
  32.   left=conditional_expression();
  33.   killsp();
  34.   if(*s!='='&&s[1]!='='&&s[2]!='=') return left;
  35.   if(*s=='=') {c=ASSIGN;s++;}
  36.   else if(*s=='*'&&s[1]=='=') {c=ASSIGNMULT;s+=2;}  
  37.   else if(*s=='/'&&s[1]=='=') {c=ASSIGNDIV;s+=2;}   
  38.   else if(*s=='%'&&s[1]=='=') {c=ASSIGNMOD;s+=2;}   
  39.   else if(*s=='+'&&s[1]=='=') {c=ASSIGNADD;s+=2;}   
  40.   else if(*s=='-'&&s[1]=='=') {c=ASSIGNSUB;s+=2;}   
  41.   else if(*s=='&'&&s[1]=='=') {c=ASSIGNAND;s+=2;}   
  42.   else if(*s=='^'&&s[1]=='=') {c=ASSIGNXOR;s+=2;}   
  43.   else if(*s=='|'&&s[1]=='=') {c=ASSIGNOR;s+=2;}    
  44.   else if(*s=='<'&&s[1]=='<') {c=ASSIGNLSHIFT;s+=3;}
  45.   else if(*s=='>'&&s[1]=='>') {c=ASSIGNRSHIFT;s+=3;}
  46.   else return left;
  47.   new=mymalloc(NODES);
  48.   new->left=left;
  49.   new->ntyp=0;
  50.   if(c==ASSIGN){
  51.     new->right=assignment_expression();
  52.     new->flags=ASSIGN;
  53.   }else{
  54.     /*  ASSIGNOP(a,b)->ASSIGN(a,OP(a,b))    */
  55.     new->flags=ASSIGNADD;   /* nur um zum Merken, dass nur einmal */
  56.                             /* ausgewertet werden darf            */
  57.     new->right=mymalloc(NODES);
  58.     new->right->left=left;
  59.     new->right->right=assignment_expression();
  60.     new->right->ntyp=0;
  61.     if(c==ASSIGNMULT) new->right->flags=MULT;
  62.     else if(c==ASSIGNDIV) new->right->flags=DIV;
  63.     else if(c==ASSIGNMOD) new->right->flags=MOD;
  64.     else if(c==ASSIGNADD) new->right->flags=ADD;
  65.     else if(c==ASSIGNSUB) new->right->flags=SUB;
  66.     else if(c==ASSIGNAND) new->right->flags=AND;
  67.     else if(c==ASSIGNXOR) new->right->flags=XOR;
  68.     else if(c==ASSIGNOR) new->right->flags=OR;
  69.     else if(c==ASSIGNLSHIFT) new->right->flags=LSHIFT;
  70.     else if(c==ASSIGNRSHIFT) new->right->flags=RSHIFT;
  71.   }
  72.   return new;
  73. }
  74. np conditional_expression(void)
  75. /*  Erledigt ? :   */
  76. {
  77.   np left,new;
  78.   left=logical_or_expression();
  79.   killsp();
  80.   if(*s=='?'){   
  81.     s++;killsp();
  82.     new=mymalloc(NODES);
  83.     new->flags=COND;
  84.     new->ntyp=0;
  85.     new->left=left;
  86.     new->right=mymalloc(NODES);
  87.     new->right->flags=COLON;
  88.     new->right->ntyp=0;
  89.     new->right->left=expression();
  90.     killsp();
  91.     if(*s==':'){s++;killsp();} else error(70);
  92.     new->right->right=conditional_expression();
  93.     left=new;
  94.     killsp();
  95.   }
  96.   return left;
  97. }
  98. np logical_or_expression(void)
  99. /*  Erledigt ||  */
  100. {
  101.   np left,right,new;
  102.   left=logical_and_expression();
  103.   killsp();
  104.   while(*s=='|'&&s[1]=='|'){
  105.     s+=2;
  106.     killsp();
  107.     right=logical_and_expression();
  108.     new=mymalloc(NODES);
  109.     new->left=left;
  110.     new->right=right;
  111.     new->flags=LOR;
  112.     new->ntyp=0;
  113.     left=new;
  114.     killsp();
  115.     if(*s=='&'&&s[1]=='&') error(222);
  116.   }
  117.   return left;
  118. }
  119. np logical_and_expression(void)
  120. /*  Erledigt &&  */
  121. {
  122.   np left,right,new;
  123.   left=inclusive_or_expression();
  124.   killsp();
  125.   while(*s=='&'&&s[1]=='&'){
  126.     s+=2;
  127.     killsp();
  128.     right=inclusive_or_expression();
  129.     new=mymalloc(NODES);
  130.     new->left=left;
  131.     new->right=right;
  132.     new->flags=LAND;
  133.     new->ntyp=0;
  134.     left=new;
  135.     killsp();
  136.     if(*s=='|'&&s[1]=='|') error(222);
  137.   }
  138.   return left;
  139. }
  140. np inclusive_or_expression(void)
  141. /*  Erledigt |  */
  142. {
  143.   np left,right,new;
  144.   left=exclusive_or_expression();
  145.   killsp();
  146.   while(*s=='|'&&s[1]!='|'&&s[1]!='='){
  147.     s++;
  148.     killsp();
  149.     right=exclusive_or_expression();
  150.     new=mymalloc(NODES);
  151.     new->left=left;
  152.     new->right=right;
  153.     new->flags=OR;
  154.     new->ntyp=0;
  155.     left=new;
  156.     killsp();
  157.   }
  158.   return left;
  159. }
  160. np exclusive_or_expression(void)
  161. /*  Erledigt ^  */
  162. {
  163.   np left,right,new;
  164.   left=and_expression();
  165.   killsp();
  166.   while(*s=='^'&&s[1]!='='){
  167.     s++;
  168.     killsp();
  169.     right=and_expression();
  170.     new=mymalloc(NODES);
  171.     new->left=left;
  172.     new->right=right;
  173.     new->flags=XOR;
  174.     new->ntyp=0;
  175.     left=new;
  176.     killsp();
  177.   }
  178.   return left;
  179. }
  180. np and_expression(void)
  181. /*  Erledigt &  */
  182. {
  183.   np left,right,new;
  184.   left=equality_expression();
  185.   killsp();
  186.   while(*s=='&'&&s[1]!='&'&&s[1]!='='){
  187.     s++;
  188.     killsp();
  189.     right=equality_expression();
  190.     new=mymalloc(NODES);
  191.     new->left=left;
  192.     new->right=right;
  193.     new->flags=AND;
  194.     new->ntyp=0;
  195.     left=new;
  196.     killsp();
  197.   }
  198.   return left;
  199. }
  200. np equality_expression(void)
  201. /*  Erledigt == und !=  */
  202. {
  203.   np left,right,new;int c;
  204.   left=relational_expression();
  205.   killsp();
  206.   while((*s=='='||*s=='!')&&s[1]=='='){
  207.     if(*s=='!') c=INEQUAL; else c=EQUAL;
  208.     s+=2;
  209.     killsp();
  210.     right=relational_expression();
  211.     new=mymalloc(NODES);
  212.     new->left=left;
  213.     new->right=right;
  214.     new->flags=c;
  215.     new->ntyp=0;
  216.     left=new;
  217.     killsp();
  218.   }
  219.   return left;
  220. }
  221. np relational_expression(void)
  222. /*  Erledigt <,>,<=,>=  */
  223. {
  224.   np left,right,new;int c;
  225.   left=shift_expression();
  226.   killsp();
  227.   while((*s=='<'&&s[1]!='<')||(*s=='>'&&s[1]!='>')){
  228.     if(*s++=='<'){
  229.       if(*s=='='){s++;c=LESSEQ;}else c=LESS;
  230.     }else{
  231.       if(*s=='='){s++;c=GREATEREQ;}else c=GREATER;
  232.     }
  233.     killsp();
  234.     right=shift_expression();
  235.     new=mymalloc(NODES);
  236.     new->left=left;
  237.     new->right=right;
  238.     new->flags=c;
  239.     new->ntyp=0;
  240.     left=new;
  241.     killsp();
  242.   }
  243.   return left;
  244. }
  245. np shift_expression(void)
  246. /*  Erledigt <<,>>  */
  247. {
  248.   np left,right,new;int c;
  249.   left=additive_expression();
  250.   killsp();
  251.   while((*s=='<'&&s[1]=='<'&&s[2]!='=')||(*s=='>'&&s[1]=='>'&&s[2]!='=')){
  252.     if(*s=='<') c=LSHIFT; else c=RSHIFT;
  253.     s+=2;
  254.     killsp();
  255.     right=additive_expression();
  256.     new=mymalloc(NODES);
  257.     new->left=left;
  258.     new->right=right;
  259.     new->flags=c;
  260.     new->ntyp=0;
  261.     left=new;
  262.     killsp();
  263.   }
  264.   return left;
  265. }
  266. np additive_expression(void)
  267. /*  Erledigt +,-  */
  268. {
  269.   np left,right,new;int c;
  270.   left=multiplicative_expression();
  271.   killsp();
  272.   while((*s=='+'||*s=='-')&&s[1]!='='){
  273.     if(*s++=='+') c=ADD; else c=SUB;
  274.     killsp();
  275.     right=multiplicative_expression();
  276.     new=mymalloc(NODES);
  277.     new->left=left;
  278.     new->right=right;
  279.     new->flags=c;
  280.     new->ntyp=0;
  281.     left=new;
  282.     killsp();
  283.   }
  284.   return left;
  285. }
  286. np multiplicative_expression(void)
  287. /*  Erledigt *,/,%  */
  288. {
  289.   np left,right,new;int c;
  290.   left=cast_expression();
  291.   killsp();
  292.   while((*s=='*'||*s=='/'||*s=='%')&&s[1]!='='){
  293.     if(*s=='*') c=MULT; else {if(*s=='/') c=DIV; else c=MOD;}
  294.     s++;
  295.     killsp();
  296.     right=cast_expression();
  297.     new=mymalloc(NODES);
  298.     new->left=left;
  299.     new->right=right;
  300.     new->flags=c;
  301.     new->ntyp=0;
  302.     left=new;
  303.     killsp();
  304.   }
  305.   return left;
  306. }
  307. np cast_expression(void)
  308. /*  Erledigt (typ)  */
  309. {
  310.   np new;char *imerk,buff[MAXI];
  311.   killsp();
  312.   if(*s!='('||!declaration(1)) return unary_expression();
  313.   s++;killsp();
  314.   new=mymalloc(NODES);
  315.   new->flags=CAST;
  316.   new->right=0;
  317.   imerk=ident;ident=buff;
  318.   new->ntyp=declarator(declaration_specifiers());
  319.   ident=imerk;
  320.   killsp();
  321.   if(*s!=')') error(59); else s++;
  322.   new->left=cast_expression();
  323.   return new;
  324. }
  325. np unary_expression(void)
  326. /*  Erledigt !,~,++,--,+,-,*,&,sizeof,__typeof  */
  327. {
  328.   np new;char *merk=s,buff[MAXI];
  329.   killsp();
  330.   if((*s!='s'&&*s!='_'&&*s!='+'&&*s!='-'&&*s!='&'&&*s!='*'&&*s!='~'&&*s!='!')||s[1]=='=') return postfix_expression();
  331.   if(*s=='s'||*s=='_'){
  332.     int fszof;
  333.     merk=s;cpbez(buff,0);s=merk;
  334.     if(strcmp("sizeof",buff)&&strcmp("__typeof",buff)){
  335.       return postfix_expression();
  336.     }else{
  337.       if(*buff=='s') fszof=1; else fszof=0;
  338.       s+=strlen(buff);
  339.       killsp();
  340.       new=mymalloc(NODES);
  341.       new->flags=CEXPR;
  342.       new->ntyp=mymalloc(TYPS);
  343.       if(fszof) new->ntyp->flags=UNSIGNED|LONG;
  344.         else   new->ntyp->flags=INT;
  345.       new->ntyp->next=0;
  346.       new->right=0;
  347.       new->left=0;
  348.       if(*s=='('&&declaration(1)){
  349.     struct Typ *t;
  350.     s++;killsp();
  351.     merk=ident;ident=buff;
  352.     t=declarator(declaration_specifiers());
  353.     if(type_uncomplete(t)) error(176);
  354.     ident=merk;
  355.     if(fszof)
  356.       new->val.vulong=zl2zul(szof(t));
  357.     else
  358.       new->val.vint=zl2zi(l2zl(t->flags));
  359.     freetyp(t);
  360.     killsp();
  361.     if(*s!=')') error(59); else s++;
  362.       }else{
  363.     np tree;
  364.     killsp();
  365.     tree=unary_expression();
  366.     if(!tree||!type_expression(tree)){
  367.       if(fszof){
  368.         new->val.vulong=zl2zul(l2zl(0L));
  369.         error(73);
  370.       }else{
  371.         new->val.vint=zl2zi(l2zl(-1L));
  372.       }
  373.     }else{
  374.       if(fszof){
  375.         if(type_uncomplete(tree->ntyp)) error(176);
  376.         new->val.vulong=zl2zul(szof(tree->ntyp));
  377.       }else{
  378.         new->val.vint=zl2zi(l2zl(tree->ntyp->flags));
  379.       }
  380.     }
  381.     if(tree) free_expression(tree);killsp();
  382.       }
  383.       return new;
  384.     }
  385.   }
  386.   new=mymalloc(NODES);
  387.   new->right=0;
  388.   new->ntyp=0;
  389.   if(*s=='+'){
  390.     if(s[1]=='+'){
  391.       s+=2;
  392.       new->left=unary_expression();
  393.       new->flags=PREINC;
  394.     }else{
  395.       s++;free(new);
  396.       return cast_expression();
  397.     }
  398.   }else if(*s=='-'){
  399.     if(s[1]=='-'){
  400.       s+=2;
  401.       new->left=unary_expression();
  402.       new->flags=PREDEC;
  403.     }else{
  404.       s++;
  405.       new->left=cast_expression();
  406.       new->flags=MINUS;
  407.     }
  408.   }else if(*s=='&'){
  409.     s++;
  410.     new->left=cast_expression();
  411.     new->flags=ADDRESS;
  412.   }else if(*s=='*'){
  413.     s++;
  414.     new->left=cast_expression();
  415.     new->flags=CONTENT;
  416.   }else if(*s=='~'){
  417.     s++;
  418.     new->left=cast_expression();
  419.     new->flags=KOMPLEMENT;
  420.   }else if(*s=='!'){
  421.     s++;
  422.     new->left=cast_expression();
  423.     new->flags=NEGATION;
  424.   }
  425.   new->right=0;
  426.   new->ntyp=0;
  427.   return new;
  428. }
  429. np postfix_expression(void)
  430. /*  Erledigt [],(),.,->,++,--  */
  431. {
  432.   np new,left;
  433.   left=primary_expression();
  434.   killsp();
  435.   while(*s=='['||*s=='('||*s=='.'||(*s=='-'&&((s[1]=='-')||(s[1]=='>')))
  436.     ||(*s=='+'&&s[1]=='+')){
  437.     new=mymalloc(NODES);
  438.     new->ntyp=0;
  439.     new->right=0;
  440.     new->left=left;
  441.     if(*s=='-'){
  442.       s++;
  443.       if(*s=='-'){
  444.     s++;
  445.     new->flags=POSTDEC;
  446.       }else{
  447.     s++; killsp();
  448.     new->flags=DSTRUCT;
  449.     new->right=identifier_expression();
  450.     new->right->flags=MEMBER;
  451.     new->left=mymalloc(NODES);
  452.     new->left->ntyp=0;
  453.     new->left->left=left;
  454.     new->left->right=0;
  455.     new->left->flags=CONTENT;
  456.       }
  457.     }else if(*s=='['){
  458.       s++; killsp();
  459.       new->flags=CONTENT;
  460.       new->left=mymalloc(NODES);
  461.       new->left->flags=ADD;
  462.       new->left->ntyp=0;
  463.       new->left->left=left;
  464.       new->left->right=expression();
  465.       killsp();
  466.       if(*s!=']') error(62); else s++;
  467.     }else if(*s=='+'){
  468.       s+=2;
  469.       new->flags=POSTINC;
  470.     }else if(*s=='.'){
  471.       s++;killsp();
  472.       new->right=identifier_expression();
  473.       new->flags=DSTRUCT;
  474.       new->right->flags=MEMBER;
  475.     }else if(*s=='('){
  476.       struct argument_list *al,*first_alist=0,*last_alist=0;np n;
  477.       s++;killsp();
  478.       new->flags=CALL;
  479.       new->right=0;
  480.       while(*s!=')'){
  481.     n=assignment_expression();
  482.     al=mymalloc(sizeof(struct argument_list));
  483.     al->arg=n;al->next=0;
  484.     if(last_alist){
  485.       last_alist->next=al;
  486.       last_alist=al;
  487.     }else{
  488.       last_alist=first_alist=al;
  489.     }
  490.     killsp();
  491.     if(*s==',') {s++;killsp();if(*s==')') error(59);}
  492.     else if(*s!=')') error(57);
  493.     
  494.       }
  495.       new->alist=first_alist;
  496.       if(*s!=')') error(59); else s++;
  497.     }
  498.     left=new;
  499.     killsp();
  500.   }
  501.   return left;
  502. }
  503. np primary_expression(void)
  504. /*  primary-expressions (Konstanten,Strings,(expr),Identifier)  */
  505. {
  506.   np new;
  507.   if((*s>='0'&&*s<='9')||*s=='.') return constant_expression();
  508.   if(*s=='\"'||*s=='\''||(*s=='L'&&(s[1]=='\''||s[1]=='\"'))) return string_expression();
  509.   if(*s=='('){
  510.     s++;killsp();
  511.     new=expression();
  512.     killsp();
  513.     if(*s!=')') error(59); else s++;
  514.     return new;
  515.   }
  516.   return identifier_expression();
  517. }
  518. np string_expression(void)
  519. /*  Gibt Zeiger auf string oder Zeichenkonstante zurueck  */
  520. {
  521.   np new; char f,string[MAXINPUT],*p;int flag,val;zlong zl;
  522.   if(*s=='L') s++;    /*  Noch keine erweiterten Zeichen  */
  523.   p=string;f=*s++;
  524.   while(1){
  525.     while(*s!=f&&p<&string[MAXINPUT-1]){
  526.       if(*s=='\\'){
  527.     s++;
  528.     if(*s=='\\'){*p++='\\';s++;continue;}
  529.     if(*s=='n'){*p++='\n';s++;continue;}
  530.     if(*s=='t'){*p++='\t';s++;continue;}
  531.     if(*s=='r'){*p++='\r';s++;continue;}
  532.     if(*s=='v'){*p++='\v';s++;continue;}
  533.     if(*s=='b'){*p++='\b';s++;continue;}
  534.     if(*s=='f'){*p++='\f';s++;continue;}
  535.     if(*s=='a'){*p++='\a';s++;continue;}
  536.     if(*s=='\?'){*p++='\?';s++;continue;}
  537.     if(*s=='\''){*p++='\'';s++;continue;}
  538.     if(*s=='\"'){*p++='\"';s++;continue;}
  539.     flag=val=0;
  540.     while(*s>='0'&&*s<='7'&&flag<3){
  541.       val=val*8+*s-'0';
  542.       s++;flag++;
  543.     }
  544.     if(flag){*p++=val;continue;}
  545.     if(*s=='x'){
  546.       s++;val=0;
  547.       while((*s>='0'&&*s<='9')||(*s>='a'&&*s<='f')||(*s>='A'&&*s<='F')){
  548.         val=val*16;
  549.         if(*s>='0'&&*s<='9') val+=*s-'0';
  550.         if(*s>='a'&&*s<='f') val+=*s-'a'+10;
  551.         if(*s>='A'&&*s<='F') val+=*s-'A'+10;
  552.         s++;
  553.       }
  554.       *p++=val;continue;
  555.     }
  556.     error(71);
  557.       }
  558.       *p++=*s++;
  559.     }
  560.     if(*s!=f) error(74); else s++;
  561.     killsp();
  562.     if(f!='\"'||*s!=f) break; else s++;
  563.   }
  564.   *p=0;
  565.   new=mymalloc(NODES);
  566.   new->ntyp=mymalloc(TYPS);
  567.   if(f=='\"'){
  568.     struct const_list *cl,**prev;int i;
  569.     new->ntyp->flags=ARRAY;
  570.     new->ntyp->size=l2zl((long)(p-string)+1);
  571.     new->ntyp->next=mymalloc(TYPS);
  572.     new->ntyp->next->flags=STRINGCONST|CHAR;
  573.     new->ntyp->next->next=0;
  574.     new->flags=STRING;
  575.     prev=&new->cl;
  576.     for(i=0;i<p-string+1;i++){
  577.       cl=mymalloc(CLS);
  578.       cl->next=0;
  579.       cl->tree=0;
  580.       cl->other=mymalloc(CLS);
  581.       cl->other->next=cl->other->other=0;
  582.       cl->other->tree=0;
  583.       cl->other->val.vchar=zl2zc(l2zl((long)string[i]));
  584.       *prev=cl;
  585.       prev=&cl->next;
  586.     }
  587.     /*        new->identifier=add_identifier(string,p-string);*/
  588.     new->val.vlong=l2zl(0L);
  589.   }else{
  590.     char *l;
  591.     new->ntyp->flags=CONST|INT;
  592.     new->ntyp->next=0;
  593.     new->flags=CEXPR;
  594.     zl=l2zl(0L);
  595.     p--;
  596.     if(p>string) error(72);
  597.     for(BIGENDIAN?(l=string):(l=p);BIGENDIAN?(l<=p):(l>=string);BIGENDIAN?(l++):(l--)){
  598.       /*  zl=zl<<CHAR_BIT+*p  */
  599.       zl=zllshift(zl,char_bit);
  600.       zl=zladd(zl,l2zl((long)*l));
  601.       new->val.vint=zl2zi(zl);
  602.     }
  603.   }
  604.   new->left=new->right=0;
  605.   return new;
  606. }
  607. np constant_expression(void)
  608. /*  Gibt Zeiger auf erzeugt Struktur fuer Konstante zurueck */
  609. {
  610.   np new; zdouble db;
  611.   zulong value,zbase,digit;unsigned long base=10,t;
  612.   char *merk;int warned=0;
  613.   merk=s;
  614.   value=ul2zul(0L);
  615.   new=mymalloc(NODES);
  616.   new->ntyp=mymalloc(TYPS);
  617.   new->ntyp->flags=0;
  618.   new->ntyp->next=0;
  619.   new->flags=CEXPR;
  620.   new->left=new->right=0;
  621.   new->sidefx=0;
  622.   if(*s=='0'){
  623.     s++;
  624.     if(*s=='x'||*s=='X'){s++;base=16;} else base=8;
  625.   }
  626.   zbase=ul2zul(base);
  627.   if(*s>='0'&&*s<='9') t=*s-'0'; 
  628.   else if(*s>='a'&&*s<='f') t=*s-'a'+10; 
  629.   else if(*s>='A'&&*s<='F') t=*s-'A'+10;
  630.   else t=20;
  631.   while(t<base){
  632.     digit=ul2zul(t);
  633.     if(!warned){
  634.       if(!zulleq(value,zuldiv(zulsub(t_max[UNSIGNED|LONG],digit),zbase)))
  635.     warned=1;
  636.     }
  637.     value=zuladd(zulmult(value,zbase),digit);
  638.     s++;
  639.     if(*s>='0'&&*s<='9') t=*s-'0'; 
  640.     else if(*s>='a'&&*s<='f') t=*s-'a'+10; 
  641.     else if(*s>='A'&&*s<='F') t=*s-'A'+10; 
  642.     else t=20;
  643.   }
  644.   while(*s=='u'||*s=='U'||*s=='l'||*s=='L'){
  645.     if(*s=='u'||*s=='U'){
  646.       if(zulleq(value,t_max[UNSIGNED|INT])) new->ntyp->flags=UNSIGNED|INT;
  647.       else               new->ntyp->flags=UNSIGNED|LONG;
  648.     }else{
  649.       if(zulleq(value,t_max[LONG])) new->ntyp->flags=LONG;
  650.       else               new->ntyp->flags=UNSIGNED|LONG;
  651.     }
  652.     s++;
  653.   }
  654.   if(*s=='.'||*s=='e'||*s=='E'){
  655.     /*  Fliesskommakonstante, ignoriert vorher berechneten Wert, falls er   */
  656.     /*  nicht dezimal und nicht 0 war (da er dann oktal war)                */
  657.     if(*merk=='0'&&!zuleqto(value,ul2zul(0UL))){
  658.       value=ul2zul(0UL);zbase=ul2zul(10UL);
  659.       while(*merk>='0'&&*merk<='9'){
  660.     digit=ul2zul((unsigned long)(*merk-'0'));
  661.     value=zuladd(zulmult(value,zbase),digit);
  662.     merk++;
  663.       }
  664.       if(merk!=s) error(75);
  665.     }
  666.     db=zul2zd(value);
  667.     if(*s=='.'){
  668.       /*  Teil hinter Kommastellen    */
  669.       zdouble zquot,zbased,digit;
  670.       s++;
  671.       zbased=d2zd(10);zquot=d2zd(0.1);
  672.       while(*s>='0'&&*s<='9'){
  673.     digit=d2zd((double)(*s-'0'));
  674.     db=zdadd(db,zdmult(digit,zquot));
  675.     zquot=zddiv(zquot,zbased);
  676.     s++;
  677.       }
  678.       
  679.     }
  680.     if(*s=='e'||*s=='E'){
  681.       /*  Exponentialdarstellung  */
  682.       int exp,vorz,i;zdouble zbased;
  683.       zbased=d2zd((double)10);
  684.       s++;
  685.       if(*s=='-'){
  686.     s++;vorz=-1;
  687.       }else{
  688.     vorz=1;if(*s=='+') s++;
  689.       }
  690.       exp=0;
  691.       while(*s>='0'&&*s<='9') exp=exp*10+*s++-'0';
  692.       for(i=0;i<exp;i++){
  693.     if(vorz>0) db=zdmult(db,zbased);
  694.     else   db=zddiv(db,zbased);
  695.       }
  696.     }
  697.     new->ntyp->flags=DOUBLE;
  698.     if(*s=='f'||*s=='F'){
  699.       new->ntyp->flags=FLOAT;s++;
  700.     }else{
  701.       /*  long double werden nicht unterstuetzt und sind==double :-(  */
  702.       if(*s=='l'||*s=='L') s++;
  703.     }
  704.   }else{
  705.     if(warned) error(211);
  706.     if(new->ntyp->flags==0){
  707.       if(base==10){
  708.     if(zulleq(value,t_max[INT])) new->ntyp->flags=INT;
  709.     else if(zulleq(value,t_max[LONG])) new->ntyp->flags=LONG; 
  710.         else {new->ntyp->flags=UNSIGNED|LONG;error(212);}
  711.       }else{
  712.     if(zulleq(value,t_max[INT])) new->ntyp->flags=INT; 
  713.     else if(zulleq(value,t_max[UNSIGNED|INT])) new->ntyp->flags=UNSIGNED|INT;
  714.     else if(zulleq(value,t_max[LONG])) new->ntyp->flags=LONG;
  715.     else {new->ntyp->flags=UNSIGNED|LONG;error(212);}
  716.       }
  717.     }
  718.   }
  719.   
  720.   if(new->ntyp->flags==FLOAT) new->val.vfloat=zd2zf(db);
  721.   else if(new->ntyp->flags==DOUBLE) new->val.vdouble=db;
  722.   else if(new->ntyp->flags==INT) new->val.vint=zl2zi(zul2zl(value));
  723.   else if(new->ntyp->flags==(UNSIGNED|INT)) new->val.vuint=zul2zui(value);
  724.   else if(new->ntyp->flags==LONG) new->val.vlong=zul2zl(value);
  725.   else if(new->ntyp->flags==(UNSIGNED|LONG)) new->val.vulong=value;
  726.   else ierror(0);
  727.   return new;
  728. }
  729. np identifier_expression(void)
  730. /*  Erzeugt Identifier mit Knoten  */
  731. {
  732.   np new;char buff[MAXI];
  733.   killsp();cpbez(buff,1);
  734.   new=mymalloc(NODES);
  735.   new->flags=IDENTIFIER;
  736.   new->left=new->right=0;
  737.   new->identifier=add_identifier(buff,strlen(buff));
  738.   new->ntyp=0;
  739.   new->sidefx=0;
  740.   new->val.vlong=l2zl(0L);
  741.   if(new->identifier==empty) {error(76);new->flags=0;}
  742.   return new;
  743. }
  744. void free_alist(struct argument_list *p)
  745. /*  Gibt argument_list inkl. expressions frei  */
  746. {
  747.   struct argument_list *merk;
  748.   while(p){
  749.     merk=p->next;
  750.     if(p->arg) free_expression(p->arg);
  751.     free(p);
  752.     p=merk;
  753.   }
  754. }
  755. void free_expression(np p)
  756. /*  Gibt expression mit allen Typen etc. frei  */
  757. {
  758.   if(!p) return;
  759.   if(p->flags==ASSIGNADD){
  760.     if(!p->right){ierror(0);return;}
  761.     if(p->right->left==p->left)  p->left=0;
  762.     if(p->right->right==p->left) p->left=0;
  763.   }
  764.   if(p->flags==CALL&&p->alist) free_alist(p->alist);
  765.   if(p->ntyp) freetyp(p->ntyp);
  766.   if(p->left) free_expression(p->left);
  767.   if(p->right) free_expression(p->right);
  768.   free(p);
  769. }
  770.  
  771.