=================================================================== RCS file: /home/cvs/OpenXM/src/OpenMath/OMproxy.java,v retrieving revision 1.1.1.1 retrieving revision 1.40 diff -u -p -r1.1.1.1 -r1.40 --- OpenXM/src/OpenMath/OMproxy.java 1999/11/02 11:52:34 1.1.1.1 +++ OpenXM/src/OpenMath/OMproxy.java 2000/09/13 06:44:55 1.40 @@ -1,43 +1,61 @@ -import JP.ac.kobe_u.math.tam.OpenXM.*; +/** + * $OpenXM: OpenXM/src/OpenMath/OMproxy.java,v 1.39 2000/07/03 05:57:43 tam Exp $ + */ + +import ORG.openxm.tam.*; import java.util.Stack; import java.io.*; -class OMproxy implements Runnable{ - private OpenXM ox; +public class OMproxy extends OpenXMserver{ private Stack stack = new Stack(); + protected boolean debug = false; + final int version = 200006130; - public OMproxy(String host,int ControlPort,int DataPort) throws IOException{ - ox = new OpenXM(this,host,ControlPort,DataPort); + public OMproxy(String hostname,int ControlPort,int DataPort){ + super(hostname,ControlPort,DataPort); } - public void run(){ + public void computeProcess(OpenXMstream stream){ OM2OXM P = new OM2OXM(); + debug("OMproxy started."); try{ while(true){ - synchronized(ox){ - int ox_tag = ox.receiveOXtag(); + try{ + OXmessage message = stream.receive(); + int ox_tag = message.getTag(); switch(ox_tag){ - case OpenXM.OX_COMMAND: - StackMachine(ox.receiveSM()); + case OXmessage.OX_COMMAND: + StackMachine((SM)message.getBody(),stream); break; - case OpenXM.OX_DATA: - stack.push(ox.receiveCMO()); - System.out.println("push: "+ stack.peek()); + case OXmessage.OX_DATA: + stack.push(message.getBody()); + debug("push: "+ stack.peek()); break; } + }catch(RuntimeException e){ + System.err.println(e.getMessage()); + e.printStackTrace(); + debug("error occured. stack was cleared."); + stack = new Stack(); } } - }catch(java.io.IOException e){ + }catch(IOException e){ System.err.println(e.getMessage()); e.printStackTrace(); + System.err.println("error occured, and recovering processes seems to be impossible."); + }catch(Exception e){ + System.err.println(e.getMessage()); + e.printStackTrace(); + System.err.println("error occured, and recovering processes seems to be impossible."); + }finally{ + System.out.println("breaking..."); } - - System.out.println("breaking..."); } + /* public void stop(){ System.out.println("OMproxy Stoping..."); synchronized(ox){ @@ -48,12 +66,22 @@ class OMproxy implements Runnable{ System.out.println("OMproxy Stopped"); } } + */ - private void SM_popCMO() throws java.io.IOException{ - if(stack.empty()){ - ox.send(new CMO_NULL()); - }else{ - ox.send(stack.pop()); + private void SM_popCMO(OpenXMstream stream) throws java.io.IOException{ + try{ + if(stack.empty()){ + stream.send(new CMO_NULL()); + }else{ + debug("sending CMO: "+ stack.peek()); + stream.send((CMO)stack.pop()); + debug("test"); + } + }catch(MathcapViolation e){ + try{ + stream.send(new CMO_ERROR2(new CMO_STRING("MathcapViolation: "+ + e.getMessage()))); + }catch(MathcapViolation tmp){} } } @@ -63,7 +91,7 @@ class OMproxy implements Runnable{ int argc; if(!(stack.peek() instanceof CMO_STRING)){ - stack.push(new CMO_ERROR2()); + stack.push(new CMO_ERROR2(new CMO_NULL())); return; } function_name = ((CMO_STRING)stack.pop()).getString(); @@ -74,7 +102,7 @@ class OMproxy implements Runnable{ } if(argc != 1){ - stack.push(new CMO_ERROR2()); + stack.push(new CMO_ERROR2(new CMO_NULL())); return; } @@ -86,28 +114,105 @@ class OMproxy implements Runnable{ return; } - stack.push(new CMO_ERROR2()); + stack.push(new CMO_ERROR2(new CMO_NULL())); return; } - private void StackMachine(SM mesg) throws java.io.IOException{ + private void SM_mathcap(OpenXMstream stream) throws java.io.IOException{ + CMO[] mathcap = new CMO[3]; + + { + CMO[] list = {new CMO_INT32(version), + new CMO_STRING("Ox_system=OMproxy.class"), + new CMO_STRING("Version=0."+ version), + new CMO_STRING("HOSTTYPE=JAVA")}; + mathcap[0] = new CMO_LIST(list); + } + + { + CMO[] list = {new CMO_INT32(SM.SM_popCMO), + new CMO_INT32(SM.SM_executeFunction), + new CMO_INT32(SM.SM_mathcap), + new CMO_INT32(SM.SM_setMathCap), + new CMO_INT32(SM.SM_control_kill), + new CMO_INT32(SM.SM_control_reset_connection)}; + mathcap[1] = new CMO_LIST(list); + } + + { + CMO[] CMOFormat = {new CMO_INT32(CMO.NULL), + new CMO_INT32(CMO.INT32), + new CMO_INT32(CMO.STRING), + new CMO_INT32(CMO.LIST), + new CMO_INT32(CMO.MONOMIAL32), + new CMO_INT32(CMO.ZZ), + new CMO_INT32(CMO.QQ), + new CMO_INT32(CMO.ZERO), + new CMO_INT32(CMO.DMS_GENERIC), + new CMO_INT32(CMO.RECURSIVE_POLYNOMIAL), + new CMO_INT32(CMO.DISTRIBUTED_POLYNOMIAL), + new CMO_INT32(CMO.POLYNOMIAL_IN_ONE_VARIABLE), + new CMO_INT32(CMO.BIGFLOAT), + new CMO_INT32(CMO.INDETERMINATE), + new CMO_INT32(CMO.TREE)}; + CMO[] DataFormat1 = {new CMO_INT32(OXmessage.OX_DATA), + new CMO_LIST(CMOFormat)}; + CMO[] list = {new CMO_LIST(DataFormat1)}; + + mathcap[2] = new CMO_LIST(list); + } + + stack = new Stack(); + stack.push(new CMO_MATHCAP(new CMO_LIST(mathcap))); + debug("push: "+ stack.peek()); + } + + private void SM_setMathCap(OpenXMstream stream) + throws java.io.IOException{ + Object mathcap = stack.pop(); + + if(mathcap instanceof CMO_MATHCAP){ + stack.push(new CMO_ERROR2(new CMO_NULL())); + } + stream.setMathCap((CMO_MATHCAP)mathcap); + } + + private void StackMachine(SM mesg,OpenXMstream stream) + throws java.io.IOException{ + debug("receive: "+mesg); + switch(mesg.getCode()){ case SM.SM_popCMO: - SM_popCMO(); + SM_popCMO(stream); break; case SM.SM_executeFunction: SM_executeFunction(); break; + case SM.SM_mathcap: + SM_mathcap(stream); + break; + + case SM.SM_setMathCap: + SM_setMathCap(stream); + break; + default: System.out.println("received "+ mesg); } } private CMO CMO2OMXML(CMO obj){ - String str = OM2OXM.CMO2OM(obj); + String str; + try{ + str = OM2OXM.CMO2OM(obj); + }catch(NumberFormatException e){ + debug("CMO2OMXML occuered error in trans"); + return new CMO_ERROR2(new CMO_STRING(e.toString())); + } + return new CMO_STRING(str); } @@ -117,49 +222,86 @@ class OMproxy implements Runnable{ ByteArrayInputStream stream; CMO ret; - if(obj instanceof CMO_STRING){ - return new CMO_ERROR2(); + debug("OMXML2CMO called: "+obj); + if(!(obj instanceof CMO_STRING)){ + return new CMO_ERROR2(new CMO_STRING("It's not CMO_STRING.")); } try{ stream = new ByteArrayInputStream(((CMO_STRING)obj).getString().getBytes()); ret = trans.parse(stream); }catch(IOException e){ + debug("OMXML2CMO occuered error in trans"); return new CMO_ERROR2(new CMO_STRING(e.toString())); + }catch(NumberFormatException e){ + debug("OMXML2CMO occuered error in trans"); + return new CMO_ERROR2(new CMO_STRING(e.toString())); } + debug("push: "+ret); return ret; } - public static void main(String argv[]){ - String host = "localhost"; - int DataPort = 1300, ControlPort = 1200; + private void debug(String str){ + if(debug){ + System.err.println(str); + } + } + private static String usage(){ + String ret = ""; + + ret += "usage\t: java OMproxy [options]\n"; + ret += "options\t:\n"; + ret += "\t -h \t show this message\n"; + ret += "\t -host hostname \t (default localhost)\n"; + ret += "\t -data port \t (default 1300)\n"; + ret += "\t -control port \t (default 1200)\n"; + ret += "\t -insecure \t this version ignore this option\n"; + ret += "\t -debug \t display debug messages\n"; + + return ret; + } + + public static void main(String[] argv){ + String hostname = "localhost"; + int ControlPort = 1200, DataPort = 1300; + OpenXMserver ox; + for(int i=0;i