home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / kaffe-0.5p4-src.tgz / tar.out / contrib / kaffe / kaffeh / sigs.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  3KB  |  179 lines
  1. /*
  2.  * sigs.c
  3.  * Translate a class into stubs.
  4.  *
  5.  * Copyright (c) 1996 Systems Architecture Research Centre,
  6.  *           City University, London, UK.
  7.  *
  8.  * See the file "license.terms" for information on usage and redistribution
  9.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  10.  *
  11.  * Written by Tim Wilkinson <tim@sarc.city.ac.uk>, February 1996.
  12.  */
  13.  
  14. #include <stdio.h>
  15.  
  16. static char fp[100];
  17.  
  18. /*
  19.  * Translate signature into argument count.
  20.  */
  21. char*
  22. translateSig(char* str, char** nstr, int* argp)
  23. {
  24.     int j;
  25.     int arg;
  26.     int k;
  27.  
  28.     switch (*str++) {
  29.     case 'L':
  30.         arg = 1;
  31.         strcpy(fp, "struct H");
  32.         k = strlen(fp);
  33.         for (j = 0; str[j] != ';'; j++, k++) {
  34.             if (str[j] == '/') {
  35.                 fp[k] = '_';
  36.             }
  37.             else {
  38.                 fp[k] = str[j];
  39.             }
  40.         }
  41.         fp[k] = '*';
  42.         fp[k+1] = 0;
  43.         str += j + 1;
  44.         break;
  45.     case '[':
  46.         arg = 1;
  47.         switch (*str++) {
  48.         case 'B':
  49.             strcpy(fp, "HArrayOfByte*");
  50.             break;
  51.         case 'C':
  52.             strcpy(fp, "HArrayOfChar*");
  53.             break;
  54.         case 'D':
  55.             strcpy(fp, "HArrayOfDouble*");
  56.             break;
  57.         case 'F':
  58.             strcpy(fp, "HArrayOfFloat*");
  59.             break;
  60.         case 'I':
  61.         case 'Z':    /* Bool */
  62.             strcpy(fp, "HArrayOfInt*");
  63.             break;
  64.         case 'S':
  65.             strcpy(fp, "HArrayOfShort*");
  66.             break;
  67.         case 'J':
  68.             strcpy(fp, "HArrayOfLong*");
  69.             break;
  70.         case '[':
  71.             strcpy(fp, "HArrayOfArray*");
  72.             /* Skip rest of definition */
  73.             while (*str == '[') {
  74.                 str++;
  75.             }
  76.             if (*str++ == 'L') {
  77.                 while (*str++ != ';')
  78.                     ;
  79.             }
  80.             break;
  81.         case 'L':
  82.             strcpy(fp, "HArrayOfObject*");
  83.             while (*str++ != ';')
  84.                 ;
  85.             break;
  86.         }
  87.         break;
  88.     case 'B':
  89.         arg = 1;
  90.         strcpy(fp, "jint /* byte */");
  91.         break;
  92.     case 'C':
  93.         arg = 1;
  94.         strcpy(fp, "jint /* char */");
  95.         break;
  96.     case 'D':
  97.         arg = 2;
  98.         strcpy(fp, "jdouble");
  99.         break;
  100.     case 'F':
  101.         arg = 1;
  102.         strcpy(fp, "jfloat");
  103.         break;
  104.     case 'I':
  105.         arg = 1;
  106.         strcpy(fp, "jint");
  107.         break;
  108.     case 'J':
  109.         arg = 2;
  110.         strcpy(fp, "jlong");
  111.         break;
  112.     case 'S':
  113.         arg = 1;
  114.         strcpy(fp, "jint /* short */");
  115.         break;
  116.     case 'Z':
  117.         arg = 1;
  118.         strcpy(fp, "jint /* bool */");
  119.         break;
  120.     case 'V':
  121.         arg = 0;
  122.         strcpy(fp, "void");
  123.         break;
  124.     default:
  125.         abort();
  126.     }
  127.  
  128.     if (argp != 0) {
  129.         (*argp) += arg;
  130.     }
  131.     if (nstr != 0) {
  132.         (*nstr) = str;
  133.     }
  134.  
  135.     return (fp);
  136. }
  137.  
  138. /*
  139.  * Translate signature to union type.
  140.  */
  141. char*
  142. translateSigType(char* str, char* type)
  143. {
  144.     switch (*str++) {
  145.     case 'L':
  146.         type[0] = 'p';
  147.         while (*str != ';') {
  148.             str++;
  149.         }
  150.         str++;
  151.         break;
  152.     case '[':
  153.         type[0] = 'p';
  154.         if (*str++ == 'L') {
  155.             while (*str != ';') {
  156.                 str++;
  157.             }
  158.             str++;
  159.         }
  160.         break;
  161.     case 'B': case 'C': case 'I': case 'S': case 'Z':
  162.         type[0] = 'i';
  163.         break;
  164.     case 'D':
  165.         type[0] = 'd';
  166.         break;
  167.     case 'F':
  168.         type[0] = 'f';
  169.         break;
  170.     case 'J':
  171.         type[0] = 'l';
  172.         break;
  173.     case 'V':
  174.         type[0] = 'v';
  175.         break;
  176.     }
  177.     return (str);
  178. }
  179.