home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Power-Programmierung
/
CD1.mdf
/
magazine
/
drdobbs
/
1991
/
10
/
actor.asc
< prev
next >
Wrap
Text File
|
1991-09-10
|
13KB
|
439 lines
_ENHANCING THE ACTOR DEVELOPMENT ENVIRONMENT_
by Steve Hatchett
[LISTING ONE]
/* EXTEND.LOD - Actor development extensions load file
* Copyright(C) 1991 Steve Hatchett. All rights reserved.
* Steve Hatchett 14352 Mussey Grade Rd.
* CIS: 70304,1423 Ramona, CA 92065
* Use this file to load the development environment
* extensions for use with the Actor programming
* language.
* load("extend.lod");
* load();
*/
#define MAXSOURCENEST 5; /* max directory nesting */
Actor[#Programmer] := " "; /* set this in workspace */
Actor[#StampText] := "Stamp";/* time stamp header. Another
* useful stamp header would be
* "Copyright (C) 1991 XYZ, Inc."*/
LoadFiles :=
{
/* Your path may be different. */
load(new(SourceFile),"c:\actor\general\classes\string.clx");
load(#("classes\extsource.cls"
"c:\actor\general\classes\symbol.clx"));
/* The minimum code necessary to navigate the directory
* hierarchy has now been loaded, paths are no longer needed. */
do(#(Behavior Browser ClassDialog ClVarDialog Function
SourceFile System ToolWind WorkEdit), {using(cl)
loadExtensions(cl);
});
}!!
[LISTING TWO]
/* EXTSOURCE.CLS - Actor development extensions
Copyright (C) 1991 Steve Hatchett. All rights reserved.
Provides access to class source code. Allows the source code for a class
to be contained in more than one file ordered hierarchically by directory
structure. There is one .cls file containing the actual class definition.
Additional .clx files may be exist at lower levels of the hierarchy. They
can contain methods and class initialization code. */!!
inherit(Object, #ExtSourceFiler,
#(clName /* Name of class being handled. */
ownsClass /* True if the .cls file for class is
in this session's directory. */
fileNames /* Source code file names with paths. */
ownsLast /* True if we owned the last method
we read. */), 2, nil)!!
now(class(ExtSourceFiler))!!
/* Return a new ExtSourceFiler, initialized to handle source code for the
class whose name Symbol was given. */
Def openClass(self className)
{
^init(new(self),className);
} !!
now(ExtSourceFiler)!!
/* Load class extension files (.clx) for the class, but don't load the class
file (.cls). This is useful for loading extensions to the standard
Actor classes. Looks for all files in CLASSES subdirectories. */
Def loadExtensions(self | work fNames fnm)
{
work := loadString(332);
if size(fileNames) > 0
cand subString(first(fileNames),0,size(work))=work
fileNames[0] := loadString(331) + getFileName(self);
if not(exists(File,fileNames[0],0))
removeFirst(fileNames);
endif;
endif;
if size(fileNames) > 0
fNames := copy(fileNames);
fnm := last(fNames);
if fnm[size(fnm)-1] == 's'
pop(fNames); /* removes the .cls file */
endif;
^do(reverse(fNames), {using(fnm)
load(new(SourceFile),fnm);
});
endif;
^nil;
}!!
/* Recompile the class by loading all its source code.
Looks in WORK for own source file if class is dirty. */
Def recompile(self)
{
^do(reverse(fileNames), {using(fnm)
load(new(SourceFile),fnm);
});
}!!
/* Return open SourceFile with given file name (which should include path). */
Def openSourceFile(self fName | sFile)
{
sFile := new(SourceFile);
setName(sFile,fName);
if not(open(sFile,0))
errorBox(loadString(311), clName
+ loadString(312)+fName+".");
^nil;
endif;
^sFile;
}!!
/* If no source file exists for the class at the directory level of this actor
session, then create an extension file in WORK, and mark class as dirty. */
Def mustHaveOwn(self | sFile)
{
if size(fileNames) == 0
cor first(fileNames)[0] == '.'
add(DirtyClasses,clName);
insert(fileNames,loadString(332)
+subString(clName,0,8)+".clx",0);
makeClassExtFile(new(SourceFile),self);
endif;
}!!
/* Replace the the fSym method text with methtext, or add method text if it
wasn't already in source file. Mode determines whether method is a class or
object method. These changes will only be made in the source file owned by
this actor session. Returns nil if not successful. */
Def saveMethText(self methtext fSym mode | rFile wFile)
{
mustHaveOwn(self);
if (rFile := openClass(SourceFile,self))
wFile := saveMethText(rFile,methtext,fSym,mode);
reName(wFile,(fileNames[0] := condDelCFile(rFile,self)));
endif;
^rFile;
}!!
/* Replace the the class initialization code, with given code. Change will
only be made in source file owned by this actor session. Returns nil if
not successful. */
Def replaceClassInit(self text | rFile wFile)
{
mustHaveOwn(self);
if (rFile := openClass(SourceFile,self))
wFile := replaceClassInit(rFile,text);
reName(wFile,(fileNames[0] := condDelCFile(rFile,self)));
close(rFile);
endif;
^rFile;
}!!
/* Return the class init code for this class as a TextCollection. */
Def readClassInit(self | rFile text)
{
/* look through source files until some class initialization text is found. */
ownsLast := false;
do(fileNames,{using(fnm)
if (rFile := openSourceFile(self,fnm))
text := readClassInit(rFile);
close(rFile);
if size(text) > 0
ownsLast := (fnm[0] <> '.');
^text;
endif;
endif;
});
^new(TextCollection,5);
}!!
/* Remove the fSym method text if it is found in source file owned by this
actor session. Mode determines whether method is a class or object method.
Returns nil if not successful or if method was not in owned source file. */
Def removeMethod(self fSym mode | rFile wFile)
{
if size(fileNames) > 0
cand first(fileNames)[0] <> '.'
cand (rFile := openClass(SourceFile,self))
if wFile := replaceMethod(rFile,nil,fSym,mode)
reName(wFile,(fileNames[0] := condDelCFile(rFile,self)));
endif;
close(rFile);
endif;
^wFile;
}!!
/* Load the class by loading all its source code. Looks in CLASSES for
all source files. */
Def load(self | work)
{
work := loadString(332);
if size(fileNames) > 0
cand subString(first(fileNames),0,size(work))=work
fileNames[0] := loadString(331) + getFileName(self);
if not(exists(File,fileNames[0],0))
removeFirst(fileNames);
endif;
endif;
^do(reverse(fileNames), {using(fnm)
load(new(SourceFile),fnm);
});
}
!!
/* Return true if the last method read using loadMethText was from a source
file at directory level of this actor session. */
Def ownsLast(self)
{
^ownsLast;
}!!
/* Initialize a new ExtSourceFiler. */
Def init(self nm | metaNm)
{
if class(nm) <> Symbol
nm := name(nm);
endif;
if (metaNm := isMetaName(nm))
clName := name(value(metaNm));
else
clName := nm;
endif;
getFileNames(self);
}!!
/* Return true if the .cls file for the class this filer is handling exists
at the directory level of this actor session. */
Def ownsClass(self)
{
^ownsClass;
}!!
/* Return text of aMethod. Note accordingly if source code is missing. Mode
indicates type of method, either class (BR_CMETH) or object (BR_OMETH). Looks
through all the source files for the class. */
Def loadMethText(self aMethod mode | text rFile)
{
/* look through source files until the text for the given method is found. */
ownsLast := false;
rFile := new(SourceFile);
do(fileNames,{using(fnm)
if not(rFile := openSourceFile(self,fnm))
errorBox(loadString(311), clName
+loadString(312)+fnm+".");
else
text := findMethod(rFile,aMethod,mode);
close(rFile);
if text
ownsLast := (fnm[0] <> '.');
^leftJustify(text[0]);
endif;
endif;
});
^aMethod + loadString(310);
}!!
/* Return the class's name the way Behavior would do it. */
Def name(self)
{
^clName;
}!!
/* Return the class's filename the way Behavior would do it. */
Def getFileName(self | dir)
{
/* return name + ext */
^subString(clName,0,8)
+ if ownsClass
".cls" else ".clx" endif;
}!!
/* Get the names of the files containing this class' source code. */
Def getFileNames(self | dir fRoot base)
{
fileNames := new(OrderedCollection,MAXSOURCENEST);
dir := loadString(if clName in DirtyClasses
332 else 331 endif);
base := subString(clName,0,8);
fRoot := dir + base;
do(MAXSOURCENEST, {using(i | fnm)
/* if the original .cls file or a .clx file is found for class, add it to list
if it's above this session's directory. */
if exists(File,(fnm:=fRoot+".cls"),0)
add(fileNames,fnm);
if i==0
ownsClass := true;
endif;
^fileNames;
endif;
if exists(File,(fnm:=fRoot+".clx"),0)
add(fileNames,fnm);
endif;
/* construct the path name of the next higher level. */
if i==0
fRoot := "..\classes\"+base;
else
fRoot := "..\"+fRoot;
endif;
});
^fileNames;
}!!
/* Return the names of the files containing this class' source code
(including own source file). */
Def fileNames(self)
{
^fileNames;
}!!
[LISTING THREE]
/* TOOLWIND.CLX - Actor development extensions
*
* Copyright(C) 1991 Steve Hatchett. All rights reserved.
*/!!
now(class(ToolWindow))!!
/* Used by the system to initialize the DirtyClasses
Set backup file. DirtyClasses is assumed to be
empty on entry. For each class found in the backup
file, ask the user whether to re-load the dirty
class file or use the old class file.
swh modified to support extended source files.
swh modified to support unique dirty class file
names between images.
*/
Def loadDirty(self | dName)
{
/* mod for unique dirty file name - base the dirty
* file name on the image name.
*/
setName($DFile,subString(imageName(TheApp),0,
indexOf(imageName(TheApp),'.',0))
+".drt");
/* end mod */
if open($DFile, 0)
then
...
if size(DirtyClasses) > 0
then do(copy(DirtyClasses),
{using(clName)
/* mod for extended source file support - if the dirty
* class exists in the system, let it tell us its file
* name (.cls or .clx), otherwise the class was created
* since the last snapshot, so it should be a .cls file.
*/
dName := loadString(332) + subString(clName,0,8)
+ if not(Classes[clName])
cor isOwnClass(Classes[clName])
".cls" else ".clx" endif;
/* end mod */
dName := loadString(332) + subString(clName,0,8) + ".cls";
...
}!!
now(ToolWindow)!!
/* Insert/overwrite a time stamp as the first line of
the method text.
*/
Def stampMethText(self text fSym mode | stampHead)
{
stampHead := "/*"+StampText;
/* if method doesn't already have a stamp, insert
* a line for it.
*/
if left(text[0],size(stampHead),' ') <> stampHead
insert(text,"",0);
endif;
/* construct the time stamp. */
text[0] := stampHead+" "+timeStamp(System)+" "
+programmer(System)+" "+name(selClass)
+if mode == BR_CMETH
"(Class)" else "" endif
+":"+fSym+" */";
}!!
/* Save the new text for current method into the source
file. The first argument, text, is the method text. The
second, fSym, is the symbol with the name of the method,
e.g. #print. The new or revised method text ends up in a
class source file in WORK. Also, write the text to the
change log.
swh modified to support extended source files
swh modified to support automatic time stamping
*/
Def saveMethText(self, text, fSym | textEnd, nowCl, rFile, wFile)
{...
changeLog(ew, "now(" + nowCl + ")" + Chunk +
subText(text, 0, 0, textEnd, size(text[textEnd])));
/* mod for automatic time stamps
* place time stamp in method text.
*/
if text
stampMethText(self,text,fSym,mode);
endif;
/* end mod */
/* mod to support extended source files */
saveMethText(openClass(ExtSourceFiler,selClass),
text, fSym, mode);
/* end mod */
makeDirty(self);
endif;
^fSym;
}!!
/* ToolWindow class initialization
Rewritten to override ToolWindow.cls class
initialization to support unique dirty file
names between images - base the dirty file
name on the image name.
*/
$DFile := setName(new(TextFile),
subString(imageName(TheApp),0,
indexOf(imageName(TheApp),'.',0))
+".drt");