783 lines
21 KiB
C
783 lines
21 KiB
C
/**
|
|
* Implementation file for the exe buffer buffer manager.
|
|
*
|
|
* copyright: see file COPYRIGHT
|
|
*
|
|
* More information in exe.tex
|
|
*
|
|
* Mark Koennecke, November 2004
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
#include <tcl.h>
|
|
#include "fortify.h"
|
|
#include "sics.h"
|
|
#include "exebuf.h"
|
|
#include "exeman.h"
|
|
#include "sdynar.h"
|
|
#include "dynstring.h"
|
|
#include "lld.h"
|
|
#include "exeman.i"
|
|
#include "splitter.h"
|
|
|
|
/*-------------------------------------------------------------------*/
|
|
static void KillExeMan(void *data){
|
|
pExeMan self = (pExeMan)data;
|
|
if(!self){
|
|
return;
|
|
}
|
|
if(self->pDes){
|
|
DeleteDescriptor(self->pDes);
|
|
}
|
|
if(self->pCall){
|
|
DeleteCallBackInterface(self->pCall);
|
|
}
|
|
if(self->batchPath){
|
|
free(self->batchPath);
|
|
}
|
|
if(self->sysPath){
|
|
free(self->sysPath);
|
|
}
|
|
if(self->exeStack){
|
|
DeleteDynar(self->exeStack);
|
|
}
|
|
LLDdelete(self->runList);
|
|
free(self);
|
|
}
|
|
/*-----------------------------------------------------------------*/
|
|
static int SaveExeMan(void *data, char *name, FILE *fd){
|
|
pExeMan self = (pExeMan)data;
|
|
|
|
if(!self){
|
|
return 0;
|
|
}
|
|
fprintf(fd,"%s batchpath %s\n",name,self->batchPath);
|
|
fprintf(fd,"%s syspath %s\n",name,self->sysPath);
|
|
return 1;
|
|
}
|
|
/*-----------------------------------------------------------------*/
|
|
static void *ExeManInterface(void *data, int interfaceID){
|
|
pExeMan self = (pExeMan)data;
|
|
|
|
if(self == NULL){
|
|
return NULL;
|
|
}
|
|
if(interfaceID == CALLBACKINTERFACE){
|
|
return self->pCall;
|
|
}
|
|
return NULL;
|
|
}
|
|
/*------------------------------------------------------------------*/
|
|
int MakeExeManager(SConnection *pCon, SicsInterp *pSics, void *pData,
|
|
int argc, char *argv[]){
|
|
pExeMan pNew = NULL;
|
|
int status;
|
|
|
|
pNew = (pExeMan)malloc(sizeof(ExeMan));
|
|
if(!pNew){
|
|
SCWrite(pCon,"ERROR: out of memory creating exe Manager",eError);
|
|
return 0;
|
|
}
|
|
|
|
memset(pNew,0,sizeof(ExeMan));
|
|
pNew->pDes = CreateDescriptor("ExeManager");
|
|
pNew->pCall = CreateCallBackInterface();
|
|
pNew->sysPath = strdup("./");
|
|
pNew->batchPath = strdup("./");
|
|
pNew->exeStack = CreateDynar(1,10,10,exeBufKill);
|
|
pNew->exeStackPtr = -1;
|
|
pNew->runList = LLDcreate(sizeof(pExeBuf));
|
|
if(!pNew->pDes || !pNew->pCall || ! pNew->batchPath ||
|
|
!pNew->exeStack || pNew->runList < 0){
|
|
SCWrite(pCon,"ERROR: out of memory creating exe Manager",eError);
|
|
return 0;
|
|
}
|
|
pNew->pDes->SaveStatus = SaveExeMan;
|
|
pNew->pDes->GetInterface = ExeManInterface;
|
|
|
|
if(argc > 1){
|
|
status = AddCommand(pSics,
|
|
argv[1],
|
|
ExeManagerWrapper,
|
|
KillExeMan,
|
|
pNew);
|
|
} else {
|
|
status = AddCommand(pSics,
|
|
"exe",
|
|
ExeManagerWrapper,
|
|
KillExeMan,
|
|
pNew);
|
|
}
|
|
if(status != 1) {
|
|
SCWrite(pCon,"ERROR: duplicate exe manager not created",eError);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
/*======================== buffer execution ==========================*/
|
|
static int fileExists(char *path){
|
|
FILE *fd = NULL;
|
|
int status = 0;
|
|
|
|
fd = fopen(path,"r");
|
|
if(fd != NULL){
|
|
fclose(fd);
|
|
status = 1;
|
|
}
|
|
return status;
|
|
}
|
|
/*--------------------------------------------------------------------*/
|
|
extern char *stptok(char *s, char *t, int len, char *brk);
|
|
|
|
static pDynString locateBatchBuffer(pExeMan self, char *name){
|
|
pDynString result = NULL;
|
|
char pPath[132], *pPtr = NULL;
|
|
|
|
result = CreateDynString(256,256);
|
|
if(!result){
|
|
return NULL;
|
|
}
|
|
|
|
pPtr = self->batchPath;
|
|
while((pPtr = stptok(pPtr,pPath,131,":")) != NULL){
|
|
DynStringCopy(result,pPath);
|
|
DynStringConcatChar(result,'/');
|
|
DynStringConcat(result,name);
|
|
if(fileExists(GetCharArray(result))){
|
|
return result;
|
|
}
|
|
}
|
|
|
|
pPtr = self->sysPath;
|
|
while((pPtr = stptok(pPtr,pPath,131,":")) != NULL){
|
|
DynStringCopy(result,pPath);
|
|
DynStringConcatChar(result,'/');
|
|
DynStringConcat(result,name);
|
|
if(fileExists(GetCharArray(result))){
|
|
return result;
|
|
}
|
|
}
|
|
DeleteDynString(result);
|
|
return NULL;
|
|
}
|
|
/*-------------------------------------------------------------------*/
|
|
static int runBatchBuffer(pExeMan self, SConnection *pCon,
|
|
SicsInterp *pSics, char *name){
|
|
pDynString filePath = NULL;
|
|
char pBueffel[256];
|
|
pExeBuf buffer = NULL;
|
|
int status;
|
|
|
|
if(!SCMatchRights(pCon,usUser)) {
|
|
return 0;
|
|
}
|
|
filePath = locateBatchBuffer(self,name);
|
|
if(filePath == NULL){
|
|
snprintf(pBueffel,255,"ERROR: batch buffer %s not found in path",
|
|
name);
|
|
SCWrite(pCon,pBueffel,eError);
|
|
return 0;
|
|
}
|
|
|
|
buffer = exeBufCreate(name);
|
|
if(!buffer){
|
|
DeleteDynString(filePath);
|
|
SCWrite(pCon,"ERROR: out of memory creating batch buffer",eError);
|
|
return 0;
|
|
}
|
|
status = exeBufLoad(buffer,GetCharArray(filePath));
|
|
if(!status){
|
|
DeleteDynString(filePath);
|
|
SCWrite(pCon,"ERROR: failed to load batch buffer",eError);
|
|
return 0;
|
|
}
|
|
DeleteDynString(filePath);
|
|
|
|
self->exeStackPtr++;
|
|
DynarPut(self->exeStack,self->exeStackPtr,buffer);
|
|
status = exeBufProcess(buffer,pSics,pCon,self->pCall);
|
|
self->exeStackPtr--;
|
|
return status;
|
|
}
|
|
/*========================== path management ========================*/
|
|
static int handleBatchPath(pExeMan self, SConnection *pCon, int argc,
|
|
char *argv[]){
|
|
char pBuffer[1024];
|
|
|
|
if(strcmp(argv[1],"batchpath") == 0) {
|
|
if(argc > 2) {
|
|
if(!SCMatchRights(pCon,usUser)){
|
|
return 0;
|
|
}
|
|
if(self->batchPath != NULL){
|
|
free(self->batchPath);
|
|
}
|
|
self->batchPath = strdup(argv[2]);
|
|
SCSendOK(pCon);
|
|
SCparChange(pCon);
|
|
return 1;
|
|
} else {
|
|
snprintf(pBuffer,1023,"%s.batchpath = %s", argv[0],self->batchPath);
|
|
SCWrite(pCon,pBuffer,eValue);
|
|
return 1;
|
|
}
|
|
}
|
|
if(strcmp(argv[1],"syspath") == 0) {
|
|
if(argc > 2) {
|
|
if(!SCMatchRights(pCon,usMugger)){
|
|
return 0;
|
|
}
|
|
if(self->sysPath != NULL){
|
|
free(self->sysPath);
|
|
}
|
|
self->sysPath = strdup(argv[2]);
|
|
SCSendOK(pCon);
|
|
SCparChange(pCon);
|
|
return 1;
|
|
} else {
|
|
snprintf(pBuffer,1023,"%s.syspath = %s", argv[0],self->sysPath);
|
|
SCWrite(pCon,pBuffer,eValue);
|
|
return 1;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
/*=========================== callbacks ==============================*/
|
|
typedef struct {
|
|
SConnection *pCon;
|
|
pExeMan exe;
|
|
}exeInfo, *pExeInfo;
|
|
/*------------------------------------------------------------------*/
|
|
static void killExeInfo(void *pData){
|
|
pExeInfo self = (pExeInfo)pData;
|
|
if(self != NULL){
|
|
free(self);
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------------*/
|
|
static pExeInfo makeExeInfo(SConnection *pCon, pExeMan self){
|
|
pExeInfo pNew = NULL;
|
|
pNew = malloc(sizeof(exeInfo));
|
|
if(pNew == NULL){
|
|
SCWrite(pCon,
|
|
"ERROR: failed to allocate info structure for registering callbacks",
|
|
eError);
|
|
return NULL;
|
|
}
|
|
pNew->pCon = pCon;
|
|
pNew->exe = self;
|
|
return pNew;
|
|
}
|
|
/*------------------------------------------------------------------*/
|
|
static int BufferCallback(int iEvent, void *pEvent, void *pUser){
|
|
pExeInfo self = (pExeInfo)pUser;
|
|
char *name = (char *)pEvent;
|
|
char pBueffel[132];
|
|
|
|
if(iEvent == BATCHSTART){
|
|
snprintf(pBueffel,131,"BATCHSTART=%s",name);
|
|
SCWrite(self->pCon,pBueffel,eWarning);
|
|
return 1;
|
|
}
|
|
if(iEvent == BATCHEND){
|
|
snprintf(pBueffel,131,"BATCHEND=%s",name);
|
|
SCWrite(self->pCon,pBueffel,eWarning);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
/*-------------------------------------------------------------------*/
|
|
static int LineCallBack(int iEvent, void *pEvent, void *pUser){
|
|
pExeInfo self = (pExeInfo)pUser;
|
|
char pBueffel[256];
|
|
int start, end, lineno;
|
|
void *pPtr = NULL;
|
|
pExeBuf buf = NULL;
|
|
|
|
assert(self);
|
|
if(iEvent == BATCHAREA){
|
|
DynarGet(self->exe->exeStack,self->exe->exeStackPtr,&pPtr);
|
|
buf = (pExeBuf)pPtr;
|
|
assert(buf);
|
|
exeBufRange(buf,&start,&end,&lineno);
|
|
snprintf(pBueffel,255,"%s.range = %d = %d",exeBufName(buf),
|
|
start,end);
|
|
SCWrite(self->pCon,pBueffel,eWarning);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
/*--------------------------------------------------------------------*/
|
|
static void registerCallbacks(SConnection *pCon, SicsInterp *pSics,
|
|
pExeMan self){
|
|
pExeInfo info = NULL;
|
|
long lID;
|
|
|
|
info = makeExeInfo(pCon,self);
|
|
if(info == NULL){
|
|
return;
|
|
}
|
|
lID = RegisterCallback(self->pCall, BATCHSTART, BufferCallback,
|
|
info, killExeInfo);
|
|
SCRegister(pCon,pSics, self->pCall,lID);
|
|
lID = RegisterCallback(self->pCall, BATCHEND, BufferCallback,
|
|
info, NULL);
|
|
SCRegister(pCon,pSics, self->pCall,lID);
|
|
lID = RegisterCallback(self->pCall, BATCHAREA, LineCallBack,
|
|
info, NULL);
|
|
SCRegister(pCon,pSics, self->pCall,lID);
|
|
}
|
|
/*--------------------------------------------------------------------*/
|
|
static void unregisterCallbacks(SConnection *pCon, pExeMan self){
|
|
long lID;
|
|
int i;
|
|
|
|
for(i = 0; i < 3; i++){
|
|
lID = SCgetCallbackID(pCon,self->pCall);
|
|
if(lID >= 0){
|
|
RemoveCallback(self->pCall,lID);
|
|
SCUnregisterID(pCon,lID);
|
|
}
|
|
}
|
|
}
|
|
/*========================= uploading ===============================*/
|
|
static int startUpload(pExeMan self, SConnection *pCon){
|
|
if(SCGetRights(pCon) > usUser){
|
|
SCWrite(pCon,"ERROR: no permission to upload buffers",eError);
|
|
return 0;
|
|
}
|
|
if(self->uploadBuffer != NULL){
|
|
SCWrite(pCon,"ERRO: another upload is still in progress",eError);
|
|
return 0;
|
|
}
|
|
self->uploadBuffer = exeBufCreate("upload");
|
|
if(self->uploadBuffer == NULL){
|
|
SCWrite(pCon,"ERROR: failed to create upload buffer",eError);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
/*---------------------------------------------------------------------*/
|
|
static int appendLine(pExeMan self, SConnection *pCon,
|
|
int argc, char *argv[]){
|
|
char pLine[1024];
|
|
|
|
if(SCGetRights(pCon) > usUser){
|
|
SCWrite(pCon,"ERROR: no permission to upload buffers",eError);
|
|
return 0;
|
|
}
|
|
if(self->uploadBuffer == NULL){
|
|
SCWrite(pCon,"ERROR: no upload in operation",eError);
|
|
return 0;
|
|
}
|
|
Arg2Text(argc-2,&argv[2],pLine,1023);
|
|
exeBufAppend(self->uploadBuffer,pLine);
|
|
return 1;
|
|
}
|
|
/*--------------------------------------------------------------------*/
|
|
static int uploadSave(pExeMan self, SConnection *pCon,
|
|
int argc, char *argv[]){
|
|
int status;
|
|
|
|
if(SCGetRights(pCon) > usUser){
|
|
SCWrite(pCon,"ERROR: no permission to save buffers",eError);
|
|
return 0;
|
|
}
|
|
if(argc < 3) {
|
|
SCWrite(pCon,"ERROR: no file given to save upload buffer to",eError);
|
|
return 0;
|
|
}
|
|
if(self->uploadBuffer == NULL){
|
|
SCWrite(pCon,"ERROR: no upload buffer to save exists",eError);
|
|
return 0;
|
|
}
|
|
status = exeBufSave(self->uploadBuffer,argv[2]);
|
|
if(status == 0){
|
|
SCWrite(pCon,"ERROR: failed to save exe buffer, destroyed...",eError);
|
|
}
|
|
exeBufDelete(self->uploadBuffer);
|
|
self->uploadBuffer = NULL;
|
|
return status;
|
|
}
|
|
/*=========================== info ===================================*/
|
|
static void printExeStack(pExeMan self, SConnection *pCon){
|
|
int i, j;
|
|
pDynString txt = NULL;
|
|
pExeBuf buf;
|
|
void *pPtr = NULL;
|
|
|
|
txt = CreateDynString(80,80);
|
|
if(txt == NULL){
|
|
SCWrite(pCon,"ERROR: failed to allocate memory in printExeStack",eError);
|
|
return;
|
|
}
|
|
for(i = 0; i <= self->exeStackPtr; i++){
|
|
DynarGet(self->exeStack,i,&pPtr);
|
|
buf = (pExeBuf)pPtr;
|
|
assert(buf);
|
|
for(j = 0; j < i; j++){
|
|
DynStringConcat(txt," ");
|
|
}
|
|
DynStringConcat(txt,exeBufName(buf));
|
|
DynStringConcatChar(txt,'\n');
|
|
}
|
|
SCWrite(pCon,GetCharArray(txt),eValue);
|
|
DeleteDynString(txt);
|
|
}
|
|
/*-----------------------------------------------------------------*/
|
|
static int locateBuffer(pExeMan self, char *name){
|
|
int i;
|
|
pExeBuf buf;
|
|
void *pPtr = NULL;
|
|
|
|
for(i = 0; i <= self->exeStackPtr; i++){
|
|
DynarGet(self->exeStack,i,&pPtr);
|
|
buf = (pExeBuf)pPtr;
|
|
if(strcmp(name,exeBufName(buf)) == 0) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
/*------------------------------------------------------------------*/
|
|
static void printExeRange(pExeMan self, SConnection *pCon,
|
|
int argc, char *argv[]){
|
|
int start, end, lineno, bufNo;
|
|
pExeBuf buf;
|
|
void *pPtr = NULL;
|
|
char pBueffel[256];
|
|
|
|
if(argc > 3) {
|
|
bufNo = locateBuffer(self,argv[3]);
|
|
} else {
|
|
bufNo = self->exeStackPtr;
|
|
}
|
|
if(bufNo < 0){
|
|
SCWrite(pCon,"ERROR: named buffer not found",eError);
|
|
return;
|
|
}
|
|
DynarGet(self->exeStack,bufNo,&pPtr);
|
|
buf = (pExeBuf)pPtr;
|
|
assert(buf);
|
|
exeBufRange(buf,&start,&end,&lineno);
|
|
snprintf(pBueffel,255,"%s.range = %d = %d = %d",exeBufName(buf),
|
|
start,end,lineno);
|
|
SCWrite(pCon,pBueffel,eValue);
|
|
}
|
|
/*------------------------------------------------------------------*/
|
|
static void printExeText(pExeMan self, SConnection *pCon,
|
|
int argc, char *argv[]){
|
|
int start, end, lineno, bufNo;
|
|
pExeBuf buf;
|
|
void *pPtr = NULL;
|
|
pDynString txt;
|
|
|
|
if(argc > 3) {
|
|
bufNo = locateBuffer(self,argv[3]);
|
|
} else {
|
|
bufNo = self->exeStackPtr;
|
|
}
|
|
if(bufNo < 0){
|
|
SCWrite(pCon,"ERROR: named buffer not found",eError);
|
|
return;
|
|
}
|
|
DynarGet(self->exeStack,bufNo,&pPtr);
|
|
buf = (pExeBuf)pPtr;
|
|
assert(buf);
|
|
exeBufRange(buf,&start,&end,&lineno);
|
|
txt = exeBufText(buf,start,end);
|
|
if(txt != NULL){
|
|
SCWrite(pCon,GetCharArray(txt),eValue);
|
|
DeleteDynString(txt);
|
|
} else {
|
|
SCWrite(pCon,"ERROR: failed to allocate text buffer for operation",eError);
|
|
}
|
|
}
|
|
/*------------------------------------------------------------------*/
|
|
static void printQueue(pExeMan self, SConnection *pCon){
|
|
pExeBuf buf= NULL;
|
|
pDynString text = NULL;
|
|
int status;
|
|
|
|
text = CreateDynString(80,80);
|
|
if(text == NULL){
|
|
SCWrite(pCon,"ERROR: out of memory",eError);
|
|
return;
|
|
}
|
|
|
|
status = LLDnodePtr2First(self->runList);
|
|
while(status != 0) {
|
|
LLDnodeDataTo(self->runList,&buf);
|
|
if(buf != NULL){
|
|
DynStringConcat(text,exeBufName(buf));
|
|
DynStringConcatChar(text,'\n');
|
|
}
|
|
status = LLDnodePtr2Next(self->runList);
|
|
}
|
|
SCWrite(pCon,GetCharArray(text),eValue);
|
|
DeleteDynString(text);
|
|
}
|
|
/*-------------------------------------------------------------------*/
|
|
static int infoHandler(pExeMan self, SConnection *pCon,
|
|
int argc, char *argv[]){
|
|
char pBueffel[256];
|
|
pExeBuf buf;
|
|
void *pPtr = NULL;
|
|
|
|
if(self->exeStackPtr < 0){
|
|
SCWrite(pCon,"Idle",eValue);
|
|
return 1;
|
|
}
|
|
|
|
if(argc < 3){
|
|
if(self->exeStackPtr >= 0){
|
|
DynarGet(self->exeStack,self->exeStackPtr,&pPtr);
|
|
buf = (pExeBuf)pPtr;
|
|
if(buf != NULL){
|
|
snprintf(pBueffel,255,"Executing %s",exeBufName(buf));
|
|
SCWrite(pCon,pBueffel,eValue);
|
|
return 1;
|
|
}
|
|
}
|
|
return 1; /* statement inserted, guessed return value M.Z. */
|
|
} else {
|
|
strtolower(argv[2]);
|
|
if(strcmp(argv[2],"stack") == 0){
|
|
printExeStack(self,pCon);
|
|
return 1;
|
|
} else if(strcmp(argv[2],"range") == 0){
|
|
printExeRange(self,pCon,argc,argv);
|
|
return 1;
|
|
} else if(strcmp(argv[2],"text") == 0){
|
|
printExeText(self,pCon,argc,argv);
|
|
return 1;
|
|
} else {
|
|
SCWrite(pCon,"ERROR: subcommand to info unknown",eError);
|
|
return 0; /* statement inserted, guessed return value M.Z. */
|
|
}
|
|
}
|
|
}
|
|
/*=========================== print ==================================*/
|
|
static int printBuffer(pExeMan self, SConnection *pCon,
|
|
int argc, char *argv[]){
|
|
pDynString filePath = NULL;
|
|
char pLine[512];
|
|
pExeBuf buf;
|
|
void *pPtr = NULL;
|
|
FILE *fd = NULL;
|
|
|
|
if(argc < 3){
|
|
if(self->exeStackPtr >= 0) {
|
|
DynarGet(self->exeStack,self->exeStackPtr,&pPtr);
|
|
buf = (pExeBuf) pPtr;
|
|
if(buf != NULL){
|
|
filePath = locateBatchBuffer(self,exeBufName(buf));
|
|
}
|
|
} else {
|
|
SCWrite(pCon,"ERROR: no default buffer to print, argument required",eError);
|
|
return 0;
|
|
}
|
|
} else {
|
|
filePath = locateBatchBuffer(self,argv[2]);
|
|
}
|
|
if(filePath == NULL){
|
|
snprintf(pLine,255,"ERROR: batch buffer %s not found in path",
|
|
argv[2]);
|
|
SCWrite(pCon,pLine,eError);
|
|
return 0;
|
|
}
|
|
|
|
fd = fopen(GetCharArray(filePath),"r");
|
|
if(fd == NULL){
|
|
SCWrite(pCon,"ERROR: failed to open file for printing",eError);
|
|
DeleteDynString(filePath);
|
|
return 0;
|
|
}
|
|
while(fgets(pLine,511,fd) != NULL){
|
|
SCWrite(pCon,pLine,eValue);
|
|
}
|
|
fclose(fd);
|
|
DeleteDynString(filePath);
|
|
return 1;
|
|
}
|
|
/*========================== run stack ===============================*/
|
|
static int enqueueBuffer(pExeMan self, SConnection *pCon,
|
|
int argc, char *argv[]){
|
|
pExeBuf buf = NULL;
|
|
int status;
|
|
pDynString filePath = NULL;
|
|
|
|
if(SCGetRights(pCon) > usUser){
|
|
SCWrite(pCon,"ERROR: no permission to enque buffers",eError);
|
|
return 0;
|
|
}
|
|
if(argc < 3) {
|
|
SCWrite(pCon,"ERROR: no buffer file given to enqueue ",eError);
|
|
return 0;
|
|
}
|
|
|
|
filePath = locateBatchBuffer(self,argv[2]);
|
|
if(filePath == NULL){
|
|
SCWrite(pCon,"ERROR: failed to locate buffer to enqueue",eError);
|
|
return 0;
|
|
}
|
|
|
|
buf = exeBufCreate("enqueue");
|
|
if(buf == NULL){
|
|
SCWrite(pCon,"ERROR: out of memory",eError);
|
|
return 0;
|
|
}
|
|
status = exeBufLoad(buf,GetCharArray(filePath));
|
|
DeleteDynString(filePath);
|
|
if(status != 1) {
|
|
SCWrite(pCon,"ERROR: failed to load buffer",eError);
|
|
return 0;
|
|
}
|
|
LLDnodeAppendFrom(self->runList,&buf);
|
|
return 1;
|
|
}
|
|
/*--------------------------------------------------------------------*/
|
|
static void clearQueue(pExeMan self){
|
|
pExeBuf buf = NULL;
|
|
int status;
|
|
|
|
status = LLDnodePtr2First(self->runList);
|
|
while(status != 0) {
|
|
LLDnodeDataTo(self->runList,&buf);
|
|
if(buf != NULL){
|
|
exeBufDelete(buf);
|
|
}
|
|
LLDnodeDelete(self->runList);
|
|
status = LLDnodePtr2Next(self->runList);
|
|
}
|
|
/*
|
|
A second time round. This is a workaround for some
|
|
dodgy behaviour of the list system.
|
|
*/
|
|
status = LLDnodePtr2First(self->runList);
|
|
while(status != 0) {
|
|
LLDnodeDataTo(self->runList,&buf);
|
|
if(buf != NULL){
|
|
exeBufDelete(buf);
|
|
}
|
|
LLDnodeDelete(self->runList);
|
|
status = LLDnodePtr2Next(self->runList);
|
|
}
|
|
}
|
|
/*--------------------------------------------------------------------*/
|
|
static int execQueue(pExeMan self, SConnection *pCon, SicsInterp *pSics){
|
|
pExeBuf buf = NULL;
|
|
int status;
|
|
|
|
if(self->exeStackPtr >= 0){
|
|
SCWrite(pCon,
|
|
"ERROR: cannot start queue while batch buffers are still running",eError);
|
|
return 0;
|
|
}
|
|
if(!SCMatchRights(pCon,usUser)){
|
|
return 0;
|
|
}
|
|
|
|
while(LLDnodePtr2First(self->runList) != 0){
|
|
LLDnodeDataTo(self->runList,&buf);
|
|
LLDnodeDelete(self->runList);
|
|
self->exeStackPtr++;
|
|
if(buf == NULL){
|
|
SCWrite(pCon,
|
|
"ERROR: serious trouble, buffer not in queue, inform programmer",eError);
|
|
return 0;
|
|
}
|
|
DynarPut(self->exeStack,self->exeStackPtr,buf);
|
|
status = exeBufProcess(buf,pSics,pCon,self->pCall);
|
|
self->exeStackPtr--;
|
|
if(SCGetInterrupt(pCon) >= eAbortBatch){
|
|
SCWrite(pCon,"ERROR: queue processing interrupted",eError);
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
/*========================== interpreter action =======================*/
|
|
int ExeManagerWrapper(SConnection *pCon, SicsInterp *pSics, void *pData,
|
|
int argc, char *argv[]){
|
|
pExeMan self = NULL;
|
|
char pBufferName[256];
|
|
int status;
|
|
|
|
self = (pExeMan)pData;
|
|
assert(self != NULL);
|
|
|
|
strncpy(pBufferName,argv[1],255);
|
|
if(argc > 1){
|
|
strtolower(argv[1]);
|
|
status = handleBatchPath(self,pCon,argc,argv);
|
|
if(status >= 0){
|
|
return status;
|
|
}
|
|
if(strcmp(argv[1],"interest") == 0){
|
|
registerCallbacks(pCon,pSics,self);
|
|
SCSendOK(pCon);
|
|
return 1;
|
|
} else if(strcmp(argv[1],"uninterest") == 0){
|
|
unregisterCallbacks(pCon,self);
|
|
SCSendOK(pCon);
|
|
return 1;
|
|
}else if(strcmp(argv[1],"upload") == 0){
|
|
status = startUpload(self,pCon);
|
|
if(status){
|
|
SCSendOK(pCon);
|
|
}
|
|
return status;
|
|
}else if(strcmp(argv[1],"append") == 0){
|
|
status = appendLine(self,pCon,argc,argv);
|
|
if(status){
|
|
SCSendOK(pCon);
|
|
}
|
|
return status;
|
|
}else if(strcmp(argv[1],"save") == 0){
|
|
status = uploadSave(self,pCon,argc,argv);
|
|
if(status){
|
|
SCSendOK(pCon);
|
|
}
|
|
return status;
|
|
}else if(strcmp(argv[1],"info") == 0){
|
|
status = infoHandler(self,pCon,argc,argv);
|
|
return status;
|
|
}else if(strcmp(argv[1],"print") == 0){
|
|
status = printBuffer(self,pCon,argc,argv);
|
|
return status;
|
|
}else if(strcmp(argv[1],"enqueue") == 0){
|
|
status = enqueueBuffer(self,pCon,argc,argv);
|
|
if(status){
|
|
SCSendOK(pCon);
|
|
}
|
|
return status;
|
|
}else if(strcmp(argv[1],"clear") == 0){
|
|
clearQueue(self);
|
|
SCSendOK(pCon);
|
|
return 1;
|
|
}else if(strcmp(argv[1],"queue") == 0){
|
|
printQueue(self,pCon);
|
|
SCSendOK(pCon);
|
|
return 1;
|
|
}else if(strcmp(argv[1],"run") == 0){
|
|
status = execQueue(self,pCon,pSics);
|
|
if(status){
|
|
SCSendOK(pCon);
|
|
}
|
|
return status;
|
|
} else {
|
|
status = runBatchBuffer(self,pCon,pSics,pBufferName);
|
|
if(self->exeStackPtr < 0){
|
|
SCWrite(pCon,"EXE TERMINATED",eWarning);
|
|
}
|
|
return status;
|
|
}
|
|
} else {
|
|
SCWrite(pCon,"ERROR: need argument to manage batch buffers",eError);
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|