int readDisk (u64 new_block)
{
off_t offset;
ssize_t bytesRead;
offset = new_block * BlockSize;
if (lseek(Disk, offset, 0) == -1) {
sysError("lseek");
return -1;
}
bytesRead = read(Disk, Block, BlockSize);
if (bytesRead == 0) {
myError("At EOF");
return 0;
}
if (bytesRead == -1) {
sysError("read");
return -1;
}
if (bytesRead < BlockSize) {
bzero( &Block[bytesRead], BlockSize - bytesRead);
}
BlockNum = new_block;
return 0;
}
void executeApplication(char *path, char *directory, char **argv)
{
int pid;
zzz();
XFlush(XtDisplay(toplevel));
if (chdir(directory)) {
wakeUp();
sysError("Can't chdir:");
} else if ((pid = fork()) == -1) {
wakeUp();
sysError("Can't fork:");
} else {
if (!pid) {
if (resources.echo_actions) {
char **arg;
fprintf(stderr, "[%s] %s", directory, path);
for (arg = argv+1; *arg; arg++)
echoarg(*arg);
fprintf(stderr, "\n");
}
/* Make sure that child processes don't lock up xfm with keyboard
input. This is certainly a kludge and if you know of any better
way to do this, please let me know. -ag */
freopen("/dev/null", "r", stdin);
execvp(path, argv);
perror("Exec failed");
exit(1);
} else {
sleep(1);
wakeUp();
}
}
}
static void mkdirOkCb(Widget w, FileWindowRec *fw, XtPointer call_data)
{
XtPopdown(popups.mkdir);
if (chdir(popups.fw->directory))
sysError("Can't change directory:");
else if (mkdir(popups.mkdir_s, S_IRUSR | S_IWUSR | S_IXUSR))
sysError("Can't make directory");
else {
clearUpdateMarks();
markForUpdate(popups.fw->directory);
intUpdate();
}
}
static void renameOkCb(Widget w, FileWindowRec *fw, XtPointer call_data)
{
XtPopdown(popups.rename);
if (chdir(popups.fw->directory))
sysError("Can't change directory:");
else if (rename(popups.rename_file, popups.rename_s))
sysError("Can't rename file:");
else {
clearUpdateMarks();
markForUpdate(popups.fw->directory);
intUpdate();
}
}
void renameFileProc(XtPointer fsel, int conf)
{
SelFileNamesRec *fnames = (SelFileNamesRec *) fsel;
struct stat stats;
char to[MAXPATHLEN];
if (conf != YES)
{
freeSelFiles(fnames);
return;
}
if (chdir(fnames->directory))
{
sysError(fnames->shell, "System error:");
freeSelFiles(fnames);
return;
}
chdir(user.home);
if (fnames->target[0] != '/' && fnames->target[0] != '~' && fnames->target != 0)
{
strcpy(to, fnames->directory);
if (to[strlen(to)-1] != '/') strcat(to, "/");
}
else to[0] = 0;
strcat(to, fnames->target);
fnexpand(to);
XTFREE(fnames->target);
fnames->target = XtNewString(to);
if (!(stat(to, &stats)) && S_ISDIR(stats.st_mode))
renameDialog(fnames);
else moveFilesProc(fsel, YES);
}
/*
readDeclaration reads a declaration of a class
*/
static void readClassDeclaration()
{
object classObj, super, vars;
int i, size, instanceTop;
object instanceVariables[15];
if (nextToken() != nameconst)
sysError("bad file format", "no name in declaration");
classObj = findClass(tokenString);
size = 0;
if (nextToken() == nameconst) /* read superclass name */
{
super = findClass(tokenString);
basicAtPut(classObj, superClassInClass, super);
size = intValue(basicAt(super, sizeInClass));
nextToken();
}
if (token == nameconst) /* read instance var names */
{
instanceTop = 0;
while (token == nameconst)
{
instanceVariables[instanceTop++] = newSymbol(tokenString);
size++;
nextToken();
}
vars = newArray(instanceTop);
for (i = 0; i < instanceTop; i++)
{
basicAtPut(vars, i+1, instanceVariables[i]);
}
basicAtPut(classObj, variablesInClass, vars);
}
basicAtPut(classObj, sizeInClass, newInteger(size));
}
bool MemoryManager::destroyObject(object z)
{
register struct ObjectStruct *p;
register int i;
int size;
bool deleted = false;
p = &objectTable[z];
if (p->referenceCount < 0)
{
fprintf(stderr,"object %d\n", static_cast<int>(z));
sysError("negative reference count","");
}
size = p->size;
if (size < 0) size = ((- size) + 1) /2;
if(objectFreeListInv.find(z) == objectFreeListInv.end())
{
objectFreeList.insert(std::pair<size_t, object>(size, z));
objectFreeListInv.insert(std::pair<object, size_t>(z, size));
deleted = true;
}
if (size > 0)
{
for (i = size; i > 0; )
p->memory[--i] = nilobj;
}
p->size = size;
return deleted;
}
/*
fileIn reads in a module definition
*/
void fileIn(FILE *fd, boolean printit)
{
while (fgets(textBuffer, TextBufferSize, fd) != NULL)
{
lexinit(textBuffer);
if (token == inputend)
; /* do nothing, get next line */
else if ((token == binary) && streq(tokenString, "\""))
; /* do nothing, its a comment */
/* Syntax for Class and Methods definitions
Number extend [
radiusToArea [
^self squared * Float pi
]
radiusToCircumference [
^self * 2 * Float pi
]
]
*/
else if ((token == nameconst) && streq(tokenString,"Class"))
readClassDeclaration();
else if ((token == nameconst) && streq(tokenString,"Methods"))
readMethods(fd, printit);
else
sysError("unrecognized line", textBuffer);
}
}
/* initialize the memory management module */
void initMemoryManager()
{
int i;
# ifdef obtalloc
objectTable = obtalloc(ObjectTableMax, sizeof(struct objectStruct));
if (! objectTable)
sysError("cannot allocate","object table");
# endif
/* set all the free list pointers to zero */
for (i = 0; i < FREELISTMAX; i++)
objectFreeList[i] = nilobj;
/* set all the reference counts to zero */
for (i = 0; i < ObjectTableMax; i++)
{
objectTable[i].referenceCount = 0;
objectTable[i].size = 0;
}
/* make up the initial free lists */
setFreeLists();
# ifndef mBlockAlloc
/* force an allocation on first object assignment */
currentMemoryPosition = MemoryBlockSize + 1;
# endif
/* object at location 0 is the nil object, so give it nonzero ref */
objectTable[0].referenceCount = 1;
objectTable[0].size = 0;
}
void fileOpenDir(Widget w, XEvent *event, String *params,Cardinal *num_params)
{
FileWindowRec *fw;
int i;
char path[MAXPATHLEN];
i = findWidget(w, &fw);
if (!fw)
return;
if (chdir(fw->directory) || chdir(fw->files[i]->name))
sysError("Can't open folder:");
else if (!getcwd(path, MAXPATHLEN))
sysError("System error:");
else {
strcpy(fw->directory, path);
updateFileDisplay(fw);
}
}
/*
imageRead - read in an object image
we toss out the free lists built initially,
reconstruct the linkages, then rebuild the free
lists around the new objects.
The only objects with nonzero reference counts
will be those reachable from either symbols
*/
static int fr(FILE* fp, char* p, int s)
{
int r;
r = fread(p, s, 1, fp);
if (r && (r != 1))
sysError("imageRead count error","");
return r;
}
void deleteFilesProc(XtPointer fsel, int conf)
{
SelFileNamesRec *fnames = (SelFileNamesRec *) fsel;
struct stat stats;
String name;
int i;
if (conf != YES)
{
freeSelFiles(fnames);
return;
}
if (chdir(fnames->directory))
{
sysError(fnames->shell, "System error:");
freeSelFiles(fnames);
return;
}
if (!fnames->first)
abort_delete = False;
for (i = fnames->first; i < fnames->n_sel && !abort_delete; i++)
{
if (!(lstat(name = fnames->names[i], &stats)))
{
if (!S_ISLNK(stats.st_mode) && S_ISDIR(stats.st_mode))
{
if (!(strcmp(name, ".")) || !(strcmp(name, "..")))
{
error(fnames->shell, "Cannot delete . or ..", NULL);
continue;
}
fnames->first = i;
chdir(user.home);
deleteDirDialog(fnames, name);
return;
}
else
{
if (unlink(name))
{
if (opError(fnames->shell, "Error deleting", fnames->names[i]) != YES)
break;
}
else fnames->update = True;
}
}
else if (opError(fnames->shell, "Error deleting", fnames->names[i]) != YES)
break;
}
chdir(user.home);
if (fnames->update)
{
markForUpdate(fnames->directory, CHECK_DIR);
intUpdate(CHECK_DIR);
}
freeSelFiles(fnames);
}
void sysErrorAll(
TString anaV="v18ReWt",
TString BckSub="SubEtaReflSingle"
)
{
TString outdir=anaV+BckSub;
gSystem->mkdir(outdir.Data(),kTRUE);
Int_t sysModes[3] = {0,1,2};
TString Ajs[5]= { "0to100","0to11","11to22","22to33","33to100" };
for (Int_t m=0; m<3;++m) {
for (Int_t a=0; a<5; ++a) {
sysError("jfh"+anaV+"_HydjetAll_djcalo_Cent0to30_Aj"+Ajs[a]+"_"+BckSub+".root",0,sysModes[m],outdir);
sysError("jfh"+anaV+"_HydjetAll_djcalo_Cent0to30_Aj"+Ajs[a]+"_"+BckSub+".root",1,sysModes[m],outdir);
sysError("jfh"+anaV+"_HydjetAll_djcalo_genp_Cent0to30_Aj"+Ajs[a]+"_"+BckSub+".root",3,sysModes[m],outdir);
}
}
}
int main( int argc, char **argv ) {
typedef enum Boolean { false, true } Boolean;
Boolean finished = false;
char buffer[1024];
in_port_t listenPort;
int serverSock;
static const char *version = "0.0.1";
static const char *phase = "prealpha";
struct sockaddr_in serverAddr;
if (argc != 2) usage(argv[0]);
listenPort = atoi(argv[1]);
printf("tcpserver -- TCP-based protocol development harness (server) v%s-%s\n", version, phase);
printf("Written by [email protected] -- Released under BSD3\n\n");
if ((serverSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) error("socket()");
memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddr.sin_port = htons(listenPort);
if (bind(serverSock, (struct sockaddr *) &serverAddr, sizeof(serverAddr)) < 0) sysError("bind()");
if (listen(serverSock, _TCPDEV_MAXCONN) < 0) sysError("listen()");
while (!finished) {
struct sockaddr_in clientAddr;
socklen_t clientAddrLength = sizeof(clientAddr);
int clientSock = accept(serverSock, (struct sockaddr *) &clientAddr, &clientAddrLength);
if (clientSock < 0) sysError("accept()");
char clientName[INET_ADDRSTRLEN];
if (inet_ntop(AF_INET, &clientAddr.sin_addr.s_addr, clientName, sizeof(clientName)) != NULL) {
printf("[+] inbound client: %s:%d\n", clientName, ntohs(clientAddr.sin_port));
} else {
printf("cannot get client address\n");
}
handleTCPClient(clientSock);
}
return 0;
}
void handleTCPClient( int clientSocket ) {
char buffer[_TCPDEV_BUFFERSIZE];
ssize_t numBytesReceived = recv(clientSocket, buffer, _TCPDEV_BUFFERSIZE, 0);
if (numBytesReceived < 0) sysError("recv()");
while (numBytesReceived > 0) {
ssize_t numBytesSent = send(clientSocket, buffer, numBytesReceived, 0);
if (numBytesSent < 0) {
sysError("send()");
} else if (numBytesSent != numBytesReceived) {
userError("send()", "unexpected number of bytes");
}
numBytesReceived = recv(clientSocket, buffer, _TCPDEV_BUFFERSIZE, 0);
if (numBytesReceived < 0) sysError("recv()");
}
close(clientSocket);
}
void* ObjectStruct::cPointerValue()
{
if(NULL == charPtr())
sysError("invalid cPointer","cPointerValue");
void* l;
int s = sizeof(void*);
memcpy((char *) &l, charPtr(), (int) sizeof(void*));
return l;
}
void mkDirProc(XtPointer fnm, int conf)
{
NewFileRec *nfr = (NewFileRec *) fnm;
if (conf == YES)
{
if (chdir(nfr->directory))
sysError(nfr->shell, "Can't change to directory:");
else if (mkdir(nfr->name, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))
sysError(nfr->shell, "Can't make directory:");
else
{
markForUpdate(nfr->directory, CHECK_FILES);
intUpdate(CHECK_DIR);
}
XTFREE(nfr->name);
}
XTFREE(nfr->directory);
XTFREE(nfr);
}
static void chmodOkCb(Widget w, FileWindowRec *fw, XtPointer call_data)
{
mode_t mode;
XtPopdown(chmode.shell);
mode = chmode.fw->files[chmode.file]->stats.st_mode;
mode &= ~(S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IWGRP | S_IXGRP |
S_IROTH | S_IWOTH | S_IXOTH);
mode |= chmode.items[OWNER][READ].value ? S_IRUSR : 0;
mode |= chmode.items[OWNER][WRITE].value ? S_IWUSR : 0;
mode |= chmode.items[OWNER][EXECUTE].value ? S_IXUSR : 0;
mode |= chmode.items[GROUP][READ].value ? S_IRGRP : 0;
mode |= chmode.items[GROUP][WRITE].value ? S_IWGRP : 0;
mode |= chmode.items[GROUP][EXECUTE].value ? S_IXGRP : 0;
mode |= chmode.items[OTHERS][READ].value ? S_IROTH : 0;
mode |= chmode.items[OTHERS][WRITE].value ? S_IWOTH : 0;
mode |= chmode.items[OTHERS][EXECUTE].value ? S_IXOTH : 0;
if (chdir(chmode.fw->directory)) {
sysError("System error:");
goto out;
}
if (chmod(chmode.fw->files[chmode.file]->name, mode)) {
char s[0xff];
sprintf(s, "Can't change modes for %s:",
chmode.fw->files[chmode.file]->name);
sysError(s);
}
else {
markForUpdate(chmode.fw->directory);
intUpdate();
}
out:
freeze = False;
}
object ObjectStruct::basicAt(int i)
{
if(( i <= 0) || (i > size))
{
fprintf(stderr, "Indexing: %d\n", i);
sysError("index out of range", "basicAt");
}
else
return (sysMemPtr()[i-1]);
return nilobj;
}
/*
readDeclaration reads a declaration of a class
*/
static void readClassDeclaration()
{
ObjectHandle classObj, metaObj, vars;
std::string className, superName;
int i, size, instanceTop;
// todo: fixed length variables array!
ObjectHandle instanceVariables[15];
// todo: horrible fixed length arrays!
char metaClassName[100];
char metaSuperClassName[100];
if (ll.nextToken() != nameconst)
sysError("bad file format","no name in declaration");
className = ll.strToken();
if (ll.nextToken() == nameconst)
{ /* read superclass name */
superName = ll.strToken();
ll.nextToken();
}
// todo: sprintf eradication!
sprintf(metaClassName, "Meta%s", className.c_str());
if(!superName.empty())
sprintf(metaSuperClassName, "Meta%s", superName.c_str());
else
sprintf(metaSuperClassName, "Class");
metaObj = createRawClass(metaClassName, "Class", metaSuperClassName);
classObj = createRawClass(className.c_str(), metaClassName, superName.c_str());
classObj->_class = metaObj;
// Get the current class size, we'll build on this as
// we add instance variables.
size = getInteger(classObj->basicAt(sizeInClass));
if (ll.currentToken() == nameconst)
{ /* read instance var names */
instanceTop = 0;
while (ll.currentToken() == nameconst)
{
instanceVariables[instanceTop++] = createSymbol(ll.strToken().c_str());
size++;
ll.nextToken();
}
vars = newArray(instanceTop);
for (i = 0; i < instanceTop; i++)
{
vars->basicAtPut(i+1, instanceVariables[i]);
}
classObj->basicAtPut(variablesInClass, vars);
}
classObj->basicAtPut(sizeInClass, newInteger(size));
classObj->basicAtPut(methodsInClass, newDictionary(39));
}
int initDisk (char *device)
{
Block = emalloc(BlockSize);
DiskName = device;
Disk = open(DiskName, O_RDONLY);
if (Disk == -1) {
sysError(DiskName);
return -1;
}
return 0;
}
void overwriteDTIcons(Boolean all)
{
FILE *fp;
int i;
time_t t;
char name[2*MAXAPPSTRINGLEN], directory[2*MAXAPPSTRINGLEN],
fname[2*MAXAPPSTRINGLEN], icon[2*MAXAPPSTRINGLEN],
push_action[2*MAXAPPSTRINGLEN], drop_action[2*MAXAPPSTRINGLEN];
if (!(fp = fopen(resources.dticon_file, "w")))
{
sysError(getAnyShell(), "Error saving desktop icons:");
return;
}
time(&t);
fprintf(fp, icon_file_header, ctime(&t));
for (i=0; i<n_dtIcons; i++) {
if (all || dtIcons[i]->save) {
expand(name, dtIcons[i]->app.name, "\\:");
expand(directory, dtIcons[i]->app.directory, "\\:");
expand(fname, dtIcons[i]->app.fname, "\\:");
expand(icon, dtIcons[i]->app.icon, "\\:");
expand(push_action, dtIcons[i]->app.push_action, "\\:");
expand(drop_action, dtIcons[i]->app.drop_action, "\\:");
fprintf(fp, "%s:%s:%s:%s:%s:%s:%d:%d\n", name, directory, fname,
icon, push_action, drop_action, dtIcons[i]->x,
dtIcons[i]->y);
dtIcons[i]->save = True;
dtIcons[i]->app.remove_file = False;
}
}
if (fclose(fp))
sysError(getAnyShell(), "Error saving desktop icons:");
dticons_readable = !stat(resources.dticon_file, &dticons_stats);
}
object sysPrimitive(int number, object* arguments)
{
ObjectHandle returnedObject = nilobj;
/* someday there will be more here */
switch(number - 150) {
case 0: /* do a system() call */
returnedObject = newInteger(system(
objectRef(arguments[0]).charPtr()));
break;
case 1: /* editline, with history support */
{
char* command = linenoise_nb(objectRef(arguments[0]).charPtr());
returnedObject = newStString(command);
if(command)
{
linenoiseHistoryAdd(command);
free(command);
}
}
break;
case 2: /* get last error */
{
returnedObject = newStString(gLastError);
}
break;
case 3: /* force garbage collect */
{
MemoryManager::Instance()->garbageCollect();
}
break;
case 4:
{
returnedObject = newInteger(MemoryManager::Instance()->objectCount());
}
break;
case 5:
{
returnedObject = newStString(MemoryManager::Instance()->statsString().c_str());
}
break;
default:
sysError("unknown primitive","sysPrimitive");
}
return(returnedObject);
}
void readDTIcons(void)
{
FILE *fp;
AppRec app;
char *name, *directory, *fname, *icon, *push_action, *drop_action, *xp, *yp;
char s[MAXAPPSTRINGLEN];
int i, p, x, y;
XtAppAddActions(app_context, icon_actions, XtNumber(icon_actions));
trans = XtParseTranslationTable(icon_translations);
dticons_blocked = False;
if (stat(resources.dticon_file, &dticons_stats) ||
!(fp = fopen(resources.dticon_file, "r")))
{
dticons_readable = False;
error(getAnyShell(), "Cannot read desktop icons from", resources.dticon_file);
return;
}
dticons_readable = True;
for (i=0; (p = parseIcon(fp, &name, &directory, &fname, &icon, &push_action, &drop_action, &xp, &yp)) > 0; i++)
{
dtIcons = (DTIconRec **) XTREALLOC(dtIcons, (i+1) * sizeof(DTIconRec *));
app.name = XtNewString(strparse(s, name, "\\:"));
app.directory = XtNewString(strparse(s, directory, "\\:"));
app.fname = XtNewString(strparse(s, fname, "\\:"));
app.icon = XtNewString(strparse(s, icon, "\\:"));
app.push_action = XtNewString(strparse(s, push_action, "\\:"));
app.drop_action = XtNewString(strparse(s, drop_action, "\\:"));
app.objType = getObjectType(app.push_action);
app.remove_file = False;
if ((x = atoi(strparse(s, xp, "\\:"))) < 0)
x += winInfo.rootWidth - DTICONWIDTH;
if ((y = atoi(strparse(s, yp, "\\:"))) < 0)
y += winInfo.rootHeight - DTICONHEIGHT;
dtIcons[i] = createDTIcon(getAnyShell(), &app, x, y);
dtIcons[i]->save = True;
displayDTIcon(dtIcons[i]);
}
if (p == -1)
error(getAnyShell(), "Error reading desktop icons from", resources.dticon_file);
n_dtIcons = i;
if (fclose(fp))
sysError(getAnyShell(), "Error reading desktop icons:");
}
void ObjectStruct::byteAtPut(int i, int x)
{
byte *bp;
if ((i <= 0) || (i > 2 * - size))
{
sysError("index out of range", "byteAtPut");
}
else
{
bp = bytePtr();
bp[i-1] = x;
}
}
void newFileProc(XtPointer fnm, int conf)
{
NewFileRec *nfr = (NewFileRec *) fnm;
int desc;
if (conf == YES)
{
if (chdir(nfr->directory))
sysError(nfr->shell, "Can't change to directory:");
else if ((desc = create(nfr->name, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1)
sysError(nfr->shell, "Can't create file:");
else
{
close(desc);
markForUpdate(nfr->directory, CHECK_FILES);
intUpdate(CHECK_DIR);
}
chdir(user.home);
XTFREE(nfr->name);
}
XTFREE(nfr->directory);
XTFREE(nfr);
}
static int copydir(ino_t *inodes, int n_inodes, struct stat *oldstats,
char *oldpath, char *newpath)
{
DIR *dir;
struct dirent *entry;
int i, ol = strlen(oldpath), nl = strlen(newpath);
struct stat newstats;
for (i = n_inodes-1; i >= 0; i--)
if (inodes[i] == oldstats->st_ino) {
errno = EINVAL;
return -1;
}
if ((mkdir(newpath, user.umask & 0777) < 0 && errno != EEXIST) ||
lstat(newpath, &newstats) ||
!(dir = opendir(oldpath)))
return -1;
inodes = (ino_t *) XTREALLOC(inodes, (n_inodes+1)*sizeof(ino_t));
inodes[n_inodes++] = newstats.st_ino;
for(i = 0; (entry = readdir(dir)); i++)
if (entry->d_name[0] != '.' || (entry->d_name[1] != '\0'
&& (entry->d_name[1] != '.' ||
entry->d_name[2] != '\0'))) {
int ol1 = ol, nl1 = nl, l = strlen(entry->d_name);
char *oldpath1 = (char *)alloca(ol1+l+2);
char *newpath1 = (char *)alloca(nl1+l+2);
strcpy(oldpath1, oldpath);
strcpy(newpath1, newpath);
if (oldpath1[ol1-1] != '/')
oldpath1[ol1++] = '/';
if (newpath1[nl1-1] != '/')
newpath1[nl1++] = '/';
strcpy(oldpath1+ol1, entry->d_name);
strcpy(newpath1+nl1, entry->d_name);
if (copy(inodes, n_inodes, oldpath1, newpath1)) {
/* take care of recursive errors */
char s[0xff];
sprintf(s, "Error copying %s:", oldpath1);
sysError(s);
}
}
inodes = (ino_t *) XTREALLOC(inodes, (n_inodes-1)*sizeof(ino_t));
return closedir(dir);
}
int ObjectStruct::byteAt(int i)
{
byte* bp;
unsigned char t;
if((i <= 0) || (i > 2 * - size))
sysError("index out of range", "byteAt");
else
{
bp = bytePtr();
t = bp[i-1];
i = (int) t;
}
return i;
}
object sysPrimitive(int number, object * arguments)
{
object returnedObject;
/* someday there will be more here */
switch (number - 150) {
case 0: /* do a system() call */
returnedObject = newInteger(system(charPtr(arguments[0])));
break;
default:
sysError("unknown primitive", "sysPrimitive");
}
return (returnedObject);
}
/*
readRawDeclaration reads a declaration of a class
*/
static void readRawClassDeclaration()
{
ObjectHandle classObj, vars;
std::string className, metaName, superName;
int i, size, instanceTop;
// todo: fixed length variables array!
ObjectHandle instanceVariables[15];
if (ll.nextToken() != nameconst)
sysError("bad file format","no name in declaration");
className = ll.strToken();
size = 0;
if (ll.nextToken() == nameconst)
{ /* read metaclass name */
metaName = ll.strToken();
ll.nextToken();
}
if (ll.currentToken() == nameconst)
{ /* read superclass name */
superName = ll.strToken();
ll.nextToken();
}
classObj = createRawClass(className.c_str(), metaName.c_str(), superName.c_str());
// Get the current class size, we'll build on this as
// we add instance variables.
size = getInteger(classObj->basicAt(sizeInClass));
if (ll.currentToken() == nameconst)
{ /* read instance var names */
instanceTop = 0;
while (ll.currentToken() == nameconst)
{
instanceVariables[instanceTop++] = createSymbol(ll.strToken().c_str());
size++;
ll.nextToken();
}
vars = newArray(instanceTop);
for (i = 0; i < instanceTop; i++)
{
vars->basicAtPut(i+1, instanceVariables[i]);
}
classObj->basicAtPut(variablesInClass, vars);
}
classObj->basicAtPut(sizeInClass, newInteger(size));
classObj->basicAtPut(methodsInClass, newDictionary(39));
}
