home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Compilers⁄Interps / GCC 1.37.1r15 Full / Sources / parameter.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-11  |  4.3 KB  |  268 lines  |  [TEXT/MPS ]
  1. #include <ctype.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <Types.h>
  5. #include "obstack.h"
  6. #include "tm.h"
  7.  
  8. #define obstack_chunk_alloc xmalloc
  9. #define obstack_chunk_free free
  10.  
  11. extern int xmalloc ();
  12. extern void free ();
  13.  
  14. static struct obstack thestack;
  15. static struct obstack *paramob;
  16.  
  17. extern FILE *finput;
  18.  
  19. static int c;
  20.  
  21. static parameter *thelast = NULL;
  22.  
  23. void
  24. initparameter(void)
  25. {
  26.     paramob=&thestack;
  27.     obstack_init (paramob);
  28.     thelast = NULL;
  29. }
  30.  
  31. void
  32. printreg( pregs r )
  33. {
  34.     switch( r ) {
  35.     case noreg:
  36.         fprintf( stderr, "noreg\n" );
  37.         break;
  38.     case pd0:
  39.         fprintf( stderr, "d0\n" );
  40.         break;
  41.     case pd1:
  42.         fprintf( stderr, "d1\n" );
  43.         break;
  44.     case pd2:
  45.         fprintf( stderr, "d2\n" );
  46.         break;
  47.     case pa0:
  48.         fprintf( stderr, "a0\n" );
  49.         break;
  50.     case pa1:
  51.         fprintf( stderr, "a1\n" );
  52.         break;
  53.     default:
  54.         fprintf( stderr, "unknown\n" );
  55.         break;
  56.     }
  57. }
  58.  
  59.     
  60. void
  61. printparameter(parameter *p)
  62. {
  63.     int i;
  64.     
  65.     fprintf( stderr, "%s\n", p->name );
  66.     fprintf( stderr, "function result: " );
  67.     printreg( p->funcreturn );
  68.     
  69.     for( i=0; i<MAXPARAMS; i++ ) {
  70.         fprintf( stderr, "parameter %d: ", i );
  71.         printreg( p->params[i] );
  72.     }
  73. }
  74.     
  75.  
  76. pregs
  77. parsereg( void )
  78. {
  79.     c = getc( finput );
  80.     if( c == 'a' || c == 'A' ) {
  81.         c = getc( finput );
  82.         switch( c ) {
  83.             case '0':
  84.                 return( pa0 );
  85.             case '1':
  86.                 return( pa1 );
  87.             default:
  88.                 warning( "Illegal register in parameter pragma.\n" );
  89.                 return( noreg );
  90.         }
  91.     }
  92.     
  93.     if( c == 'd' || c == 'D' ) {
  94.         c = getc( finput );
  95.         switch( c ) {
  96.             case '0':
  97.                 return( pd0 );
  98.             case '1':
  99.                 return( pd1 );
  100.             case '2':
  101.                 return( pd2 );
  102.             default:
  103.                 warning( "Illegal register in parameter pragma.\n" );
  104.                 return( noreg );
  105.         }
  106.     }
  107. }
  108. #if 1    
  109. int
  110. parseparam(void)
  111. {    
  112.     int i;
  113.     char symbol[512];
  114.     char *s;
  115.     parameter p;
  116.     parameter *tp;
  117.     
  118.     s = symbol;
  119.     
  120.     for( i=0; i<MAXPARAMS; i++ )
  121.         p.params[i] = noreg;
  122.         
  123.     p.funcreturn = noreg;
  124.         
  125.     do {
  126.         c = getc( finput );
  127.     } while( !(isalnum(c) || c == '_') );
  128.     
  129.     if( c == '_' )
  130.     {
  131.         c = getc( finput );
  132.         if( c == '_' )
  133.             p.funcreturn = parsereg();
  134.         else
  135.         {
  136.             *s++ =  '_' ;
  137.             *s++ =   c ;
  138.         }
  139.         
  140.     }
  141.     else
  142.     *s++ =  c ;
  143.     
  144.     do {
  145.         c = getc( finput );
  146.     } while( !(isalnum(c) || c == '_' ) );
  147.     
  148.     while( isalnum(c) || c == '_' ) {
  149.         *s++ =  c ;
  150.         c = getc( finput );
  151.     }
  152.     *s++ =  '\0' ;
  153.     
  154.     if( c == '\n' ) {
  155.         //printparameter(&p);
  156.         tp = (void *)malloc( sizeof( parameter ) + strlen( symbol ) + 1);
  157.         *tp = p;
  158.         strcpy( tp->name, symbol );
  159.         tp->last = thelast;
  160.         thelast = tp;
  161.         return(c);
  162.     }
  163.  
  164.     for( i=0; i < MAXPARAMS; i++ ) {
  165.         do {
  166.             c = getc( finput );
  167.         } while( !(isalnum(c)|| c == '_' || c == '\n' ) );
  168.         if( c == '_' ){
  169.             c = getc( finput );
  170.             if( c == '_' )
  171.                 p.params[i] = parsereg();
  172.         }
  173.         if( c == '\n' ) {
  174.             //printparameter(&p);
  175.             tp = (void *)malloc( sizeof( parameter ) + strlen( symbol ) + 1 );
  176.             *tp = p;
  177.             strcpy( tp->name, symbol );
  178.             tp->last = thelast;
  179.             thelast = tp;
  180.             return(c);
  181.         }
  182.     }
  183. }
  184. #else
  185. {    
  186.     int i;
  187.     parameter *p;
  188.     
  189.     p = (parameter *)obstack_base( paramob );
  190.     obstack_blank( paramob, sizeof( parameter ) );
  191.     
  192.     for( i=0; i<MAXPARAMS; i++ )
  193.         p->params[i] = noreg;
  194.         
  195.     p->funcreturn = noreg;
  196.     
  197.     p->last = thelast;
  198.     
  199.     do {
  200.         c = getc( finput );
  201.     } while( !(isalnum(c) || c == '_') );
  202.     
  203.     if( c == '_' )
  204.     {
  205.         c = getc( finput );
  206.         if( c == '_' )
  207.             p->funcreturn = parsereg();
  208.         else
  209.         {
  210.             obstack_1grow( paramob, '_' );
  211.             obstack_1grow( paramob, c );
  212.         }
  213.         
  214.     }
  215.     else
  216.     obstack_1grow( paramob, c );
  217.     
  218.     do {
  219.         c = getc( finput );
  220.     } while( !(isalnum(c) || c == '_' ) );
  221.     
  222.     while( isalnum(c) || c == '_' ) {
  223.         obstack_1grow( paramob, c );
  224.         c = getc( finput );
  225.     }
  226.     obstack_1grow( paramob, 0 );
  227.     
  228.     if( c == '\n' ) {
  229.         p=(parameter *)obstack_finish( paramob );
  230.         //printparameter(p);
  231.         thelast = p;
  232.         return(c);
  233.     }
  234.  
  235.     for( i=0; i < MAXPARAMS; i++ ) {
  236.         do {
  237.             c = getc( finput );
  238.         } while( !(isalnum(c)|| c == '_' || c == '\n' ) );
  239.         if( c == '_' ){
  240.             c = getc( finput );
  241.             if( c == '_' )
  242.                 p->params[i] = parsereg();
  243.         }
  244.         if( c == '\n' ) {
  245.             p=(parameter *)obstack_finish( paramob );
  246.             //printparameter(p);
  247.             thelast = p;
  248.             return(c);
  249.         }
  250.     }
  251. }
  252. #endif
  253. parameter *
  254. lookupparameter( const char *name )
  255. {
  256.     parameter *temp;
  257.     
  258.     //fprintf( stderr, "looking up:%s\n", name );
  259.     
  260.     for( temp = thelast; temp != NULL; temp = temp->last ) {
  261.         if( strcmp( name, temp->name ) == 0 ) {
  262.             //fprintf( stderr, "found:%s\n", name );
  263.             return( temp );
  264.         }
  265.     }
  266.             
  267.     return( NULL );
  268. }