Changeset 2305


Ignore:
Timestamp:
Feb 1, 2007, 7:54:37 PM (14 years ago)
Author:
yura
Message:
  • Minor changes
  • Corrected EOL in rfi-files
  • Class files in wrappers are added
Location:
to-imperative/trunk/java/org/refal/plus
Files:
3 added
2 edited

Legend:

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

    r2296 r2305  
    11package org.refal.plus.wrapgen;
    22
     3import java.io.BufferedReader;
    34import java.io.File;
    4 import java.io.FileInputStream;
    55import java.io.FileOutputStream;
     6import java.io.FileReader;
     7import java.io.PrintStream;
    68import java.util.ArrayList;
    79import java.util.HashMap;
     
    1012
    1113class RFIFile {
    12         private String fileName;
    13         private FileOutputStream out;
     14        private String className;
     15        private PrintStream out;
    1416        private ArrayList refalNames;
    1517        private HashMap refalFunctions;
     
    1921                int retType;
    2022                int[] argTypes;
    21                
     23
    2224                public String toString () {
    2325                        String str = "$func \""+this.name+"\"";
    2426                        for (int i = 0; i < argTypes.length; i++)
    25                                 switch (argTypes[i]) {
     27                                switch (this.argTypes[i]) {
    2628                                case WrapGen.S: str += " s"; break;
    2729                                case WrapGen.E: str += " (e)"; break;
    2830                                }
    2931                        str += " = ";
    30                         switch (retType) {
     32                        switch (this.retType) {
    3133                        case WrapGen.S: str += "s"; break;
    3234                        case WrapGen.E: str += "e"; break;
     
    3739        }
    3840       
    39         static private String getJavaDeclaration (boolean isStatic, String name, Type retType, Type[] argTypes) {
     41        RFIFile (String className) {
     42                this.className = className;
     43                this.out = null;
     44                this.refalNames = new ArrayList();
     45                this.refalFunctions = new HashMap();
     46                try {
     47                        (new File(this.className.substring(0, this.className.lastIndexOf('/')))).mkdirs();
     48                        File file = new File(this.className+".rfi");
     49                        if (file.exists())
     50                                readRFIFile(file);
     51                        else
     52                                this.out = new PrintStream(file);
     53                } catch (Exception e) {}
     54        }
     55       
     56        RefalFunction getRefalFuncion (boolean isStatic, String name, Type retType, Type[] argTypes) {
     57                try {
     58                        if (this.out != null) {
     59                                RefalFunction refFun = getRefalFunction(isStatic, name, retType, argTypes);
     60                                this.out.println(refFun+" // "+getJavaDeclaration(isStatic, name, retType, argTypes));
     61                                return refFun;
     62                        } else
     63                                return findRefalFunction(isStatic, name, retType, argTypes);
     64                } catch (Exception e) {
     65                        return null;
     66                }
     67        }
     68       
     69        String getRefalConst (String name, int value) {
     70                String intName = "int "+name;
     71                try {
     72                        if (this.out != null) {
     73                                if (this.refalNames.indexOf(name)!=-1)
     74                                        for(int i = 1; ; i++)
     75                                                if (this.refalNames.indexOf(name+i)==-1)
     76                                                {
     77                                                        name += i;
     78                                                        break;
     79                                                }
     80                                this.refalNames.add(name);
     81                                this.out.println("$const \""+name+"\" = "+value+"; // "+intName);
     82                                return name;
     83                        } else {
     84                                return (String)this.refalFunctions.get(intName);
     85                        }
     86                } catch (Exception e) {
     87                        return null;
     88                }
     89        }
     90       
     91        void writeClass (byte[] bytes) {
     92                try {
     93                        (new FileOutputStream(this.className+".class")).write(bytes);
     94                } catch (Exception e) {}
     95        }
     96
     97                static private String getJavaDeclaration (boolean isStatic, String name, Type retType, Type[] argTypes) {
    4098                String str = "";
    4199                if (isStatic)
     
    48106        }
    49107       
    50         private RefalFunction getDefaultRefalFunction (boolean isStatic, String name, Type retType, Type[] argTypes) {
     108        private RefalFunction getRefalFunction (boolean isStatic, String name, Type retType, Type[] argTypes) {
    51109                RefalFunction refFun = new RefalFunction();
    52110                if (this.refalNames.indexOf(name)!=-1)
     
    59117                this.refalNames.add(name);
    60118                refFun.name = name;
    61                 int x = retType.getSort();
    62                 switch (x) {
     119                switch (retType.getSort()) {
    63120                case Type.VOID: refFun.retType = WrapGen.Void; break;
    64121                case Type.ARRAY: refFun.retType = WrapGen.E; break;
     
    73130        }
    74131       
    75         private void readRFIFile (FileInputStream in) throws Exception {
    76                 byte[] file = new byte[1024*1024];
    77                 int z = in.read(file);
    78                 String str = new String(file, 0, z);
    79                 while (str.length() != 0) {
    80                         int i1 = str.indexOf("$func");
    81                         int i2 = str.indexOf("$const");
    82                         if ((i1<i2 || i2==-1) && i1!=-1) {
    83                                 int i = i1;
    84                                 for (i += 5; ;i++)
    85                                         if (str.charAt(i)!=' ')
    86                                                 break;
    87                                 int j;
     132        private RefalFunction findRefalFunction  (boolean isStatic, String name, Type retType, Type[] argTypes) {
     133                return (RefalFunction)this.refalFunctions.get(getJavaDeclaration(isStatic, name, retType, argTypes));
     134        }
     135
     136        private void readRFIFile (File file) throws Exception {
     137                BufferedReader in = new BufferedReader(new FileReader(file));
     138                for (String str = in.readLine(); str != null; str = in.readLine()) {
     139                        str = str.replaceFirst("^ *", "");
     140                        if (str.startsWith("$func")) {
     141                                str = str.replaceFirst("^.func *", "");
    88142                                String name;
    89                                 if (str.charAt(i)=='\"')
    90                                 {
    91                                         j = str.indexOf('\"', i+1);
    92                                         name = str.substring(i+1,j);
    93                                         j++;                           
    94                                 }
    95                                 else
    96                                 {
    97                                         j = str.indexOf(' ', i+1);
    98                                         name = str.substring(i,j);
     143                                if (str.charAt(0)=='\"') {
     144                                        int i = str.indexOf('\"', 1);
     145                                        name = str.substring(1,i);
     146                                        str = str.substring(i+1);
     147                                } else {
     148                                        int i = str.indexOf(' ');
     149                                        name = str.substring(0,i);
     150                                        str = str.substring(i);
    99151                                }
    100152                                int[] argTypes = new int[1024];
    101                                 int retType = 0;
    102                                 int l = 0;
     153                                int argCount = 0;
     154                                int i = 0;
    103155                                boolean flag = true;
    104                                 for (;flag;j++) {
    105                                         switch (str.charAt(j)) {
    106                                         case 'e': argTypes[l] = WrapGen.E; l++; break;
    107                                         case 's': argTypes[l] = WrapGen.S; l++; break;
     156                                for ( ; flag; i++)
     157                                        switch (str.charAt(i)) {
     158                                        case 'e': argTypes[argCount] = WrapGen.E; argCount++; break;
     159                                        case 's': argTypes[argCount] = WrapGen.S; argCount++; break;
    108160                                        case '=': flag = false; break;
    109161                                        default: break;
    110162                                        }
    111                                 }
     163                                int retType = WrapGen.Void;
    112164                                flag = true;
    113                                 for (;flag;j++) {
    114                                         switch (str.charAt(j)) {
     165                                for ( ; flag; i++)
     166                                        switch (str.charAt(i)) {
    115167                                        case 'e': retType = WrapGen.E; flag = false; break;
    116168                                        case 's': retType = WrapGen.S; flag = false; break;
     
    118170                                        default: break;
    119171                                        }
    120                                 }
    121                                 int m = str.indexOf("//", j);
    122                                 for (m += 2; str.charAt(m)==' ';m++);
    123                                 int n = str.indexOf('\n', m);
    124                                 String javaDesc = str.substring(m,n);
    125                                 str = str.substring(n);
     172                                String javaDesc = str.replaceFirst("^.*// *", "");
    126173                               
    127174                                RefalFunction refFun = new RefalFunction();
    128175                                refFun.name = name;
    129176                                refFun.retType = retType;
    130                                 refFun.argTypes = new int[l];
    131                                 for (int ii = 0; ii < l; ii++)
    132                                         refFun.argTypes[ii] = argTypes[ii];
    133                                
     177                                refFun.argTypes = new int[argCount];
     178                                for (i = 0; i < argCount; i++)
     179                                        refFun.argTypes[i] = argTypes[i];
    134180                                this.refalFunctions.put(javaDesc, refFun);
    135                         } else if (i2 != -1) {
    136                                 int i = i2;
    137                                 for (i += 6; ;i++)
    138                                         if (str.charAt(i)!=' ')
    139                                                 break;
    140                                 int j;
     181                        } else if (str.startsWith("$const")) {
     182                                str = str.replaceFirst("^.const *", "");
    141183                                String name;
    142                                 if (str.charAt(i)=='\"')
    143                                 {
    144                                         j = str.indexOf('\"', i+1);
    145                                         name = str.substring(i+1,j);
    146                                         j++;                           
     184                                if (str.charAt(0)=='\"') {
     185                                        int i = str.indexOf('\"', 1);
     186                                        name = str.substring(1,i);
     187                                        str = str.substring(i+1);
     188                                } else {
     189                                        int i = str.indexOf(' ');
     190                                        name = str.substring(0,i);
     191                                        str = str.substring(i);
    147192                                }
    148                                 else
    149                                 {
    150                                         j = str.indexOf(' ', i+1);
    151                                         name = str.substring(i,j);
    152                                 }
    153                                 int m = str.indexOf("//", j);
    154                                 for (m += 2; str.charAt(m)==' ';m++);
    155                                 int n = str.indexOf('\n', m);
    156                                 String javaDesc = str.substring(m,n);
    157                                 str = str.substring(n);
    158                                
     193                                String javaDesc = str.replaceFirst("^.*// *", "");
    159194                                this.refalFunctions.put(javaDesc, name);
    160                         } else
    161                                 break;
     195                        }
    162196                }
    163         }
    164        
    165         private RefalFunction findRefalFunction  (boolean isStatic, String name, Type retType, Type[] argTypes) {
    166                 return (RefalFunction)this.refalFunctions.get(getJavaDeclaration(isStatic, name, retType, argTypes));
    167         }
    168        
    169         RFIFile (String fileName) {
    170                 this.fileName = fileName;
    171                 this.out = null;
    172                 this.refalNames = new ArrayList();
    173                 this.refalFunctions = new HashMap();
    174                 try {
    175                         File file = new File(this.fileName);
    176                         if (file.exists())
    177                                 readRFIFile(new FileInputStream(this.fileName));
    178                         else
    179                                 this.out = new FileOutputStream(this.fileName);
    180                 } catch (Exception e) {
    181                 }
    182         }
    183        
    184         RefalFunction getRefalFuncion (boolean isStatic, String name, Type retType, Type[] argTypes) {
    185                 try {
    186                         if (out != null) {
    187                                 RefalFunction refFun = getDefaultRefalFunction(isStatic, name, retType, argTypes);
    188                                 out.write((refFun+" // "+getJavaDeclaration(isStatic, name, retType, argTypes)+"\n").getBytes());
    189                                 return refFun;
    190                         } else
    191                                 return findRefalFunction(isStatic, name, retType, argTypes);
    192                 } catch (Exception e) {
    193                         return null;
    194                 }
    195         }
    196        
    197         String getRefalConst (String name, int value) {
    198                 String name1 = "int "+name;
    199                 try {
    200                         if (out != null) {
    201                                 if (this.refalNames.indexOf(name)!=-1)
    202                                         for(int i = 1; ; i++)
    203                                                 if (this.refalNames.indexOf(name+i)==-1)
    204                                                 {
    205                                                         name = name+i;
    206                                                         break;
    207                                                 }
    208                                 this.refalNames.add(name1);
    209                                 out.write(("$const \""+name+"\" = "+value+"; // "+name1+"\n").getBytes());
    210                         } else {
    211                                 return (String)this.refalFunctions.get(name1);
    212                         }
    213                 } catch (Exception e) {
    214                         return null;
    215                 }
    216                 return name;
    217         }
     197        }       
    218198}
  • to-imperative/trunk/java/org/refal/plus/wrapgen/WrapGen.java

    r2299 r2305  
    11package org.refal.plus.wrapgen;
    22
    3 import java.io.File;
    4 import java.io.FileInputStream;
    5 import java.io.FileOutputStream;
    6 import java.math.BigInteger;
    73import java.util.HashMap;
    84import java.util.Iterator;
    95
     6import org.objectweb.asm.AnnotationVisitor;
     7import org.objectweb.asm.Attribute;
    108import org.objectweb.asm.ClassAdapter;
    119import org.objectweb.asm.ClassReader;
    12 import org.objectweb.asm.ClassVisitor;
    1310import org.objectweb.asm.ClassWriter;
    1411import org.objectweb.asm.FieldVisitor;
     
    2017public class WrapGen extends ClassAdapter
    2118{
    22         public static final BigInteger S1 = BigInteger.valueOf(1);
    23         public static final int S = 0;
    24         public static final int E = 1;
    25         public static final int Void = -1;
    26 
     19        static final int S = 0;
     20        static final int E = 1;
     21        static final int Void = -1;
     22
     23        private String oldName;
    2724        private Type oldType;
    28         private String oldName;
    2925        private String newName;
     26        private boolean isInterface;
     27        private HashMap constants;
    3028        private RFIFile rfiFile;
    31         private HashMap constants;
    32         private boolean isInterface;
    33 
    34         public WrapGen (ClassVisitor cv) {
    35                 super(cv);
    36                 constants = new HashMap();
     29
     30        public WrapGen () {
     31                super(new ClassWriter(ClassWriter.COMPUTE_FRAMES+ClassWriter.COMPUTE_MAXS));
    3732        }
    3833
     
    4136                this.oldType = Type.getType("L"+name+";");
    4237                this.newName = "org/refal/plus/wrappers/"+this.oldName;
    43                 this.isInterface = (access&Opcodes.ACC_INTERFACE)!=0;
    44 
    45                 (new File(this.newName.substring(0, this.newName.lastIndexOf('/')))).mkdirs();
    46                 this.rfiFile = new RFIFile(this.newName+".rfi");
    47 
     38                this.isInterface = (access & Opcodes.ACC_INTERFACE)!=0;
     39                this.constants = new HashMap();
     40                this.rfiFile = new RFIFile(this.newName);
    4841                super.visit(version, access, this.newName, signature, this.oldName, null);
    4942        }
    5043
    51         public void visitSource (String file, String debug) {
    52                 super.visitSource(null, null);
    53         }
     44        public void visitSource (String file, String debug) {}
     45
     46        public void visitOuterClass (String owner, String name, String desc) {}
     47       
     48        public AnnotationVisitor visitAnnotation (String desc, boolean visible) {
     49                return null;
     50        }
     51
     52        public void visitAttribute (Attribute attr) {}
     53       
     54        public void visitInnerClass (String name, String outerName, String innerName, int access) {}
    5455
    5556        public FieldVisitor visitField (int access, String name, String desc, String signature, Object value) {
    56                 if ((access & Opcodes.ACC_PUBLIC)==0 || (access & Opcodes.ACC_STATIC)==0 || !desc.equals("I"))
    57                         return null;
    58                 String refConst = this.rfiFile.getRefalConst(name, ((Integer)value).intValue());
    59                 if (refConst != null) {
    60                         FieldVisitor fv = super.visitField(access, refConst, "Lorg/refal/plus/Expr;", signature, null);
    61                         constants.put(refConst, value);
    62                         fv.visitEnd();
    63                 }
     57                if ((access == Opcodes.ACC_PUBLIC+Opcodes.ACC_STATIC+Opcodes.ACC_FINAL) && desc.equals("I")) {
     58                        String refName = this.rfiFile.getRefalConst(name, ((Integer)value).intValue());
     59                        if (refName != null) {
     60                                FieldVisitor fv = super.visitField(access, refName, "Lorg/refal/plus/Expr;", signature, null);
     61                                constants.put(refName, value);
     62                                fv.visitEnd();
     63                }       }
    6464                return null;
    6565        }
     
    7474                boolean isStatic = (access & Opcodes.ACC_STATIC)!=0;
    7575                boolean isVoid = retType==Type.VOID_TYPE;
    76 
    77                 RFIFile.RefalFunction refFun;
    78                 if (isConstructor)
    79                 {
     76                RFIFile.RefalFunction   refFun;
     77                if (isConstructor) {
    8078                        retType = this.oldType;
    8179                        isStatic = true;
    8280                        isVoid = false;
    8381                        refFun = this.rfiFile.getRefalFuncion(isStatic, this.oldName.replaceAll(".*/", ""), retType, argTypes);
    84                 }
    85                 else
     82                } else
    8683                        refFun = this.rfiFile.getRefalFuncion(isStatic, name, retType, argTypes);
    8784                if (refFun == null)
     
    9592                String newDesc = Type.getMethodDescriptor(Type.VOID_TYPE, newArgTypes);
    9693                MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC+Opcodes.ACC_STATIC, refFun.name, newDesc, signature, new String[] {"org/refal/plus/RefalException"});
    97 
    9894                mv.visitCode();
    9995                if (isConstructor) {
     
    10197                        mv.visitInsn(Opcodes.DUP);
    10298                } else if (! isStatic)
    103                         putArgToStack(mv, this.oldType, refFun.argTypes[0], 0);
     99                        putArgToStack(mv, this.oldType, refFun.argTypes, 0);
    104100                for (int i = 0; i < argTypes.length; i++)
    105                         putArgToStack(mv, argTypes[i], refFun.argTypes[(isStatic?0:1)+i], (isStatic?0:1)+i);
    106                 mv.visitMethodInsn(isConstructor?Opcodes.INVOKESPECIAL:(isStatic?Opcodes.INVOKESTATIC:(this.isInterface?Opcodes.INVOKEINTERFACE:Opcodes.INVOKEVIRTUAL)), this.oldName, name, desc);
     101                        putArgToStack(mv, argTypes[i], refFun.argTypes, (isStatic?0:1)+i);
     102                mv.visitMethodInsn(isConstructor ? Opcodes.INVOKESPECIAL : (isStatic ? Opcodes.INVOKESTATIC : (this.isInterface ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL)), this.oldName, name, desc);
    107103                if (! isVoid)
    108104                        getResFromStack(mv, retType, refFun.retType, refFun.argTypes.length);
     
    110106                mv.visitMaxs(0,0);
    111107                mv.visitEnd();
    112 
    113108                return null;
    114109        }
    115110
    116111        public void visitEnd() {
    117                 MethodVisitor mv = super.visitMethod(Opcodes.ACC_STATIC, "<clinit>", "()V", null, null);
    118                 Iterator it = constants.keySet().iterator();
    119                 mv.visitCode();
    120                 while (it.hasNext()) {
    121                         String name = (String)it.next();
    122                         mv.visitTypeInsn(Opcodes.NEW, "org/refal/plus/Expr");
    123                         mv.visitInsn(Opcodes.DUP);
    124                         mv.visitLdcInsn(constants.get(name));
    125                         mv.visitInsn(Opcodes.I2L);
    126                         mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/math/BigInteger", "valueOf", "(J)Ljava/math/BigInteger;");
    127                         mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Object"); // TODO: It is not needed.
    128                         mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "org/refal/plus/Expr", "<init>", "(Ljava/lang/Object;)V");
    129                         mv.visitFieldInsn(Opcodes.PUTSTATIC, this.newName, name, "Lorg/refal/plus/Expr;");
    130                 }
    131                 mv.visitInsn(Opcodes.RETURN);
    132                 mv.visitMaxs(0,0);
    133                 mv.visitEnd();
    134 
     112                if (! this.constants.isEmpty()) {
     113                        MethodVisitor mv = super.visitMethod(Opcodes.ACC_STATIC, "<clinit>", "()V", null, null);
     114                        mv.visitCode();
     115                        for (Iterator it = this.constants.keySet().iterator(); it.hasNext(); ) {
     116                                String name = (String)it.next();
     117                                mv.visitTypeInsn(Opcodes.NEW, "org/refal/plus/Expr");
     118                                mv.visitInsn(Opcodes.DUP);
     119                                mv.visitLdcInsn(this.constants.get(name));
     120                                mv.visitInsn(Opcodes.I2L);
     121                                mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/math/BigInteger", "valueOf", "(J)Ljava/math/BigInteger;");
     122                                mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/Object"); // TODO: It is not needed.
     123                                mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "org/refal/plus/Expr", "<init>", "(Ljava/lang/Object;)V");
     124                                mv.visitFieldInsn(Opcodes.PUTSTATIC, this.newName, name, "Lorg/refal/plus/Expr;");
     125                        }
     126                        mv.visitInsn(Opcodes.RETURN);
     127                        mv.visitMaxs(0,0);
     128                        mv.visitEnd();
     129                }
    135130                super.visitEnd();
     131                this.rfiFile.writeClass(((ClassWriter)this.cv).toByteArray());
    136132        }
    137133
     
    203199        }
    204200
    205         private void putArgToStack (MethodVisitor mv, Type type, int refType, int argNum) {
     201        private void putArgToStack (MethodVisitor mv, Type type, int[] refTypes, int argNum) {
    206202                mv.visitVarInsn(Opcodes.ALOAD, argNum);
    207                 switch (refType) {
     203                switch (refTypes[argNum]) {
    208204                case WrapGen.S:
    209205                        mv.visitInsn(Opcodes.ICONST_0);
     
    293289
    294290        public static void main (String[] args) throws Exception {
    295                 for (int i = 0; i < args.length; i++) {
    296                         ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES+ClassWriter.COMPUTE_MAXS);
    297                         WrapGen wg = new WrapGen(cw);
    298                         (new ClassReader(new FileInputStream(args[i]))).accept(wg, 0);
    299                         (new FileOutputStream(wg.newName+".class")).write(cw.toByteArray());
    300                 }
    301         }
    302 
    303         public String TEST1 (String[][] x) {
    304                 return "";
    305         }
    306 
    307         public byte TEST2 (byte x) {
    308                 return x;
    309         }
    310 
    311         public String[] TEST2 (int[][] x) {
    312                 long z = TEST2((byte)1);
    313                 if (z==0)
    314                         return null;
    315                 else
    316                         return null;
    317         }
    318 
    319         public int[] TEST2 (int[] x) {
    320                 return x;
    321         }
    322 
    323         public static Integer TEST3 (int[] x) {
    324                 int res = 0;
    325                 for(int i = 0; i < x.length; i++)
    326                         res += x[i];
    327                 return new Integer(res);
    328         }
    329 
    330         public static int TEST4 (int[] x) {
    331                 int res = 0;
    332                 for(int i = 0; i < x.length; i++)
    333                         res += x[i];
    334                 return res;
    335         }
    336        
    337         public static boolean TEST1 (boolean x) {
    338                 return x;
    339         }
    340 
    341         public static int TEST1 (int x) {
    342                 return x;
     291                for (int i = 0; i < args.length; i++)
     292                        (new ClassReader(args[i])).accept(new WrapGen(), 0);
    343293        }
    344294}
Note: See TracChangeset for help on using the changeset viewer.