Changeset 2293


Ignore:
Timestamp:
Jan 26, 2007, 10:04:42 PM (14 years ago)
Author:
yura
Message:

Reading functions name and types from RFI file, if it exists.

Location:
to-imperative/trunk/java/org/refal/plus/wrapgen
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • to-imperative/trunk/java/org/refal/plus/wrapgen/RFIFile.java

    r2292 r2293  
    6868        }
    6969       
    70         private void readRFIFile (FileInputStream in)
    71         {
    72                
     70        private void readRFIFile (FileInputStream in) throws Exception {
     71                byte[] file = new byte[1024*1024];
     72                int z = in.read(file);
     73                String str = new String(file, 0, z);
     74                while (str.length() != 0) {
     75                        int i = str.indexOf("$func");
     76                        if (i == -1)
     77                                break;
     78                        for (i += 5; ;i++)
     79                                if (str.charAt(i)!=' ')
     80                                        break;
     81                        int j;
     82                        String name;
     83                        if (str.charAt(i)=='\"')
     84                        {
     85                                j = str.indexOf('\"', i+1);
     86                                name = str.substring(i+1,j);
     87                                j++;                           
     88                        }
     89                        else
     90                        {
     91                                j = str.indexOf(' ', i+1);
     92                                name = str.substring(i,j);
     93                        }
     94                        int[] argTypes = new int[1024];
     95                        int retType = 0;
     96                        int l = 0;
     97                        boolean flag = true;
     98                        for (;flag;j++) {
     99                                switch (str.charAt(j)) {
     100                                case 'e': argTypes[l] = WrapGen.E; l++; break;
     101                                case 's': argTypes[l] = WrapGen.S; l++; break;
     102                                case '=': flag = false; break;
     103                                default: break;
     104                                }
     105                        }
     106                        flag = true;
     107                        for (;flag;j++) {
     108                                switch (str.charAt(j)) {
     109                                case 'e': retType = WrapGen.E; flag = false; break;
     110                                case 's': retType = WrapGen.S; flag = false; break;
     111                                case ';': flag = false; break;
     112                                default: break;
     113                                }
     114                        }
     115                        int m = str.indexOf("//", j);
     116                        for (m += 2; str.charAt(m)==' ';m++);
     117                        int n = str.indexOf('\n', m);
     118                        String javaDesc = str.substring(m,n);
     119                        str = str.substring(n);
     120                       
     121                        RefalFunction refFun = new RefalFunction();
     122                        refFun.name = name;
     123                        refFun.retType = retType;
     124                        refFun.argTypes = new int[l];
     125                        for (int ii = 0; ii < l; ii++)
     126                                refFun.argTypes[ii] = argTypes[ii];
     127                       
     128                        this.refalFunctions.put(javaDesc, refFun);
     129                }
    73130        }
    74131       
    75132        private RefalFunction findRefalFunction  (boolean isStatic, String name, Type retType, Type[] argTypes) {
    76                 return null;
     133                return (RefalFunction)this.refalFunctions.get(getJavaDeclaration(isStatic, name, retType, argTypes));
    77134        }
    78135       
  • to-imperative/trunk/java/org/refal/plus/wrapgen/WrapGen.java

    r2292 r2293  
    11package org.refal.plus.wrapgen;
     2
    23import java.io.File;
    34import java.io.FileInputStream;
     
    1415import org.objectweb.asm.Type;
    1516
    16 import org.refal.plus.wrapgen.RFIFile;
    17 
    1817public class WrapGen extends ClassAdapter
    1918{
     
    6968                        newArgTypes[newArgTypes.length-1] = Type.getType("Lorg/refal/plus/Result;");
    7069                String newDesc = Type.getMethodDescriptor(Type.VOID_TYPE, newArgTypes);
    71                 MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC+Opcodes.ACC_STATIC, name, newDesc, signature, new String[] {"org/refal/plus/RefalException"});
     70                MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC+Opcodes.ACC_STATIC, refFun.name, newDesc, signature, new String[] {"org/refal/plus/RefalException"});
    7271
    7372                mv.visitCode();
     
    9493                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "org/refal/plus/Result", "assign", "(Ljava/lang/Object;)V");
    9594                        break;
    96                 //case WrapGen.E:
    97                 //      mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "org/refal/plus/Result", "assign", "([Ljava/lang/Object;)V");
    98                 //      break;
     95                case WrapGen.E:
     96                //TODO
     97                        //mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "org/refal/plus/Result", "assign", "([Ljava/lang/Object;)V");
     98                        break;
    9999                }
    100100        }
     
    104104                case Type.BOOLEAN:
    105105                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "org/refal/plus/Word", "valueOf", "(B)Lorg/refal/plus/Word;");
    106                         mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Object");
    107106                        break;
    108107                case Type.CHAR:
    109108                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/math/Character", "charValue", "(C)Ljava/math/Character;");
    110109                        break;
     110                case Type.BYTE:
     111                case Type.SHORT:
    111112                case Type.INT:
    112113                        mv.visitInsn(Opcodes.I2L);
    113                         mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/math/BigInteger", "valueOf", "(J)Ljava/math/BigInteger;");
    114                         break;
    115114                case Type.LONG:
    116115                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/math/BigInteger", "valueOf", "(J)Ljava/math/BigInteger;");
     
    118117                default:
    119118                        if (type.equals(Type.getType("Ljava/lang/String;")))
    120                         {
    121119                                mv.visitMethodInsn(Opcodes.INVOKESTATIC, "org/refal/plus/Word", "valueOf", "(Ljava/lang/String;)Lorg/refal/plus/Word;");
    122                                 mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Object");
    123                         }
    124                         else
    125                                 mv.visitTypeInsn(Opcodes.CHECKCAST, type.getSort()==Type.ARRAY?type.getDescriptor():type.getInternalName());
    126                         break;
    127                 }
    128 
     120                        break;
     121                }
     122                mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Object"); // TODO: It is not needed.
    129123        }
    130124
     
    180174                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "org/refal/plus/Word", "boolValue", "()B");
    181175                        break;
    182                 case Type.BYTE:
    183                         mv.visitTypeInsn(Opcodes.CHECKCAST, "java/math/BigInteger");
    184                         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/math/BigInteger", "byteValue", "()B");
    185                         break;
    186176                case Type.CHAR:
    187177                        mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Character");
    188178                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Character", "charValue", "()C");
     179                        break;
     180                case Type.BYTE:
     181                        mv.visitTypeInsn(Opcodes.CHECKCAST, "java/math/BigInteger");
     182                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/math/BigInteger", "byteValue", "()B");
    189183                        break;
    190184                case Type.SHORT:
     
    223217        }
    224218
     219        public byte TEST2 (byte x) {
     220                return x;
     221        }
     222
    225223        public String[] TEST2 (int[][] x) {
    226                 return null;
     224                long z = TEST2((byte)1);
     225                if (z==0)
     226                        return null;
     227                else
     228                        return null;
    227229        }
    228230
Note: See TracChangeset for help on using the changeset viewer.