sync/ports
1
0
Fork 0
mirror of https://git.freebsd.org/ports.git synced 2025-07-18 17:59:20 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

comms/rxtx: mutiple fixes

Browse source 
Makefile
1) Missing dependancy on plibthread.so.1

Java code base
2) Added commandline debug output in multiple Java files

3) Tided comment statements, tabulation and white space to aid reading
of sections of the original source code

4) Added additional debug statements to aid diagnosis in multiple Java
files

5) Moved error logging from Zystem to be local in the RXTXPort.java
file (was never firing from Zystem); now common with rest of codebase

6) Ensured that RXTX only outputs debug level information when
requested.

7) Only enumerate the local ports on initialisation once (use of
init_clean), rather than three times.

8) Updated ports lists to reflect current usage pre FreeBSD v10 and post
v10.

9) Debug identifier inserted before all calls

10) correctly read the properties file when there are multiple java
library paths

11) Enabled the skipping of parrellel ports during scans where they are
not used by the invoking java parent base to RXTX (Still allows them to
be manually specified in gn.io.parellel env arg)

SerialImp.c
12) Tidied code indentation (where needed, it is a medium length file
and doesn't provide benifit on areas that work)

13) Added standard out debug support to allow for assessment of
interaction with Java code that can be compiled in (DEBUG_STDOUT)

14) Added entry and exist debug statement for key functions

15) where sprintf is being used, ensure that the existing ptr refers to
an empty string (uses memset to sizeof)

16) cleared up display tabulation of function headers in entire file (on
second enumeration strings contained garbage)

17) Remove LEAVE and ENTRY functions as not working as expected in
header.

18) Made sure all debug statements are null pointer terminated (note
sprintf is not solely used for debug message formatting)

19) Added condition so that a port that is in use during testread() is
still reported as selectable. (If you attempt to open it after the port
scan and it is still EBUSY the behaviour is unaltered and will throw a
suitable error back)

20) Disabled uucp for lpt ports, as uucp only applies to tty on
FreeBSD (so says the Handbook...)

21) RXTXPort:interruptEventLoop - resolved SIGABRT call to
process (intended to kill off thread not entire JRE)...

22) RXTXPort:interruptEventLoop now waits for timer in child thread to
expire before attempting to closing the thread (delay between 0 and
1000000 sleeps)

23) All debug streams for FreeBSD now forward to same function for
uniform formatting.

This fixes two downstream issues in the arduino port, which results in
missing dependancies, a core dump when uploading, or very slow port
enumeration (up to 30s in some cases) when the arduino IDE is first
started.

PR:                  200179
Submitted by:        james@elstone.net
Approved by:         maintainer timeout (mirror176@cox.net ; 45 days)
This commit is contained in:
Philip M. Gollucci 2015-06-27 19:34:42 +00:00
parent cedefb8580
commit cf9286addd
Notes: svn2git 2021-03-31 03:12:20 +00:00 
svn path=/head/; revision=390725
12 changed files with 11692 additions and 18 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
comms/rxtx/Makefile
View file

@ -14,6 +14,8 @@ MAINTAINER= mirror176@cox.net
COMMENT= Native interface to serial ports in Java
USES= gmake libtool zip
USE_LINUX= c6
USE_JAVA= yes
JAVA_VERSION= 1.6+
JAVA_OS= native

8
comms/rxtx/files/patch-src-ParallelImp.c
View file

@ -1,8 +1,6 @@
$FreeBSD: /tmp/pcvs/ports/comms/rxtx/files/patch-src-ParallelImp.c,v 1.1 2011-09-17 14:55:56 pawel Exp $
--- src/ParallelImp.c.orig Fri Apr 9 23:31:09 2004
+++ src/ParallelImp.c Fri Apr 9 23:35:01 2004
@@ -222,9 +222,6 @@
--- src/ParallelImp.c.orig 2008-11-27 20:01:48.000000000 +0000
+++ src/ParallelImp.c 2015-05-11 16:52:36.000000000 +0100
@@ -265,9 +265,6 @@
#if defined(__linux__)
return( status & LP_BUSY ? JNI_TRUE : JNI_FALSE );
#endif

6145
comms/rxtx/files/patch-src-SerialImp.c Normal file
View file

File diff suppressed because it is too large Load diff

44
comms/rxtx/files/patch-src-gnu-io-CommPort.java Normal file
View file

@ -0,0 +1,44 @@
--- src/gnu/io/CommPort.java.orig 2007-04-26 06:26:05.000000000 +0100
+++ src/gnu/io/CommPort.java 2015-05-11 16:51:34.000000000 +0100
@@ -73,7 +73,7 @@
*/
public abstract class CommPort extends Object {
protected String name;
- private final static boolean debug = false;
+ private final static boolean debug = "true".equals( System.getProperty( "gnu.io.rxtx.DEBUG" ) );
public abstract void enableReceiveFraming( int f )
throws UnsupportedCommOperationException;
@@ -94,6 +94,7 @@
public abstract int getInputBufferSize();
public abstract void setOutputBufferSize( int size );
public abstract int getOutputBufferSize();
+
public void close()
{
if (debug) System.out.println("CommPort:close()");
@@ -102,12 +103,23 @@
{
CommPortIdentifier cp =
CommPortIdentifier.getPortIdentifier(this);
- if ( cp != null )
+
+ if (cp != null)
+ {
+
+ if (debug) System.out.println(" Not Null");
+
cp.getPortIdentifier(this).internalClosePort();
+
+ }
}
catch (NoSuchPortException e)
{
+ if (debug) System.out.println("CommPort:close(): No Such Port");
}
+
+ if (debug) System.out.println("CommPort:close:Exit");
+
};
public abstract InputStream getInputStream() throws IOException;

108
comms/rxtx/files/patch-src-gnu-io-CommPortEnumerator.java Normal file
View file

@ -0,0 +1,108 @@
--- src/gnu/io/CommPortEnumerator.java.orig 2007-04-26 06:26:05.000000000 +0100
+++ src/gnu/io/CommPortEnumerator.java 2015-05-11 16:51:34.000000000 +0100
@@ -69,50 +69,79 @@
class CommPortEnumerator implements Enumeration
{
private CommPortIdentifier index;
- private final static boolean debug = false;
+ private final static boolean debug = "true".equals( System.getProperty( "gnu.io.rxtx.DEBUG" ) );
static
{
- if (debug)
- System.out.println("CommPortEnumerator:{}");
+ if (debug) System.out.println("CommPortEnumerator:Static{}");
}
CommPortEnumerator()
{
}
-/*------------------------------------------------------------------------------
- nextElement()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
public Object nextElement()
{
- if(debug) System.out.println("CommPortEnumerator:nextElement()");
+ if (debug) System.out.println("CommPortEnumerator:nextElement()");
+
synchronized (CommPortIdentifier.Sync)
{
- if(index != null) index = index.next;
- else index=CommPortIdentifier.CommPortIndex;
+ if(index != null)
+ {
+ index = index.next;
+ }
+ else
+ {
+ index=CommPortIdentifier.CommPortIndex;
+ }
+ if (debug) System.out.println(" CommPortEnumerator:nextElement(" + index + ")");
return(index);
}
}
-/*------------------------------------------------------------------------------
- hasMoreElements()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
public boolean hasMoreElements()
{
- if(debug) System.out.println("CommPortEnumerator:hasMoreElements() " + CommPortIdentifier.CommPortIndex == null ? false : true );
+ if (debug) System.out.println("CommPortEnumerator:hasMoreElements()");
+
+ if (CommPortIdentifier.CommPortIndex == null)
+ {
+ if (debug) System.out.println(" ComPortIndex is null...");
+ }
+ else
+ {
+ if (debug) System.out.println(" ComPortIndex is not null...");
+ }
+
synchronized (CommPortIdentifier.Sync)
{
- if(index != null) return index.next == null ? false : true;
- else return CommPortIdentifier.CommPortIndex == null ?
- false : true;
+ if (debug) System.out.println(" Syncronised");
+ if(index != null)
+ {
+ if (debug) System.out.println(" Valid index");
+ if (index.next == null)
+ {
+ if (debug) System.out.println("CommPortEnumerator:hasMoreElements: Exit(Next index is null - false)");
+ return false;
+ }
+ else
+ {
+ if (debug) System.out.println("CommPortEnumerator:hasMoreElements: Exit(Next index is not null - true)");
+ return true;
+ }
+ }
+ else
+ {
+ if (debug) System.out.println(" Index is not valid");
+ if (CommPortIdentifier.CommPortIndex == null)
+ {
+ if (debug) System.out.println("CommPortEnumerator:hasMoreElements: Exit(CommPortIdentifier.CommPortIndex is null - false)");
+ return false;
+ }
+ else
+ {
+ if (debug) System.out.println("CommPortEnumerator:hasMoreElements: Exit(CommPortIdentifier.CommPortIndex is not null - true)");
+ return true;
+ }
+ }
}
}
}

850
comms/rxtx/files/patch-src-gnu-io-CommPortIdentifier.java Normal file
View file

@ -0,0 +1,850 @@
--- src/gnu/io/CommPortIdentifier.java.orig 2008-11-27 20:02:34.000000000 +0000
+++ src/gnu/io/CommPortIdentifier.java 2015-05-11 16:51:34.000000000 +0100
@@ -76,85 +76,138 @@
public static final int PORT_RS485 = 4; // rs485 Port
public static final int PORT_RAW = 5; // Raw Port
private String PortName;
- private boolean Available = true;
+ private static boolean init_clean = false;
+ private boolean Available = true;
private String Owner;
private CommPort commport;
private CommDriver RXTXDriver;
static CommPortIdentifier CommPortIndex;
CommPortIdentifier next;
private int PortType;
- private final static boolean debug = false;
+ private final static boolean debug = "true".equals( System.getProperty( "gnu.io.rxtx.DEBUG" ) );
static Object Sync;
Vector ownershipListener;
-/*------------------------------------------------------------------------------
- static {} aka initialization
- accept: -
- perform: load the rxtx driver
- return: -
- exceptions: Throwable
- comments: static block to initialize the class
-------------------------------------------------------------------------------*/
- // initialization only done once....
+ /**
+ * static {} aka initialization
+ * accept: -
+ * perform: load the rxtx driver
+ * return: -
+ * exceptions: Throwable
+ * comments: static block to initialize the class
+ *
+ * initialization only done once....
+ *
+ **/
+
static
{
- if(debug) System.out.println("CommPortIdentifier:static initialization()");
+ if(debug) System.out.println("CommPortIdentifier:Static()");
+
Sync = new Object();
try
{
+ if(debug) System.out.println(" Pre RXTXDriver.Loading New Class (Clean)");
+
+ init_clean = true;
+
CommDriver RXTXDriver = (CommDriver) Class.forName("gnu.io.RXTXCommDriver").newInstance();
+
+ if(debug) System.out.println(" Pre RXTXDriver.initialize()");
+
RXTXDriver.initialize();
+
+ if(debug) System.out.println(" Post RXTXDriver.initialize()");
+
}
catch (Throwable e)
{
- System.err.println(e + " thrown while loading " + "gnu.io.RXTXCommDriver");
+
+ if(debug) System.out.println(" " + e + " thrown while loading gnu.io.RXTXCommDriver");
+
+ System.err.println(e + " thrown while loading gnu.io.RXTXCommDriver");
+
+ init_clean = false;
+
}
String OS;
OS = System.getProperty("os.name");
+
+ if(debug) System.out.println(" The OS is " + OS);
+
if(OS.toLowerCase().indexOf("linux") == -1)
{
- if (debug)
- System.out.println("Have not implemented native_psmisc_report_owner(PortName)); in CommPortIdentifier");
+ if (debug)
+ {
+ System.out.println(" WARNING:");
+ System.out.println(" native_psmisc_System.out.println_owner(@)) not implemented");
+
+ /**
+ * Not Implemented:
+ *
+ * native_psmisc_System.out.println_owner(PortName)
+ * in CommPortIdentifier")
+ **/
+
+ }
}
+
+ if(debug) System.out.println(" Loading Library...");
+
System.loadLibrary( "rxtxSerial" );
- }
- CommPortIdentifier ( String pn, CommPort cp, int pt, CommDriver driver)
+
+ if(debug) System.out.println(" init_clean is " + init_clean);
+ if(debug) System.out.println("CommPortIdentifier:Static:Exit");
+
+ }
+ CommPortIdentifier
+ (
+ String pn,
+ CommPort cp,
+ int pt,
+ CommDriver driver
+ )
{
PortName = pn;
commport = cp;
PortType = pt;
next = null;
RXTXDriver = driver;
-
}
-/*------------------------------------------------------------------------------
- addPortName()
- accept: Name of the port s, Port type,
- reverence to RXTXCommDriver.
- perform: place a new CommPortIdentifier in the linked list
- return: none.
- exceptions: none.
- comments:
-------------------------------------------------------------------------------*/
+ /**
+ * addPortName()
+ * accept: Name of the port s, Port type,
+ * reference to RXTXCommDriver.
+ * perform: place a new CommPortIdentifier in the linked list
+ * return: none.
+ * exceptions: none.
+ * comments:
+ **/
+
public static void addPortName(String s, int type, CommDriver c)
{
- if(debug) System.out.println("CommPortIdentifier:addPortName("+s+")");
+ if(debug) System.out.println("CommPortIdentifier:addPortName(" + s + ")");
+
AddIdentifierToList(new CommPortIdentifier(s, null, type, c));
+
+ if(debug) System.out.println("CommPortIdentifier:addPortName:Exit");
}
-/*------------------------------------------------------------------------------
- AddIdentifierToList()
- accept: The cpi to add to the list.
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
+ /**
+ * AddIdentifierToList()
+ * accept: The cpi to add to the list.
+ * perform:
+ * return:
+ * exceptions:
+ * comments:
+ **/
+
private static void AddIdentifierToList( CommPortIdentifier cpi)
{
if(debug) System.out.println("CommPortIdentifier:AddIdentifierToList()");
@@ -163,7 +216,7 @@
if (CommPortIndex == null)
{
CommPortIndex = cpi;
- if(debug) System.out.println("CommPortIdentifier:AddIdentifierToList() null");
+ if(debug) System.out.println(" Com Port Index is null!");
}
else
{
@@ -171,264 +224,351 @@
while (index.next != null)
{
index = index.next;
- if(debug) System.out.println("CommPortIdentifier:AddIdentifierToList() index.next");
}
index.next = cpi;
}
}
+
+ if(debug) System.out.println("CommPortIdentifier:addIdentifier:Exit");
+
}
-/*------------------------------------------------------------------------------
- addPortOwnershipListener()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
public void addPortOwnershipListener(CommPortOwnershipListener c)
{
if(debug) System.out.println("CommPortIdentifier:addPortOwnershipListener()");
- /* is the Vector instantiated? */
+ /**
+ * is the Vector instantiated?
+ **/
if( ownershipListener == null )
{
ownershipListener = new Vector();
}
- /* is the ownership listener already in the list? */
+ /**
+ * is the ownership listener already in the list?
+ **/
if ( ownershipListener.contains(c) == false)
{
ownershipListener.addElement(c);
}
+
+ if(debug) System.out.println("CommPortIdentifier:addPortOwnershipListener:Exit");
}
-/*------------------------------------------------------------------------------
- getCurrentOwner()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
public String getCurrentOwner()
{
if(debug) System.out.println("CommPortIdentifier:getCurrentOwner()");
+
return( Owner );
+
}
-/*------------------------------------------------------------------------------
- getName()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
public String getName()
{
- if(debug) System.out.println("CommPortIdentifier:getName()");
+ if(debug) System.out.println("CommPortIdentifier:getName(" + PortName + ")");
+
return( PortName );
+
+
}
-/*------------------------------------------------------------------------------
- getPortIdentifier()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
static public CommPortIdentifier getPortIdentifier(String s) throws NoSuchPortException
{
if(debug) System.out.println("CommPortIdentifier:getPortIdentifier(" + s +")");
+
CommPortIdentifier index;
synchronized (Sync)
{
index = CommPortIndex;
- while (index != null && !index.PortName.equals(s)) {
+
+ while (index != null && !index.PortName.equals(s))
+ {
index = index.next;
}
+
if (index == null) {
- /* This may slow things down but if you pass the string for the port after
- a device is plugged in, you can find it now.
-
- http://bugzilla.qbang.org/show_bug.cgi?id=48
- */
+
+ /**
+ * This may slow things down but if you pass the string for the port after
+ * a device is plugged in, you can find it now.
+ *
+ * http://bugzilla.qbang.org/show_bug.cgi?id=48
+ **/
+
getPortIdentifiers();
+
index = CommPortIndex;
- while (index != null && !index.PortName.equals(s)) {
+
+ while (index != null && !index.PortName.equals(s))
+ {
index = index.next;
}
+
}
+
}
+
if (index != null) return index;
else
{
- if ( debug )
- System.out.println("not found!" + s);
+ if (debug) System.out.println(" not found!" + s);
+
throw new NoSuchPortException();
}
+
+
+
}
-/*------------------------------------------------------------------------------
- getPortIdentifier()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
static public CommPortIdentifier getPortIdentifier(CommPort p)
throws NoSuchPortException
{
- if(debug) System.out.println("CommPortIdentifier:getPortIdentifier(CommPort)");
+ if(debug) System.out.println("CommPortIdentifier:getPortIdentifier(" + p + ")");
+
CommPortIdentifier c;
+
synchronized( Sync )
{
+
c = CommPortIndex;
- while ( c != null && c.commport != p )
+
+ while
+ (
+ c != null &&
+ c.commport != p
+ )
+ {
c = c.next;
+ }
}
+
if ( c != null )
return (c);
- if ( debug )
- System.out.println("not found!" + p.getName());
+ if ( debug ) System.out.println(" not found!" + p.getName());
+
throw new NoSuchPortException();
+
+
}
-/*------------------------------------------------------------------------------
- getPortIdentifiers()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
static public Enumeration getPortIdentifiers()
{
- if(debug) System.out.println("static CommPortIdentifier:getPortIdentifiers()");
- //Do not allow anybody get any ports while we are re-initializing
- //because the CommPortIndex points to invalid instances during that time
+ if(debug) System.out.println("CommPortIdentifier:getPortIdentifiers()");
+
+ /**
+ * Do not allow anybody get any ports while we are re-initializing
+ * because the CommPortIndex points to invalid instances during that time
+ */
+
synchronized(Sync) {
- //Remember old ports in order to restore them for ownership events later
+
+ /**
+ * Remember old ports in order to restore them for ownership events later
+ **/
+ if(debug) System.out.println(" backing up current ports");
HashMap oldPorts = new HashMap();
CommPortIdentifier p = CommPortIndex;
- while(p!=null) {
+
+ while(p!=null)
+ {
oldPorts.put(p.PortName, p);
p = p.next;
}
+
CommPortIndex = null;
+
try
{
- //Initialize RXTX: This leads to detecting all ports
- //and writing them into our CommPortIndex through our method
- //{@link #addPortName(java.lang.String, int, gnu.io.CommDriver)}
- //This works while lock on Sync is held
- CommDriver RXTXDriver = (CommDriver) Class.forName("gnu.io.RXTXCommDriver").newInstance();
- RXTXDriver.initialize();
- //Restore old CommPortIdentifier objects where possible,
- //in order to support proper ownership event handling.
- //Clients might still have references to old identifiers!
+ /**
+ * Initialize RXTX: This leads to detecting all ports
+ * and writing them into our CommPortIndex through our method
+ * {@link #addPortName(java.lang.String, int, gnu.io.CommDriver)}
+ * This works while lock on Sync is held
+ **/
+
+ /**
+ * However, if RXTX is being called invoked by
+ * CommPortIdentifier:getPortIdentifiers for the first
+ * time, they have just been enumerated by static() in
+ * this class, so we don't need to repeat on the first
+ * time.
+ **/
+
+ if ( init_clean == false )
+ {
+ if(debug) System.out.println(" RXTX init() is dirty");
+ if(debug) System.out.println(" Creating RXTX new instance");
+ CommDriver RXTXDriver = (CommDriver) Class.forName("gnu.io.RXTXCommDriver").newInstance();
+ if(debug) System.out.println(" Creating RXTX new instance");
+ RXTXDriver.initialize();
+
+ }
+ else
+ {
+ if(debug) System.out.println(" RXTX init() still clean, now marking as dirty");
+ init_clean = false;
+ }
+
+ /**
+ * Restore old CommPortIdentifier objects where possible,
+ * in order to support proper ownership event handling.
+ * Clients might still have references to old identifiers!
+ **/
+
CommPortIdentifier curPort = CommPortIndex;
CommPortIdentifier prevPort = null;
- while(curPort!=null) {
+ while(curPort!=null)
+ {
CommPortIdentifier matchingOldPort = (CommPortIdentifier)oldPorts.get(curPort.PortName);
- if(matchingOldPort!=null && matchingOldPort.PortType == curPort.PortType) {
- //replace new port by old one
+ if
+ (
+ matchingOldPort!=null &&
+ matchingOldPort.PortType == curPort.PortType
+ )
+ {
+ /**
+ * replace new port by old one
+ **/
+
matchingOldPort.RXTXDriver = curPort.RXTXDriver;
matchingOldPort.next = curPort.next;
- if(prevPort==null) {
+
+ if (prevPort==null)
+ {
CommPortIndex = matchingOldPort;
- } else {
+ }
+ else
+ {
prevPort.next = matchingOldPort;
}
prevPort = matchingOldPort;
- } else {
+ }
+ else
+ {
prevPort = curPort;
}
+
curPort = curPort.next;
+
}
+
}
catch (Throwable e)
{
+
+ System.out.println(" " + e + " thrown while loading gnu.io.RXTXCommDriver");
+
System.err.println(e + " thrown while loading " + "gnu.io.RXTXCommDriver");
+
System.err.flush();
+
}
}
+
+ if(debug) System.out.println("CommPortIdentifier:getPortIdentifiers:Exit");
+
return new CommPortEnumerator();
+
+
+
}
-/*------------------------------------------------------------------------------
- getPortType()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
public int getPortType()
{
- if(debug) System.out.println("CommPortIdentifier:getPortType()");
+ if(debug) System.out.println("CommPortIdentifier:getPortType(" + PortType + ")");
+
return( PortType );
+
+
}
-/*------------------------------------------------------------------------------
- isCurrentlyOwned()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
public synchronized boolean isCurrentlyOwned()
{
if(debug) System.out.println("CommPortIdentifier:isCurrentlyOwned()");
+
return(!Available);
+
+
}
-/*------------------------------------------------------------------------------
- open()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
public synchronized CommPort open(FileDescriptor f) throws UnsupportedCommOperationException
{
if(debug) System.out.println("CommPortIdentifier:open(FileDescriptor)");
+
throw new UnsupportedCommOperationException();
+
}
private native String native_psmisc_report_owner(String PortName);
-/*------------------------------------------------------------------------------
- open()
- accept: application making the call and milliseconds to block
- during open.
- perform: open the port if possible
- return: CommPort if successful
- exceptions: PortInUseException if in use.
- comments:
-------------------------------------------------------------------------------*/
+ /**
+ * open()
+ * accept: application making the call and milliseconds to block
+ * during open.
+ * perform: open the port if possible
+ * return: CommPort if successful
+ * exceptions: PortInUseException if in use.
+ * comments:
+ **/
+
private boolean HideOwnerEvents;
- public CommPort open(String TheOwner, int i)
- throws gnu.io.PortInUseException
+ public CommPort open(
+ String TheOwner,
+ int i
+ )
+ throws gnu.io.PortInUseException
{
- if(debug) System.out.println("CommPortIdentifier:open("+TheOwner + ", " +i+")");
+ if(debug) System.out.println("CommPortIdentifier:open(" + TheOwner + ", " + i + ")");
+
boolean isAvailable;
- synchronized(this) {
+
+ synchronized(this)
+ {
isAvailable = this.Available;
+
if (isAvailable) {
- //assume ownership inside the synchronized block
+
+ /**
+ * assume ownership inside the synchronized block
+ * ? Of you and me !
+ **/
+
this.Available = false;
this.Owner = TheOwner;
}
}
+
if (!isAvailable)
{
long waitTimeEnd = System.currentTimeMillis() + i;
- //fire the ownership event outside the synchronized block
- fireOwnershipEvent(CommPortOwnershipListener.PORT_OWNERSHIP_REQUESTED);
+
+ /**
+ * Fire the ownership event outside the synchronized block
+ **/
+
+ fireOwnershipEvent
+ (
+ CommPortOwnershipListener.PORT_OWNERSHIP_REQUESTED
+ );
+
long waitTimeCurr;
- synchronized(this) {
- while(!Available && (waitTimeCurr=System.currentTimeMillis()) < waitTimeEnd) {
+
+ synchronized(this)
+ {
+
+ while
+ (
+ !Available &&
+ (
+ waitTimeCurr=System.currentTimeMillis()
+ ) < waitTimeEnd
+ )
+ {
try
{
wait(waitTimeEnd - waitTimeCurr);
@@ -439,91 +579,134 @@
break;
}
}
+
isAvailable = this.Available;
+
if (isAvailable) {
- //assume ownership inside the synchronized block
+ /**
+ * Assume ownership inside the synchronized block
+ * ? of you an me !
+ **/
this.Available = false;
this.Owner = TheOwner;
}
}
}
+
if (!isAvailable)
{
throw new gnu.io.PortInUseException(getCurrentOwner());
}
- //At this point, the CommPortIdentifier is owned by us.
- try {
+
+ /**
+ * At this point, the CommPortIdentifier is owned by us.
+ **/
+
+ try
+ {
if(commport == null)
{
- commport = RXTXDriver.getCommPort(PortName,PortType);
+ commport = RXTXDriver.getCommPort(
+ PortName,
+ PortType
+ );
}
+
if(commport != null)
{
- fireOwnershipEvent(CommPortOwnershipListener.PORT_OWNED);
+ fireOwnershipEvent(
+ CommPortOwnershipListener.PORT_OWNED
+ );
+
return commport;
}
else
{
- throw new gnu.io.PortInUseException(
- native_psmisc_report_owner(PortName));
+ throw new gnu.io.PortInUseException
+ (
+ native_psmisc_report_owner(PortName)
+ );
}
- } finally {
+ }
+ finally
+ {
if(commport == null) {
- //something went wrong reserving the commport -> unown the port
+
+ /**
+ * something went wrong reserving the commport
+ * -> release ownership (internal) of the port
+ **/
+
synchronized(this) {
+
this.Available = true;
this.Owner = null;
+
}
}
+ if(debug) System.out.println("CommPortIdentifier:open:Exit");
}
- }
-/*------------------------------------------------------------------------------
- removePortOwnership()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
+
+
+ }
+
public void removePortOwnershipListener(CommPortOwnershipListener c)
{
if(debug) System.out.println("CommPortIdentifier:removePortOwnershipListener()");
- /* why is this called twice? */
- if(ownershipListener != null)
+
+ /**
+ * why is this called twice?
+ **/
+
+ if(ownershipListener != null)
+ {
+ if(debug) System.out.println(" I was owned!");
ownershipListener.removeElement(c);
+ }
+
+ if(debug) System.out.println("CommPortIdentifier:removePortOwnershipListener()");
}
-/*------------------------------------------------------------------------------
- internalClosePort()
- accept: None
- perform: clean up the Ownership information and send the event
- return: None
- exceptions: None
- comments: None
-------------------------------------------------------------------------------*/
+ /**
+ * internalClosePort()
+ * accept: None
+ * perform: clean up the Ownership information and send the event
+ * return:
+ * exceptions:
+ * comments:
+ **/
+
void internalClosePort()
{
+
+ if(debug) System.out.println("CommPortIdentifier:internalClosePort()");
+
synchronized(this) {
- if(debug) System.out.println("CommPortIdentifier:internalClosePort()");
+
Owner = null;
Available = true;
commport = null;
- /* this tosses null pointer?? */
+
+ /**
+ * this tosses null pointer??
+ **/
+ if(debug) System.out.println(" Notifying all...");
+
notifyAll();
+
}
+
fireOwnershipEvent(CommPortOwnershipListener.PORT_UNOWNED);
+
+ if(debug) System.out.println("CommPortIdentifier:internalClosePort:Exit");
}
-/*------------------------------------------------------------------------------
- fireOwnershipEvent()
- accept:
- perform:
- return:
- exceptions:
- comments:
-------------------------------------------------------------------------------*/
+
void fireOwnershipEvent(int eventType)
{
+
if(debug) System.out.println("CommPortIdentifier:fireOwnershipEvent( " + eventType + " )");
+
if (ownershipListener != null)
{
CommPortOwnershipListener c;
@@ -532,6 +715,10 @@
c.ownershipChange(eventType))
c = (CommPortOwnershipListener) e.nextElement();
}
+
+ if(debug) System.out.println("CommPortIdentifier:fireOwnershipEvent:Exit");
}
+
+
}

31
comms/rxtx/files/patch-src-gnu-io-Configure.java Normal file
View file

@ -0,0 +1,31 @@
--- src/gnu/io/Configure.java.orig 2007-11-18 22:32:41.000000000 +0000
+++ src/gnu/io/Configure.java 2015-05-11 16:51:34.000000000 +0100
@@ -61,6 +61,7 @@
import java.awt.event.*;
import java.io.*;
+
class Configure extends Frame
{
Checkbox cb[];
@@ -68,7 +69,9 @@
static final int PORT_SERIAL = 1;
static final int PORT_PARALLEL = 2;
int PortType = PORT_SERIAL;
-
+
+ private final static boolean debug = "true".equals( System.getProperty( "gnu.io.rxtx.DEBUG" ) );
+
private void saveSpecifiedPorts()
{
String filename;
@@ -212,7 +215,9 @@
}
public static void main (String[] args)
{
+ if (debug) System.out.println("Configure - Before New");
new Configure();
+ if (debug) System.out.println("Configure - After New");
}
String EnumMessage = "gnu.io.rxtx.properties has not been detected.\n\nThere is no consistant means of detecting ports on this operating System. It is necessary to indicate which ports are valid on this system before proper port enumeration can happen. Please check the ports that are valid on this system and select Save";
}

11
comms/rxtx/files/patch-src-gnu-io-LPRPort.java Normal file
View file

@ -0,0 +1,11 @@
--- src/gnu/io/LPRPort.java.orig 2007-04-26 06:26:05.000000000 +0100
+++ src/gnu/io/LPRPort.java 2015-05-11 16:51:34.000000000 +0100
@@ -77,7 +77,7 @@
/** Initialize the native library */
private native static void Initialize();
- private final static boolean debug = false;
+ private final static boolean debug = "true".equals( System.getProperty( "gnu.io.rxtx.DEBUG" ) );
/** Open the named port */
public LPRPort( String name ) throws PortInUseException

12
comms/rxtx/files/patch-src-gnu-io-NoSuchPortException.java Normal file
View file

@ -0,0 +1,12 @@
--- src/gnu/io/NoSuchPortException.java.orig 2007-04-26 06:26:05.000000000 +0100
+++ src/gnu/io/NoSuchPortException.java 2015-05-11 16:51:34.000000000 +0100
@@ -67,6 +67,9 @@
public class NoSuchPortException extends Exception
{
+
+ private final static boolean debug = "true".equals( System.getProperty( "gnu.io.rxtx.DEBUG" ) );
+
NoSuchPortException( String str )
{
super( str );

1648
comms/rxtx/files/patch-src-gnu-io-RXTXCommDriver.java
View file

File diff suppressed because it is too large Load diff

2840
comms/rxtx/files/patch-src-gnu-io-RXTXPort.java Normal file
View file

File diff suppressed because it is too large Load diff

11
comms/rxtx/files/patch-src-gnu-io-SerialPortEvent.java Normal file
View file

@ -0,0 +1,11 @@
--- src/gnu/io/SerialPortEvent.java.orig 2007-04-26 06:26:06.000000000 +0100
+++ src/gnu/io/SerialPortEvent.java 2015-05-11 16:51:34.000000000 +0100
@@ -76,6 +76,8 @@
public static final int PE =8;
public static final int FE =9;
public static final int BI =10;
+
+ private final static boolean debug = "true".equals( System.getProperty( "gnu.io.rxtx.DEBUG" ) );
private boolean OldValue;
private boolean NewValue;