; Copyright (c) 2000, Perforce Software, All rights reserved.
; 
; This software was originally developed by Silicon Graphics, Inc (SGI).
; 
; Redistribution and use in source and binary forms, with or
; without modification, are permitted provided that the following
; conditions are met:
; 
; Redistributions of source code must retain the above copyright notice,
; this list of conditions and the following disclaimer.
; 
; Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in the
; documentation and/or other materials provided with the distribution.
; 
; Neither name of Perforce Software nor SGI nor the names of its
; contributors may be used to endorse or promote products derived from
; this software without specific prior written permission.
; 
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
; ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
; CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
; EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


procedure(CDS_P4IPCDirectCommand(command)	  ;_Jul 25 00 sikand 320
  ;; front end caller for direct ipc calls
  ;; unbuffered
  ;; piping handled by stdHandler in BeginDirectProcess
  let((child)
    CDS_P4IPCBeginDirectProcess(command)
    ipcWait(CDS_P4IPCProc)
    status = ipcGetExitStatus(CDS_P4IPCProc)
    ;; ugly
    0
  ) ; ** let **
) ; ** procedure CDS_P4IPCDirectCommand **




procedure(CDS_P4IPCCommand(command)		  ;_Jun 17 99 sikand 94

  ;; equivalent to a buffered skillserver command

  
  CDS_P4IPCBeginProcess(command)
) ; ** procedure CDS_P4IPCDirectCommand **


procedure(CDS_P4IPCBeginProcess(command)

;; command thru the server, buffered
  let( (pcommand)
    if( CDS_P4CurrentClient then
       pcommand = strcat("-c " CDS_P4CurrentClient " " command "\n")
    else
      pcommand = strcat(command "\n")
    )

    ;;printf("Executing %s",pcommand)
    CDS_P4ServerBufferCommand(pcommand)
  
  ) ; ** let **
) ; ** procedure CDS_P4IPCBeginProcess **


procedure(CDS_P4IPCBeginDirectProcess(command	  ;_Apr  4 00 sikand 342
	     @key (stdHandler "CDS_P4IPCLog")
	     (errHandler "CDS_P4Error")
	     (doneFunc "")
	     (logFile  ""))
  ;; execute the command directly without saving output in buffer
  let( (pcommand)
    if( CDS_P4CurrentClient then
       pcommand = strcat("p4 -c " CDS_P4CurrentClient " " command)
    else
      pcommand = strcat("p4 "  command)
    )

    CDS_P4IPCProc = ipcBeginProcess(pcommand "" stdHandler errHandler doneFunc logFile)
  )
) ; ** procedure CDS_P4IPCBeginDirectProcess **



procedure(CDS_P4IPCLog(childId data)		  ;_Jun 17 99 sikand 121
  ;;fprintf(CDS_P4Port "%s" data)
  ;drain(CDS_P4Port)
  ;; NO action for now, too noisy
  t
)


procedure(CDS_P4IPCError(childId data)		  ;_Jun 17 99 sikand 121
  ;;fprintf(CDS_P4Port "%s" data)
  ;drain(CDS_P4Port)
  ;; NO action for now, too noisy
  printf("Message: %s\n" data)
  t
)

procedure(CDS_P4IPCDirectBufferProcess(command	  ;_Jul 25 00 sikand 529
	     @key (stdHandler "CDS_P4IPCAssignToGlobal")
	     (errHandler "CDS_P4IPCAssignToGlobal")
	     (doneFunc "")
	     (logFile  ""))

  ;; execute a command directly, and store the output in the
  ;; buffer
  let((child pcommand)
    ;; clear the buffer
    CDS_IPCBuffer= nil
    pcommand = strcat("p4 " command)
    child = ipcBeginProcess(pcommand "" stdHandler errHandler doneFunc logFile)
    ipcWait(child)
    ;;ipcGetExitStatus(child)
    ;; ugly
    0
  ) ; ** let **
) ; ** procedure CDS_P4IPCDirectBufferProcess **



procedure(CDS_P4IPCBufferProcess(command)
;; communicate with the skillserver as a buffered read
  let((child pcommand)
    ;; clear the buffer
    if( CDS_P4CurrentClient then
       pcommand = strcat("-c " CDS_P4CurrentClient " " command "\n")
    else
       pcommand = strcat(command "\n")
    )

    ;;printf("Executing %s",pcommand)
    CDS_P4ServerBufferCommand(pcommand)
  ) ; ** let **
) ; ** procedure CDS_P4IPCBufferProcess **


procedure(CDS_P4IPCAssignToGlobal(childId data)	  ;_Jun 17 99 sikand 0
  let((temp)

    if( CDS_IPCBuffer then
       temp = strcat(CDS_IPCBuffer data)
       CDS_IPCBuffer = temp
    else
       CDS_IPCBuffer =data
    ) ; ** if CDS_IPCBuffer **
    
    ;;fprintf(CDS_P4Port "Buffer: %s" data)
    ;drain(CDS_P4Port)
  ) ; ** let **
) ; ** procedure CDS_P4IPCAssignToGlobal **

procedure(CDS_P4IPCAssignToGlobalQ(childId data)  ;_Jun 17 99 sikand 0
  let((temp)
    
    if( CDS_IPCBuffer then
       temp = strcat(CDS_IPCBuffer data)
       CDS_IPCBuffer = temp
    else
       CDS_IPCBuffer= data
    ) ; ** if CDS_IPCBuffer **
  ) ; ** let **
) ; ** procedure CDS_P4IPCAssignToGlobalQ **



procedure(CDS_P4ServerBufferCommand(cmd)	  ;_Mar 24 00 sikand 158
  prog((child data)
    child = CDS_P4ServerId
    CDS_IPCBuffer = ""
    CDS_P4rawcount = 0
    ;; need to flush the buffer in the client
    ;; since it may not be empty
    ;; if a previous read failed due to a trigger
    ;; call to 'error' for example

    ;; so do a set of non blocking reads

    ;; assumption: the client has acutally finished the previous
    ;; command in question by the time we return here
    ;; ....if not, it could get a bit ugly
    ;; since the buffer won't have flushed correctly
    
    while(  (data = ipcReadProcess(child)) !=  ""
       t
    )
    
    
    rexCompile("p4skillservercmddone")

    ;;printf("Writing server %s" cmd)
    unless( ipcWriteProcess(child cmd)
       return()
    )
    return(CDS_P4ReadData(child))
    ;;printf("G %s\n", CDS_IPCBuffer)
  ) ; ** prog **
) ; ** procedure CDS_P4ServerBufferCommand **

procedure(CDS_P4ReadDataBuff(child)		  ;_Jun 29 01 sikand 885
  prog((x y error)
    CDS_P4IPCError = nil
    error=nil
    ;; 30 second blocking default
    x = ipcReadProcess(child 30)
      
    when( x
       ;;printf("Raw: %s\n" x)
       if( x == "" then
	  CDS_P4rawcount++
       else
	  CDS_P4rawcount = 0
       )
       when( CDS_P4rawcount > 30
	  CDS_P4rawcount = 0
	  error("FATAL: Failed to communicate or massive data overrun!")
       )
       ;;printf("End of raw\n")
       ;;
       ;; rely on rexCompile from ServerBufferCommand
       if( rexExecute(x) then
	  ;;x = rexReplace(x "" 1)
	  when( rexMatchp("p4skillservercmddoneerr" x)
	     
	     rexCompile("p4skillservercmddoneerr")
	     y = rexReplace(x "" 1)
	     CDS_IPCBuffer = strcat(CDS_IPCBuffer y)
	     ;;when( CDS_P4Debug
	     ;;warn("p4skillserver command completed with errors!")
	     printf("\np4: %s\n" CDS_IPCBuffer)
	     ;;)
	     error=t
	     ;; all error trapping disabled ;; ugly
	     ;;CDS_P4IPCError = nil
	     ;;return(t)
	  ) ; ** when rexMatchp **
	  if(error then
	  rexCompile("p4skillservercmddoneerr")
	  error=nil
	  else
	  rexCompile("p4skillservercmddone")
	  )
	  y = rexReplace(x "" 1)
	  CDS_IPCBuffer = strcat(CDS_IPCBuffer y)
	  return(nil)
       ) ; ** if rexMatchp **
       CDS_IPCBuffer = strcat(CDS_IPCBuffer x)
    ) ; ** when x **
    return(t)
  ) ; ** let **
) ; ** procedure CDS_P4ReadDataBuff **


procedure(CDS_P4ReadData(child)			  ;_Jul 25 00 sikand 194
  prog(()

    while( CDS_P4ReadDataBuff(child)
       t
    )
    ;;printf("info: %d buffered reads\n" b)
    if( CDS_P4IPCError then
       CDS_P4IPCError = nil
       return(1)
    else
       return(0)
    )
    
  ) ; ** let **
) ; ** procedure CDS_P4Read_data **