ostream& operator<< (ostream& out, const AttributeValue& sv) {
AttributeValue* svp = (AttributeValue*)&sv;
char* title;
char* symbol;
int counter;
#if 0
switch( svp->type() )
{
case AttributeValue::KeywordType:
out << "Keyword (" << symbol_pntr( svp->symbol_ref() ) <<
")";
break;
case AttributeValue::CommandType:
title = "Command (";
symbol = symbol_pntr( svp->symbol_ref() );
out << title << symbol;
counter = strlen(title) + strlen(symbol);
while( ++counter < 32 ) out << ' ';
out << ")";
break;
case AttributeValue::SymbolType:
out << "symbol (" << svp->symbol_ptr() << ")";
break;
case AttributeValue::StringType:
out << "string (" << svp->string_ptr() << ")";
break;
case AttributeValue::BooleanType:
out << "boolean (" << svp->boolean_ref() << ")";
break;
case AttributeValue::CharType:
out << "char (" << svp->char_ref() << ":" << (int)svp->char_ref() << ")";
break;
case AttributeValue::UCharType:
out << "uchar (" << svp->char_ref() << ":" << (int)svp->char_ref() << ")";
break;
case AttributeValue::IntType:
out << "int (" << svp->int_ref() << ")";
break;
case AttributeValue::UIntType:
if (svp->state()==AttributeValue::OctState)
out << "uint (" << svp->uint_ref() << ")";
else if (svp->state()==AttributeValue::HexState)
out << "uint (" << svp->uint_ref() << ")";
else
out << "uint (" << svp->uint_ref() << ")";
break;
case AttributeValue::LongType:
out << "Long (" << svp->long_ref() << ")";
break;
case AttributeValue::ULongType:
out << "ulong (" << svp->ulong_ref() << ")";
break;
case AttributeValue::FloatType:
out << "float (" << svp->float_ref() << ")";
break;
case AttributeValue::DoubleType:
out << "double (" << svp->double_ref() << ")";
//printf("%9.2f\n", svp->double_ref());
break;
case AttributeValue::EofType:
out << "eof";
break;
case AttributeValue::ArrayType:
{
out << "list of length " << svp->array_len();
ALIterator i;
AttributeValueList* avl = svp->array_val();
avl->First(i);
boolean first = true;
while (!avl->Done(i)) {
out << "\n\t" << *avl->GetAttrVal(i);
avl->Next(i);
}
}
break;
case AttributeValue::BlankType:
break;
default:
break;
}
#else
switch(svp->type()) {
case AttributeValue::KeywordType:
out << "Keyword (" << symbol_pntr( svp->symbol_ref() ) <<
")";
break;
case AttributeValue::CommandType:
title = "Command (";
symbol = symbol_pntr( svp->symbol_ref() );
out << title << symbol;
counter = strlen(title) + strlen(symbol);
while( ++counter < 32 ) out << ' ';
out << ")";
break;
case AttributeValue::SymbolType:
out << svp->symbol_ptr();
break;
case AttributeValue::StringType:
out << "\"" << svp->string_ptr() << "\"";
break;
case AttributeValue::CharType:
out << svp->char_ref();
break;
case AttributeValue::UCharType:
out << svp->char_ref();
break;
case AttributeValue::IntType:
out << svp->int_ref();
break;
case AttributeValue::UIntType:
if (svp->state()==AttributeValue::OctState)
out << "0" << std::oct << svp->uint_ref() << std::dec;
else if (svp->state()==AttributeValue::HexState)
out << "0x" << std::hex << svp->uint_ref() << std::dec;
else
out << svp->uint_ref();
break;
case AttributeValue::BooleanType:
out << svp->uint_ref();
break;
case AttributeValue::ShortType:
out << svp->short_ref();
break;
case AttributeValue::UShortType:
if (svp->state()==AttributeValue::OctState)
out << "0" << std::oct << svp->ushort_ref() << std::dec;
else if (svp->state()==AttributeValue::HexState)
out << "0x" << std::hex << svp->ushort_ref() << std::dec;
else
out << svp->ushort_ref();
break;
case AttributeValue::LongType:
out << svp->long_ref();
break;
case AttributeValue::ULongType:
if (svp->state()==AttributeValue::OctState)
out << "0" << std::oct << svp->ulong_ref() << std::dec;
else if (svp->state()==AttributeValue::HexState)
out << "0x" << std::hex << svp->ulong_ref() << std::dec;
else
out << svp->ulong_ref();
break;
case AttributeValue::FloatType:
#if __GNUG__<3
out.form("%.6f", svp->float_val());
#else
{
const int bufsiz=256;
char buffer[bufsiz];
snprintf(buffer, bufsiz, "%.6f", svp->float_val());
out << buffer;
}
#endif
break;
case AttributeValue::DoubleType:
#if __GNUG__<3
out.form("%.6f", svp->double_val());
#else
{
const int bufsiz=256;
char buffer[bufsiz];
snprintf(buffer, bufsiz, "%.6f", svp->double_val());
out << buffer;
}
#endif
break;
case AttributeValue::EofType:
out << "eof";
break;
case AttributeValue::ArrayType:
{
//out << "array of length " << svp->array_len();
ALIterator i;
AttributeValueList* avl = svp->array_val();
avl->First(i);
boolean first = true;
while (!avl->Done(i)) {
if (!first)
out << ",";
out << *avl->GetAttrVal(i);
avl->Next(i);
first = false;
}
}
break;
case AttributeValue::BlankType:
break;
case AttributeValue::ObjectType:
out << "<" << symbol_pntr(svp->class_symid()) << ">";
break;
case AttributeValue::StreamType:
out << "<stream:" << svp->stream_mode() << ">";
break;
default:
out << "nil";
break;
}
#endif
return out;
}
void VarFunc::execute() {
ComValue vallist(stack_arg(0));
reset_stack();
if (vallist.is_type(ComValue::ArrayType)) {
AttributeValueList* avl = vallist.array_val();
AddFunc addfunc(comterp());
MpyFunc mpyfunc(comterp());
ComValue sqrsumval(ComValue::zeroval());
ComValue sumval(ComValue::zeroval());
ComValue mnsquaresval;
Iterator it;
int count = 0;
for (avl->First(it); !avl->Done(it); avl->Next(it)) {
count++;
/* square value and add to sum of squares */
push_stack(*avl->GetAttrVal(it));
push_stack(*avl->GetAttrVal(it));
mpyfunc.exec(2,0);
push_stack(sqrsumval);
addfunc.exec(2,0);
sqrsumval = comterp()->pop_stack();
/* add value to running sum */
push_stack(sumval);
push_stack(*avl->GetAttrVal(it));
addfunc.exec(2,0);
sumval = comterp()->pop_stack();
}
/* compute mean of squares */
DivFunc divfunc(comterp());
push_stack(sqrsumval);
ComValue countval((float)count);
push_stack(countval);
divfunc.exec(2,0);
mnsquaresval = comterp()->pop_stack();
/* compute mean squared */
push_stack(sumval);
push_stack(countval);
divfunc.exec(2,0);
ComValue meanval(comterp()->pop_stack());
push_stack(meanval);
push_stack(meanval);
mpyfunc.exec(2,0);
ComValue mnsquaredval(comterp()->pop_stack());
/* subract mean squared from sum of squares to get variance */
SubFunc subfunc(comterp());
push_stack(mnsquaresval);
push_stack(mnsquaredval);
subfunc.exec(2,0);
/* compute standard deviation if StdDevFunc */
if (_stddevfunc) {
SqrtFunc sqrtfunc(comterp());
sqrtfunc.exec(1,0);
}
} else {
push_stack(ComValue::zeroval());
}
}
void CreateRasterFunc::execute() {
const int x0 = 0;
const int y0 = 1;
const int x1 = 2;
const int y1 = 3;
const int n = 4;
int coords[n];
ComValue& vect = stack_arg(0);
if (!vect.is_type(ComValue::ArrayType) || vect.array_len() != n) {
reset_stack();
push_stack(ComValue::nullval());
return;
}
ALIterator i;
AttributeValueList* avl = vect.array_val();
avl->First(i);
for (int j=0; j<n && !avl->Done(i); j++) {
coords[j] = avl->GetAttrVal(i)->int_val();
avl->Next(i);
}
AttributeList* al = stack_keys();
Resource::ref(al);
reset_stack();
PasteCmd* cmd = nil;
if (coords[x0] != coords[x1] || coords[y0] != coords[y1]) {
float dcoords[n];
((OverlayViewer*)GetEditor()->GetViewer())->ScreenToDrawing
(coords[x0], coords[y0], dcoords[x0], dcoords[y0]);
((OverlayViewer*)GetEditor()->GetViewer())->ScreenToDrawing
(coords[x1], coords[y1], dcoords[x1], dcoords[y1]);
OverlayRaster* raster =
new OverlayRaster((int)(dcoords[x1]-dcoords[x0]+1),
(int)(dcoords[y1]-dcoords[y0]+1),
2 /* initialize with border of 2 */);
OverlayRasterRect* rasterrect = new OverlayRasterRect(raster, stdgraphic);
#if 1
Transformer* t = new Transformer();
t->Translate(dcoords[x0], dcoords[y0]);
rasterrect->SetTransformer(t);
Unref(t);
#else
Transformer* rel = get_transformer(al);
#endif
RasterOvComp* comp = new RasterOvComp(rasterrect);
comp->SetAttributeList(al);
if (PasteModeFunc::paste_mode()==0)
cmd = new PasteCmd(_ed, new Clipboard(comp));
ComValue compval(new OverlayViewRef(comp), symbol_add("RasterComp"));
push_stack(compval);
execute_log(cmd);
} else
push_stack(ComValue::nullval());
Unref(al);
}
void SelectFunc::execute() {
static int all_symid = symbol_add("all");
ComValue all_flagv(stack_key(all_symid));
boolean all_flag = all_flagv.is_true();
static int clear_symid = symbol_add("clear");
ComValue clear_flagv(stack_key(clear_symid));
boolean clear_flag = clear_flagv.is_true();
Selection* sel = _ed->GetViewer()->GetSelection();
if (clear_flag) {
sel->Clear();
unidraw->Update();
reset_stack();
return;
}
OverlaySelection* newSel = ((OverlayEditor*)_ed)->overlay_kit()->MakeSelection();
Viewer* viewer = _ed->GetViewer();
AttributeValueList* avl = new AttributeValueList();
if (all_flag) {
GraphicView* gv = ((OverlayEditor*)_ed)->GetFrame();
Iterator i;
int count=0;
for (gv->First(i); !gv->Done(i); gv->Next(i)) {
GraphicView* subgv = gv->GetView(i);
newSel->Append(subgv);
OverlayComp* comp = (OverlayComp*)subgv->GetGraphicComp();
ComValue* compval = new ComValue(new OverlayViewRef(comp), comp->classid());
avl->Append(compval);
}
} else if (nargs()==0) {
Iterator i;
int count=0;
for (sel->First(i); !sel->Done(i); sel->Next(i)) {
GraphicView* grview = sel->GetView(i);
OverlayComp* comp = grview ? (OverlayComp*)grview->GetSubject() : nil;
ComValue* compval = comp ? new ComValue(new OverlayViewRef(comp), comp->classid()) : nil;
if (compval) {
avl->Append(compval);
}
delete newSel;
newSel = nil;
}
} else {
for (int i=0; i<nargsfixed(); i++) {
ComValue& obj = stack_arg(i);
if (obj.object_compview()) {
ComponentView* comview = (ComponentView*)obj.obj_val();
OverlayComp* comp = (OverlayComp*)comview->GetSubject();
if (comp) {
GraphicView* view = comp->FindView(viewer);
if (view) {
newSel->Append(view);
ComValue* compval = new ComValue(new OverlayViewRef(comp), comp->classid());
avl->Append(compval);
}
}
} else if (obj.is_array()) {
Iterator it;
AttributeValueList* al = obj.array_val();
al->First(it);
while (!al->Done(it)) {
if (al->GetAttrVal(it)->object_compview()) {
ComponentView* comview = (ComponentView*)al->GetAttrVal(it)->obj_val();
OverlayComp* comp = (OverlayComp*)comview->GetSubject();
if (comp) {
GraphicView* view = comp->FindView(viewer);
if (view) {
newSel->Append(view);
ComValue* compval = new ComValue(new OverlayViewRef(comp), comp->classid());
avl->Append(compval);
}
}
}
al->Next(it);
}
}
}
}
if (newSel){
sel->Clear();
delete sel;
_ed->SetSelection(newSel);
newSel->Update(viewer);
unidraw->Update();
}
reset_stack();
ComValue retval(avl);
push_stack(retval);
}
void PrintFunc::execute() {
ComValue formatstr(stack_arg(0));
static int str_symid = symbol_add("str");
ComValue strflag(stack_key(str_symid));
static int string_symid = symbol_add("string");
ComValue stringflag(stack_key(string_symid));
static int sym_symid = symbol_add("sym");
ComValue symflag(stack_key(sym_symid));
static int symbol_symid = symbol_add("symbol");
ComValue symbolflag(stack_key(symbol_symid));
static int err_symid = symbol_add("err");
ComValue errflag(stack_key(err_symid));
static int out_symid = symbol_add("out");
ComValue outflag(stack_key(out_symid));
static int file_symid = symbol_add("file");
ComValue fileobjv(stack_key(file_symid));
static int prefix_symid = symbol_add("prefix");
ComValue prefixv(stack_key(prefix_symid));
const char* fstr = formatstr.is_string() ? formatstr.string_ptr() : "nil";
ComValue::comterp(comterp());
streambuf* strmbuf = nil;
if (stringflag.is_false() && strflag.is_false() &&
symbolflag.is_false() && symflag.is_false()) {
if (comterp()->handler() && fileobjv.is_unknown() && errflag.is_false() && outflag.is_false()) {
FILEBUFP(fbuf, comterp()->handler() && comterp()->handler()->wrfptr()
? comterp()->handler()->wrfptr() : stdout, ios_base::out);
strmbuf = fbuf;
} else if (fileobjv.is_known()) {
FileObj *fileobj = (FileObj*)fileobjv.geta(FileObj::class_symid());
if (fileobj) {
FILEBUFP(fbuf, fileobj->fptr(), ios_base::out);
strmbuf = fbuf;
} else {
PipeObj *pipeobj = (PipeObj*)fileobjv.geta(PipeObj::class_symid());
FILEBUFP(fbuf, pipeobj ? pipeobj->wrfptr() : stdout, ios_base::out);
strmbuf = fbuf;
}
} else {
FILEBUFP(fbuf, errflag.is_false() ? stdout : stderr, ios_base::out);
strmbuf = fbuf;
}
} else
strmbuf = new std::strstreambuf();
ostream out(strmbuf);
int narg = nargsfixed();
if (narg==1) {
if (formatstr.is_string() && !prefixv.is_string()) {
out << formatstr.symbol_ptr();
out.flush();
}
else {
if (prefixv.is_string()) out << prefixv.symbol_ptr();
out << formatstr; // which could be arbitrary ComValue
if (prefixv.is_string()) out << "\n";
}
} else {
const char* fstrptr = fstr;
int curr=1;
while (curr<narg) {
char fbuf[BUFSIZ];
ComValue printval(stack_arg(curr));
curr++;
int i=0;
if(curr<narg) {
int flen;
while(*fstrptr && !(flen=format_extent(fstrptr)) && i<BUFSIZ-1) fbuf[i++] = *fstrptr++;
if(*fstrptr && flen+i<BUFSIZ-1) {
strncpy(fbuf+i, fstrptr, flen);
i += flen;
fstrptr += flen;
}
while(*fstrptr && !format_extent(fstrptr) && i<BUFSIZ-1) fbuf[i++] = *fstrptr++;
fbuf[i] = '\0';
} else
strncpy(fbuf, fstrptr, BUFSIZ);
switch( printval.type() )
{
case ComValue::SymbolType:
case ComValue::StringType:
out_form(out, fbuf, symbol_pntr( printval.symbol_ref()));
break;
case ComValue::BooleanType:
out_form(out, fbuf, printval.boolean_ref());
break;
case ComValue::CharType:
out_form(out, fbuf, printval.char_ref());
break;
case ComValue::UCharType:
out_form(out, fbuf, printval.uchar_ref());
break;
case ComValue::IntType:
out_form(out, fbuf, printval.int_ref());
break;
case ComValue::UIntType:
out_form(out, fbuf, printval.uint_ref());
break;
case ComValue::LongType:
out_form(out, fbuf, printval.long_ref());
break;
case ComValue::ULongType:
out_form(out, fbuf, printval.ulong_ref());
break;
case ComValue::FloatType:
out_form(out, fbuf, printval.float_ref());
break;
case ComValue::DoubleType:
out_form(out, fbuf, printval.double_ref());
break;
case ComValue::ArrayType:
{
ALIterator i;
AttributeValueList* avl = printval.array_val();
avl->First(i);
boolean first = true;
while (!avl->Done(i)) {
ComValue val(*avl->GetAttrVal(i));
push_stack(formatstr);
push_stack(val);
exec(2,0);
avl->Next(i);
if (!avl->Done(i)) out << "\n";
}
}
break;
case ComValue::BlankType:
out << "<blank>";
break;
case ComValue::UnknownType:
out_form(out, fbuf, nil);
break;
case ComValue::ObjectType:
out_form(out, fbuf, symbol_pntr(printval.class_symid()));
break;
default:
break;
}
}
}
reset_stack();
if (stringflag.is_true() || strflag.is_true()) {
out << '\0';
ComValue retval(((std::strstreambuf*)strmbuf)->str());
push_stack(retval);
} else if (symbolflag.is_true() || symflag.is_true()) {
out << '\0';
int symbol_id = symbol_add(((std::strstreambuf*)strmbuf)->str());
ComValue retval(symbol_id, ComValue::SymbolType);
push_stack(retval);
} else {
out.flush();
push_stack(ComValue::blankval());
}
delete strmbuf;
}
