Instance::Instance(Schedulable &s, const std::string &nm, const Time &t, const Time &d, Channel * const c)
: Notified(s.uberQua)
, schedulable(s)
, startTime(t)
, duration(d)
{
thruEnabled = false;
channel = c;
status = STATUS_SLEEPING;
wokenAt = Time::zero;
wakeDuration = Time::zero;
mainStack = nullptr;
rxStack = nullptr;
wakeStack = nullptr;
sleepStack = nullptr;
startStack = nullptr;
stopStack = nullptr;
cueStack = nullptr;
uberQua = s.uberQua;
std::string nmbuf = glob.makeUniqueName(s.sym, nm != "" ? nm : s.sym->name, 0);
sym = DefineSymbol(nmbuf, TypedValue::S_INSTANCE, 0,
this, s.sym,
TypedValue::REF_VALUE, false, false, StabEnt::DISPLAY_NOT);
// interfaceBridge.SetSymbol(sym);
cerr << "instance " << sym->uniqueName() << " of " << s.sym->name<< " defined at "<< startTime.StringValue() << " on " << channel->chanId << endl;
// keep a list of the standard controllers
// controlVariables = new QuaControllerBridge(s->uberQua, this, nullptr, s->standardControlInfo);
}
Schedulable::Schedulable(StabEnt *s, Qua *q, class Metric *m):
Notifiable(s),
wake("Wake", s),
sleep("Sleep", s),
rx("Rx", s),
cue("Cue", s),
start("Start", s),
stop("Stop", s),
record("Record", s),
init("Init", s)
{
cerr << "building schedulable " << endl;
uberQua = q;
metric = m;
// insertableBridge.SetSymbol(s);
mainBlock = nullptr;
status = STATUS_SLEEPING;
Instance *i=0;
chanSym = DefineSymbol("chan", TypedValue::S_CHANNEL, 0,
(char*)&i->channel, sym, TypedValue::REF_INSTANCE, false, false, StabEnt::DISPLAY_CTL);
starttSym = DefineSymbol("starttime", TypedValue::S_TIME, 0,
(char*)&i->startTime, sym, TypedValue::REF_INSTANCE, false, false, StabEnt::DISPLAY_CTL);
durSym = DefineSymbol("duration", TypedValue::S_TIME, 0,
(char*)&i->duration, sym, TypedValue::REF_INSTANCE, false, false, StabEnt::DISPLAY_CTL);
DefineSymbol("wakedurclock", TypedValue::S_INT, 0,
((char *)&i->wakeDuration.ticks), sym,
TypedValue::REF_INSTANCE, false, false, StabEnt::DISPLAY_NOT);
DefineSymbol("wakeatclock", TypedValue::S_INT, 0,
((char*)&i->wokenAt.ticks), sym,
TypedValue::REF_INSTANCE, false, false, StabEnt::DISPLAY_NOT);
}
// Process the source files directives
vector<string> PreProcessor::Process(fstream &source)
{
symbolTable->~SymbolTable();
symbolTable = new SymbolTable();
file = &source;
output->clear();
string line;
if (file->is_open())
{
while (getline(*file, line))
{
// Tokenize line on whitespace
vector<string> lineTokens;
char delim = ' ';
split(line, delim, lineTokens);
// Ignore Comments
if (ProcessInlineComments(lineTokens, line));
// Ignore =end and =else that aren't scanned to
else if (line.compare(directives[1]) == 0 || line.compare(directives[6]) == 0);
// Escape from empty lines
else if (lineTokens.empty());
// Handle =begin comment blocks
else if (ProcessCommentBlocks(lineTokens));
// Handle =ifdef
else if (ProcessIfDefined(lineTokens));
// Handle =ifndef
else if (ProcessIfNotDefined(lineTokens));
// Handle =def
else if (DefineSymbol(lineTokens));
// Send line to output with symbol replacement
else { RecordOutput(lineTokens, line); }
}
}
return *output;
}
vector<string> PreProcessor::Process(vector<string> &source)
{
symbolTable->~SymbolTable();
symbolTable = new SymbolTable();
output->clear();
string line;
for (vector<string>::iterator iter = source.begin(); iter < source.end(); ++iter)
{
// Tokenize line on whitespace
vector<string> lineTokens;
line = (*iter);
char delim = ' ';
split(line, delim, lineTokens);
// Ignore Comments
if (ProcessInlineComments(lineTokens, line));
// Ignore =end and =else that aren't scanned to
else if (line.compare(directives[1]) == 0 || line.compare(directives[6]) == 0);
// Escape from empty lines
else if (lineTokens.empty());
// Handle =begin comment blocks
else if (ProcessCommentBlocks(lineTokens));
// Handle =ifdef
else if (ProcessIfDefined(lineTokens));
// Handle =ifndef
else if (ProcessIfNotDefined(lineTokens));
// Handle =def
else if (DefineSymbol(lineTokens));
// Send line to output with symbol replacement
else { RecordOutput(lineTokens, line); }
}
return *output;
}
long
Parsedefvarsize (long offset)
{
long varoffset = 0;
switch (sym)
{
case name:
if (strcmp (ident, "DS") != 0)
{
DefineSymbol (ident, offset, 0);
GetSym ();
}
if (sym == name)
varoffset = Parsevarsize ();
break;
default:
ReportError (CURRENTFILE->fname, CURRENTFILE->line, 1);
}
return varoffset;
}
void
DEFGROUP (void)
{
struct expr *postfixexpr;
long constant, enumconst = 0;
writeline = OFF; /* DEFGROUP definitions are not output'ed to listing file */
while (!feof (z80asmfile) && GetSym () != lcurly)
{
Skipline (z80asmfile);
EOL = OFF;
++CURRENTFILE->line;
}
if (sym == lcurly)
{
while (!feof (z80asmfile) && sym != rcurly)
{
if (EOL == ON)
{
++CURRENTFILE->line;
EOL = OFF;
}
else
{
do
{
GetSym ();
switch (sym)
{
case rcurly:
case semicolon:
case newline:
break;
case name:
strcpy (stringconst, ident); /* remember name */
if (GetSym () == assign)
{
GetSym ();
if ((postfixexpr = ParseNumExpr ()) != NULL)
{
if (postfixexpr->rangetype & NOTEVALUABLE)
ReportError (CURRENTFILE->fname, CURRENTFILE->line, 2);
else
{
constant = EvalPfixExpr (postfixexpr);
enumconst = constant;
DefineSymbol (stringconst, enumconst++, 0);
}
RemovePfixlist (postfixexpr);
}
GetSym (); /* prepare for next identifier */
}
else
DefineSymbol (stringconst, enumconst++, 0);
break;
default:
ReportError (CURRENTFILE->fname, CURRENTFILE->line, 1);
break;
}
}
while (sym == comma); /* get enum definitions separated by comma in current line */
Skipline (z80asmfile); /* ignore rest of line */
}
}
}
}
static orl_return ProcSymbol( orl_symbol_handle symhdl )
/******************************************************/
{
orl_symbol_type type;
char *name;
orl_symbol_value value;
orl_sec_handle sechdl;
symbol *sym;
size_t namelen;
sym_flags symop;
extnode *newnode;
segnode *snode;
bool isweak;
orl_symbol_handle assocsymhdl;
symbol *assocsym;
orl_symbol_binding binding;
sechdl = ORLSymbolGetSecHandle( symhdl );
snode = FindSegNode( sechdl );
type = ORLSymbolGetType( symhdl );
name = ORLSymbolGetName( symhdl );
if( type & ORL_SYM_TYPE_FILE ) {
if( (CurrMod->modinfo & MOD_GOT_NAME) == 0 ) {
CurrMod->modinfo |= MOD_GOT_NAME;
_LnkFree( CurrMod->name );
CurrMod->name = AddStringStringTable( &PermStrings, name );
}
return( ORL_OKAY );
}
if( type & ORL_SYM_TYPE_DEBUG )
return( ORL_OKAY );
if( type & (ORL_SYM_TYPE_OBJECT|ORL_SYM_TYPE_FUNCTION) ||
(type & (ORL_SYM_TYPE_NOTYPE|ORL_SYM_TYPE_UNDEFINED) &&
name != NULL)) {
namelen = strlen( name );
if( namelen == 0 ) {
BadObject();
}
if( CurrMod->modinfo & MOD_IMPORT_LIB ) {
ImpProcSymbol( snode, type, name, namelen );
return( ORL_OKAY );
}
newnode = AllocNode( ExtNodes );
newnode->handle = symhdl;
binding = ORLSymbolGetBinding( symhdl );
symop = ST_CREATE;
if( binding == ORL_SYM_BINDING_LOCAL ) {
symop |= ST_STATIC | ST_NONUNIQUE;
}
if( (type & ORL_SYM_TYPE_UNDEFINED) && binding != ORL_SYM_BINDING_ALIAS ){
symop |= ST_REFERENCE;
} else {
symop |= ST_NOALIAS;
}
sym = SymOp( symop, name, namelen );
CheckIfTocSym( sym );
if( type & ORL_SYM_TYPE_COMMON ) {
value = ORLSymbolGetValue( symhdl );
sym = MakeCommunalSym( sym, value.u._32[I64LO32], false, true );
} else if( type & ORL_SYM_TYPE_UNDEFINED ) {
DefineReference( sym );
isweak = false;
switch( binding ) {
case ORL_SYM_BINDING_WEAK:
isweak = true;
case ORL_SYM_BINDING_ALIAS:
case ORL_SYM_BINDING_LAZY:
assocsymhdl = ORLSymbolGetAssociated( symhdl );
name = ORLSymbolGetName( assocsymhdl );
namelen = strlen(name);
if( binding == ORL_SYM_BINDING_ALIAS ) {
MakeSymAlias( sym->name, strlen(sym->name), name, namelen );
} else {
assocsym = SymOp( ST_CREATE | ST_REFERENCE, name, namelen );
DefineLazyExtdef( sym, assocsym, isweak );
newnode->isweak = true;
}
}
} else {
newnode->isdefd = true;
value = ORLSymbolGetValue( symhdl );
if( (type & ORL_SYM_TYPE_COMMON) && (type & ORL_SYM_TYPE_OBJECT) && sechdl == NULL) {
sym = MakeCommunalSym( sym, value.u._32[I64LO32], false, true );
} else if( snode != NULL && snode->entry != NULL && snode->entry->iscdat ) {
DefineComdatSym( snode, sym, value );
} else {
sym->info |= SYM_DEFINED;
DefineSymbol( sym, snode, value.u._32[I64LO32], 0 );
}
}
newnode->entry = sym;
} else if( (type & ORL_SYM_TYPE_SECTION) && (type & ORL_SYM_CDAT_MASK)
&& snode != NULL && !(snode->info & SEG_DEAD) ) {
snode->entry->select = (type & ORL_SYM_CDAT_MASK) >> ORL_SYM_CDAT_SHIFT;
}
Quaddon::Quaddon(char *path, image_id id, int n):
Stackable(DefineSymbol(AddonName(id,n), S_QUADDON, 0,
this, nullptr,
REF_VALUE, ATTRIB_NONE, false, DISP_MODE_NOT))
{
status_t err;
srcImage = id;
srcIndex = n;
fprintf(stderr, "addon %s, image %d, hook %d: name %s\n", path, id, n, sym->name);
uint32 *addon_id_p;
if ((err=get_image_symbol(
id, "addon_id", B_SYMBOL_TYPE_DATA, (void**)&addon_id_p)) >= B_NO_ERROR) {
subType = *addon_id_p;
} else if ((err=get_image_symbol(
id, "addon_id_array", B_SYMBOL_TYPE_DATA, (void**)&addon_id_p)) >= B_NO_ERROR) {
subType = addon_id_p[n];
} else {
subType = 0;
}
char **addon_formal_p;
if ((err=get_image_symbol(
id, "addon_params", B_SYMBOL_TYPE_DATA, (void **)&addon_formal_p)) >= B_NO_ERROR) {
controlVariableDef = new char[strlen(*addon_formal_p)+1];
strcpy(controlVariableDef, *addon_formal_p);
} else if ((err=get_image_symbol(
id, "addon_params_array", B_SYMBOL_TYPE_DATA, (void**)&addon_formal_p)) >= B_NO_ERROR) {
controlVariableDef = new char[strlen(addon_formal_p[n])+1];
strcpy(controlVariableDef, addon_formal_p[n]);
} else {
controlVariableDef = new char[strlen("()")+1];
strcpy(controlVariableDef, "()");
}
InitFnPtr *addon_init_array_p;
if ((err=get_image_symbol(
id, "init", B_SYMBOL_TYPE_TEXT, (void**)&init)) >= B_NO_ERROR) {
;
} else if ((err=get_image_symbol(
id, "init_array", B_SYMBOL_TYPE_DATA, (void**)&addon_init_array_p)) >= B_NO_ERROR) {
init = addon_init_array_p[n];
} else {
init = nullptr;
}
DisInitFnPtr *addon_disinit_array_p;
if ((err=get_image_symbol(
id, "disinit", B_SYMBOL_TYPE_TEXT, (void**)&disInit)) >= B_NO_ERROR) {
;
} else if ((err=get_image_symbol(
id, "disinit_array", B_SYMBOL_TYPE_DATA, (void**)&addon_disinit_array_p)) >= B_NO_ERROR) {
disInit = addon_disinit_array_p[n];
} else {
disInit = nullptr;
}
ApplyFnPtr *addon_apply_array_p;
if ((err=get_image_symbol(
id, "apply", B_SYMBOL_TYPE_TEXT, (void **)&apply)) >= B_NO_ERROR) {
;
} else if ((err=get_image_symbol(
id, "apply_array", B_SYMBOL_TYPE_DATA, (void**)&addon_apply_array_p)) >= B_NO_ERROR) {
apply = addon_apply_array_p[n];
} else {
apply = nullptr;
}
ResetFnPtr *addon_reset_array_p;
if ((err=get_image_symbol(
id, "reset", B_SYMBOL_TYPE_TEXT, (void**)&reset)) >= B_NO_ERROR) {
;
} else if ((err=get_image_symbol(
id, "reset_array", B_SYMBOL_TYPE_DATA, (void**)&addon_reset_array_p)) >= B_NO_ERROR) {
reset = addon_reset_array_p[n];
} else {
reset = nullptr;
}
SetParamFnPtr *addon_setp_array_p;
if ((err=get_image_symbol(
id, "set_parameters", B_SYMBOL_TYPE_TEXT, (void**)&setParameters)) >= B_NO_ERROR) {
;
} else if ((err=get_image_symbol(
id, "set_parameters_array", B_SYMBOL_TYPE_DATA, (void**)&addon_setp_array_p)) >= B_NO_ERROR) {
setParameters = addon_setp_array_p[n];
} else {
setParameters = nullptr;
}
// allocate a pointer on the stack for the cookie...
cookieVar.Set(S_STRANGE_POINTER, REF_STACK, sym,
(long)AllocStack(sym, S_STRANGE_POINTER, 1));
TxtParser *p = new TxtParser(controlVariableDef, path, nullptr);
p->GetToken();
p->ParseFormalsList(sym);
next = nullptr;
}
void
MFCSimpleTypeView::ContextMenu(UINT nFlags, CPoint point)
{
long caty[] = {
// TypedValue::S_DOUBLE,
// TypedValue::S_LAMBDA,
TypedValue::S_FLOAT,
TypedValue::S_INT,
TypedValue::S_SHORT,
TypedValue::S_BYTE,
TypedValue::S_BOOL
};
CPoint popPt = point;
ClientToScreen(&popPt);
CMenu *ctxtMenu = new CMenu;
ctxtMenu->CreatePopupMenu();
CMenu *addVarMenu = new CMenu;
addVarMenu->CreatePopupMenu();
char buf[512];
long item = ItemAtPoint(point);
for (short i=0; i<sizeof(caty)/sizeof(caty[0]); i++) {
if (ID_VARIABLECONTEXT_ADD_VAR + caty[i] > ID_VARIABLECONTEXT_ADD_VAR_TYPE_RANGE) {
reportError("Internal error. type index value exceeded in menu creator, is %d and shouldn't exceed %d",
caty[i], ID_VARIABLECONTEXT_ADD_VAR_TYPE_RANGE-ID_VARIABLECONTEXT_ADD_VAR);
} else {
string tnm = findTypeName(caty[i]);
if (tnm.size()) {
sprintf(buf, "%s", tnm.c_str());
addVarMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_ADD_VAR + caty[i], buf);
}
}
}
ctxtMenu->AppendMenu(MF_POPUP, (UINT) addVarMenu->m_hMenu, "add variable");
ctxtMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_ADD_METHOD, "add method");
StabEnt *itemSym = NULL;
if (item >= 0) {
// delete selected item
// set selected item envelope
// set selected item display type
// set selected item length ... to create an array
itemSym = SymForItem(item);
if (itemSym != NULL) {
CMenu *setVarTypeMenu = new CMenu;
setVarTypeMenu->CreatePopupMenu();
for (short i=0; i<sizeof(caty)/sizeof(caty[0]); i++) {
if (ID_VARIABLECONTEXT_SET_VAR_TYPE + caty[i] > ID_VARIABLECONTEXT_SET_VAR_TYPE_RANGE) {
reportError("Internal error. type index value exceeded in menu creator, is %d and shouldn't exceed %d",
caty[i], ID_VARIABLECONTEXT_SET_VAR_TYPE_RANGE-ID_VARIABLECONTEXT_SET_VAR_TYPE);
} else {
string tnm = findTypeName(caty[i]);
if (tnm.size() && itemSym->type != caty[i]) {
sprintf(buf, "%s", tnm.c_str());
setVarTypeMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_SET_VAR_TYPE + caty[i], buf);
}
}
}
sprintf(buf, "set '%s' type", itemSym->uniqueName());
ctxtMenu->AppendMenu(MF_POPUP, (UINT) setVarTypeMenu->m_hMenu, buf);
sprintf(buf, "delete '%s'", itemSym->uniqueName());
ctxtMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_DELETE_SELECTED, buf);
sprintf(buf, "set '%s' envelope", itemSym->uniqueName());
ctxtMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_ENVELOPE_SELECTED, buf);
CMenu *dispVarMenu = new CMenu;
dispVarMenu->CreatePopupMenu();
dispVarMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_NODISPLAY_SELECTED, "none");
dispVarMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_CONTROL_SELECTED, "control");
dispVarMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_DISPLAY_SELECTED, "display");
sprintf(buf, "set '%s' display", itemSym->uniqueName());
ctxtMenu->AppendMenu(MF_POPUP, (UINT) dispVarMenu->m_hMenu, buf);
ctxtMenu->AppendMenu(MF_STRING, ID_VARIABLECONTEXT_SET_LENGTH_SELECTED, "set length");
}
}
// add item
// by type
// structures ????
short ret = ctxtMenu->TrackPopupMenuEx(
TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_RETURNCMD,
popPt.x, popPt.y, this, NULL);
if (ret >= ID_VARIABLECONTEXT_ADD_VAR && ret <= ID_VARIABLECONTEXT_ADD_VAR_TYPE_RANGE) {
long typ = ret - ID_VARIABLECONTEXT_ADD_VAR;
if (parent && parent->Symbol()) {
StabEnt *pSym = parent->Symbol();
Stackable *stkbl = pSym->StackableValue();
if (stkbl) {
char *vnm = "variable%d";
switch(typ) {
case TypedValue::S_BYTE: vnm = "bytevar"; break;
case TypedValue::S_SHORT: vnm = "wordvar"; break;
case TypedValue::S_INT: vnm = "intvar"; break;
case TypedValue::S_LONG: vnm = "longvar"; break;
case TypedValue::S_FLOAT: vnm = "floatvar"; break;
}
string nmbuf = glob.makeUniqueName(pSym, vnm, 1);
StabEnt *nsym=DefineSymbol(nmbuf, typ, 0, 0, pSym, TypedValue::REF_STACK, false, false, StabEnt::DISPLAY_NOT);
stkbl->ReAllocateChildren();
AddSym(nsym);
}
}
} else if (ret == ID_VARIABLECONTEXT_ADD_METHOD) {
if (parent && parent->Symbol()) {
StabEnt *pSym = parent->Symbol();
string nmbuf = glob.makeUniqueName(pSym, "action", 1);
QuaPerceptualSet *quaLink=parent->QuaLink();
if (quaLink) {
StabEnt *mSym = quaLink->CreateMethod(nmbuf, pSym);
if (mSym) {
AddSym(mSym);
fprintf(stderr, "tried to add method element\n");
}
}
}
} else if (ret >= ID_VARIABLECONTEXT_SET_VAR_TYPE && ret <= ID_VARIABLECONTEXT_SET_VAR_TYPE_RANGE) {
long typ = ret - ID_VARIABLECONTEXT_SET_VAR_TYPE;
if (itemSym && parent && parent->Symbol()) {
StabEnt *pSym = parent->Symbol();
Stackable *stkbl = pSym->StackableValue();
if (stkbl) {
bool validChange = false;
switch(typ) {
case TypedValue::S_BYTE: validChange = true; break;
case TypedValue::S_SHORT: validChange = true; break;
case TypedValue::S_INT: validChange = true; break;
case TypedValue::S_LONG: validChange = true; break;
case TypedValue::S_FLOAT: validChange = true; break;
}
if (validChange) {
itemSym->type = typ;
stkbl->ReAllocateChildren();
}
}
}
} else if (ret == ID_VARIABLECONTEXT_DELETE_SELECTED) {
if (itemSym) {
glob.DeleteSymbol(itemSym, true);
RemoveSym(itemSym);
if (parent && parent->Symbol()) {
StabEnt *pSym = parent->Symbol();
Stackable *stkbl = pSym->StackableValue();
if (stkbl) {
stkbl->ReAllocateChildren();
}
}
}
} else if (ret == ID_VARIABLECONTEXT_ENVELOPE_SELECTED) {
if (itemSym) {
itemSym->SetEnvelopeMode(true);
}
} else if (ret == ID_VARIABLECONTEXT_NODISPLAY_SELECTED) {
if (itemSym) {
itemSym->SetDisplayMode(StabEnt::DISPLAY_NOT);
// forces redisplay of this entry to show icon change
GetListCtrl().SetItemText(item, 3, "N");
}
} else if (ret == ID_VARIABLECONTEXT_DISPLAY_SELECTED) {
if (itemSym) {
itemSym->SetDisplayMode(StabEnt::DISPLAY_DISP);
// forces redisplay of this entry
GetListCtrl().SetItemText(item, 3, "D");
}
} else if (ret == ID_VARIABLECONTEXT_CONTROL_SELECTED) {
if (itemSym) {
itemSym->SetDisplayMode(StabEnt::DISPLAY_CTL);
// forces redisplay of this entry
GetListCtrl().SetItemText(item, 3, "C");
}
} else if (ret == ID_VARIABLECONTEXT_SET_LENGTH_SELECTED) {
reportError("Currently only undimensioned data are supported by this interface .... but they can be added manually by hand-editting the script");
}
}
