/*
* fieldset_copy
*
* Copy-constructor for field sets. In the copy,
* the nameref's must point to the entries in the
* newly-constructed scope.
*/
static int
fieldset_copy (void *vctx, name_t *dst, void *dp,
name_t *src, void *sp)
{
namereflist_t *drefs = dp;
namereflist_t *srefs = sp;
expr_ctx_t ctx = vctx;
scopectx_t dscope = name_scope(dst);
namectx_t namectx = expr_namectx(ctx);
nameref_t *ref;
name_t *np;
for (ref = namereflist_head(srefs); ref != 0; ref = ref->tq_next) {
if (ref->np == 0) {
// XXX should never happen
continue;
}
strdesc_t *str = name_string(ref->np);
np = name_search(dscope, str->ptr, str->len, 0);
namereflist_instail(drefs, nameref_alloc(namectx, np));
}
return 1;
} /* fieldset_copy */
/*
* prepare_body
*
* Builds a lexeme sequence with the expansion of the body of
* a macro.
*/
static int
prepare_body (macroctx_t mctx, expansion_t *curexp, lexseq_t *result)
{
expr_ctx_t ctx = mctx->ectx;
parse_ctx_t pctx = expr_parse_ctx(ctx);
lexctx_t lctx = parser_lexmemctx(pctx);
struct macrodecl_s *macro = name_extraspace(curexp->curmacro);
lexeme_t *lex;
name_t *np;
static strdesc_t mend = STRDEF("<macro-end>");
// Prepare the grouper and separator lexemes, in case
// they are needed (only applicable to iterative macros)
if (curexp->count == 0 && macro->type == MACRO_ITER) {
curexp->sep = parser_punct_separator(pctx);
lex = parser_punct_grouper(pctx, 0);
if (lex != 0) {
lexseq_instail(result, lex);
}
curexp->closer = parser_punct_grouper(pctx, 1);
}
// Associate the iterative-formals with any actuals
if (macro->type == MACRO_ITER) {
nameref_t *iformal;
lextype_t lt, terms[1] = { LEXTYPE_DELIM_COMMA };
for (iformal = namereflist_head(¯o->ilist); iformal != 0;
iformal = iformal->tq_next) {
strdesc_t *namestr = name_string(iformal->np);
np = macparam_special(curexp->expscope, namestr, 0);
parse_lexeme_seq(pctx, &curexp->remaining, QL_MACRO, terms, 1,
macparam_lexseq(np), <);
}
}
// Expand the macro parameters here, instead of relying on the parser
// to do this while processing the expansion. If we were to wait, we'd
// have to push a new scope on the parser's stack and remove it when we're
// done -- but the expansion could declare other names, and those would
// get declared in the scope we're removing.
for (lex = lexseq_head(¯o->body); lex != 0; lex = lexeme_next(lex)) {
if (curexp->expscope != 0 && lexeme_boundtype(lex) == LEXTYPE_NAME) {
lexseq_t seq;
lexseq_init(&seq);
if (macparam_lookup(lctx, curexp->expscope, lexeme_text(lex), &seq) != 0) {
lexseq_append(result, &seq);
} else {
lexseq_instail(result, lexeme_copy(lctx, lex));
}
} else {
lexseq_instail(result, lexeme_copy(lctx, lex));
}
}
lexseq_instail(result, lexeme_create(lctx, LEXTYPE_MACROEND, &mend));
curexp->count += 1;
return 1;
} /* prepare_body */
/*
* macro_copydata
*
* Copy-constructor for macros.
*/
static int
macro_copydata (void *vctx, name_t *dst, void *dp, name_t *src, void *sp)
{
struct macrodecl_s *srcm = sp;
struct macrodecl_s *dstm = dp;
nameref_t *ref;
expr_ctx_t ctx = vctx;
namectx_t namectx = expr_namectx(ctx);
lexctx_t lctx = expr_lexmemctx(ctx);
lexseq_init(&dstm->body);
lexseq_copy(lctx, &dstm->body, &srcm->body);
dstm->ptable = scope_copy(srcm->ptable, 0);
namereflist_init(&dstm->plist);
namereflist_init(&dstm->ilist);
dstm->type = srcm->type;
// We can't just copy the namereflists over verbatim; the copied
// list has to reference the names in the copied name table, not
// the original.
for (ref = namereflist_head(&srcm->plist); ref != 0; ref = ref->tq_next) {
name_t *np;
if (ref->np == 0) {
np = 0;
} else {
strdesc_t *namestr = name_string(ref->np);
np = name_search(dstm->ptable, namestr->ptr, namestr->len, 0);
}
namereflist_instail(&dstm->plist, nameref_alloc(namectx, np));
}
for (ref = namereflist_head(&srcm->ilist); ref != 0; ref = ref->tq_next) {
name_t *np;
if (ref->np == 0) {
np = 0;
} else {
strdesc_t *namestr = name_string(ref->np);
np = name_search(dstm->ptable, namestr->ptr, namestr->len, 0);
}
namereflist_instail(&dstm->ilist, nameref_alloc(namectx, np));
}
return 1;
} /* macro_copydata */
void const_copy_to(const char *name, void *host, size_t size)
{
RPCSend snd(socket, "const_copy_to");
string name_string(name);
snd.add(name_string);
snd.add(size);
snd.write();
snd.write_buffer(host, size);
}
/*
* structure_copy
*
* Copy-constructor for a structure cell. Handles
* the fact that name references must point to the
* newly-constructed scope tables, rather than the
* originals.
*/
static int
structure_copy (void *vctx, name_t *dst, void *dp,
name_t *src, void *sp)
{
expr_ctx_t ctx = vctx;
lexctx_t lctx = expr_lexmemctx(ctx);
strudef_t *dstru = dp;
strudef_t *sstru = sp;
namectx_t namectx = expr_namectx(ctx);
nameref_t *ref;
name_t *np;
dstru->acctbl = scope_copy(sstru->acctbl, 0);
dstru->allotbl = scope_copy(sstru->allotbl, 0);
for (ref = namereflist_head(&sstru->accformals); ref != 0;
ref = ref->tq_next) {
if (ref->np == 0) {
np = 0;
} else {
strdesc_t *str = name_string(ref->np);
np = name_search(dstru->acctbl, str->ptr, str->len, 0);
}
namereflist_instail(&dstru->accformals, nameref_alloc(namectx, np));
}
for (ref = namereflist_head(&sstru->alloformals); ref != 0;
ref = ref->tq_next) {
if (ref->np == 0) {
np = 0;
} else {
strdesc_t *str = name_string(ref->np);
np = name_search(dstru->allotbl, str->ptr, str->len, 0);
}
namereflist_instail(&dstru->alloformals, nameref_alloc(namectx, np));
}
lexseq_copy(lctx, &dstru->accbody, &sstru->accbody);
lexseq_copy(lctx, &dstru->allobody, &sstru->allobody);
return 1;
} /* structure_copy */
void const_copy_to(const char *name, void *host, size_t size)
{
thread_scoped_lock lock(rpc_lock);
RPCSend snd(socket, &error_func, "const_copy_to");
string name_string(name);
snd.add(name_string);
snd.add(size);
snd.write();
snd.write_buffer(host, size);
}
/*
* handle_exits
*/
int
handle_exits (parse_ctx_t pctx, void *vctx, quotelevel_t ql, lextype_t curlt)
{
macroctx_t ctx = vctx;
expansion_t *cur = ctx->curexp;
struct macrodecl_s *macro;
lexeme_t *lex;
if (ctx->curexp == 0) {
expr_signal(ctx->ectx, STC__INTCMPERR, "handle_exits[1]");
return 1;
}
if (ctx->state != EXP_NORMAL) {
return 1;
}
macro = name_extraspace(cur->curmacro);
switch (curlt) {
case LEXTYPE_LXF_EXITITER:
if (macro->type != MACRO_ITER) {
expr_signal(ctx->ectx, STC__INVEXITER, name_string(cur->curmacro));
ctx->state = EXP_EXITMACRO;
}
parser_skipmode_set(pctx, 1);
ctx->state = EXP_EXITITER;
break;
case LEXTYPE_LXF_EXITMACRO:
parser_skipmode_set(pctx, 1);
ctx->state = EXP_EXITMACRO;
break;
case LEXTYPE_LXF_ERRORMACRO:
lex = parse_string_params(pctx, 0);
if (lex == 0) {
expr_signal(ctx->ectx, STC__SYNTAXERR);
} else {
expr_signal(ctx->ectx, STC__USRERR, lexeme_text(lex));
lexeme_free(expr_lexmemctx(ctx->ectx), lex);
}
parser_skipmode_set(pctx, 1);
ctx->state = EXP_ERRORMACRO;
break;
default:
expr_signal(ctx->ectx, STC__INTCMPERR, "handle_exits[2]");
break;
}
return 1;
} /* handle_exits */
void AbstractHdf5Access::SetUnlimitedDatasetId()
{
// Now deal with the unlimited dimension
// In terms of an Unlimited dimension dataset:
// * Files pre - r16738 (inc. Release 3.1 and earlier) use simply "Time" for "Data"'s unlimited variable.
// * Files generated by r16738 - r18257 used "<DatasetName>_Time" for "<DatasetName>"'s unlimited variable,
// - These are not to be used and there is no backwards compatibility for them, since they weren't in a release.
// * Files post r18257 (inc. Release 3.2 onwards) use "<DatasetName>_Unlimited" for "<DatasetName>"'s
// unlimited variable,
// - a new attribute "Name" has been added to the Unlimited Dataset to allow it to assign
// any name to the unlimited variable. Which can then be easily read by Hdf5DataReader.
// - if this dataset is missing we look for simply "Time" to remain backwards compatible with Releases <= 3.1
if (DoesDatasetExist(mDatasetName + "_Unlimited"))
{
mUnlimitedDatasetId = H5Dopen(mFileId, (mDatasetName + "_Unlimited").c_str());
hid_t name_attribute_id = H5Aopen_name(mUnlimitedDatasetId, "Name");
hid_t unit_attribute_id = H5Aopen_name(mUnlimitedDatasetId, "Unit");
hid_t attribute_type = H5Aget_type(name_attribute_id);
// Read into it.
char* string_array = (char *)malloc(sizeof(char)*MAX_STRING_SIZE);
H5Aread( name_attribute_id, attribute_type, string_array);
std::string name_string(&string_array[0]);
mUnlimitedDimensionName = name_string;
H5Aread( unit_attribute_id, attribute_type, string_array);
std::string unit_string(&string_array[0]);
mUnlimitedDimensionUnit = unit_string;
free(string_array);
H5Tclose(attribute_type);
H5Aclose(name_attribute_id);
H5Aclose(unit_attribute_id);
}
else if (DoesDatasetExist("Time"))
{
mUnlimitedDimensionName = "Time";
mUnlimitedDimensionUnit = "msec";
mUnlimitedDatasetId = H5Dopen(mFileId, mUnlimitedDimensionName.c_str());
}
else
{
NEVER_REACHED;
}
mIsUnlimitedDimensionSet = true;
}
void tex_alloc(const char *name, device_memory& mem, bool interpolation, bool periodic)
{
mem.device_pointer = ++mem_counter;
RPCSend snd(socket, "tex_alloc");
string name_string(name);
snd.add(name_string);
snd.add(mem);
snd.add(interpolation);
snd.add(periodic);
snd.write();
snd.write_buffer((void*)mem.data_pointer, mem.memory_size());
}
void debug_view_memory::enumerate_sources()
{
// start with an empty list
m_source_list.reset();
std::string name;
// first add all the devices' address spaces
for (device_memory_interface &memintf : memory_interface_iterator(machine().root_device()))
for (int spacenum = 0; spacenum < memintf.max_space_count(); ++spacenum)
if (memintf.has_space(spacenum))
{
address_space &space = memintf.space(spacenum);
name = string_format("%s '%s' %s space memory", memintf.device().name(), memintf.device().tag(), space.name());
m_source_list.append(*global_alloc(debug_view_memory_source(name.c_str(), space)));
}
// then add all the memory regions
for (auto ®ion : machine().memory().regions())
{
name = string_format("Region '%s'", region.second->name());
m_source_list.append(*global_alloc(debug_view_memory_source(name.c_str(), *region.second.get())));
}
// finally add all global array symbols in alphabetical order
std::vector<std::tuple<std::string, void *, u32, u32> > itemnames;
itemnames.reserve(machine().save().registration_count());
for (int itemnum = 0; itemnum < machine().save().registration_count(); itemnum++)
{
u32 valsize, valcount;
void *base;
std::string name_string(machine().save().indexed_item(itemnum, base, valsize, valcount));
// add pretty much anything that's not a timer (we may wish to cull other items later)
// also, don't trim the front of the name, it's important to know which VIA6522 we're looking at, e.g.
if (strncmp(name_string.c_str(), "timer/", 6))
itemnames.emplace_back(std::move(name_string), base, valsize, valcount);
}
std::sort(itemnames.begin(), itemnames.end(), [] (auto const &x, auto const &y) { return std::get<0>(x) < std::get<0>(y); });
for (auto const &item : itemnames)
m_source_list.append(*global_alloc(debug_view_memory_source(std::get<0>(item).c_str(), std::get<1>(item), std::get<2>(item), std::get<3>(item))));
// reset the source to a known good entry
set_source(*m_source_list.first());
}
void tex_alloc(const char *name, device_memory& mem, InterpolationType interpolation, bool periodic)
{
thread_scoped_lock lock(rpc_lock);
mem.device_pointer = ++mem_counter;
RPCSend snd(socket, &error_func, "tex_alloc");
string name_string(name);
snd.add(name_string);
snd.add(mem);
snd.add(interpolation);
snd.add(periodic);
snd.write();
snd.write_buffer((void*)mem.data_pointer, mem.memory_size());
}
static void ReportException(Environment* env, v8::Handle<v8::Value> er, v8::Handle<v8::Message> message)
{
v8::HandleScope scope(env->isolate());
AppendExceptionLine(env, er, message);
v8::Local<v8::Value> trace_value;
if (er->IsUndefined() || er->IsNull())
trace_value = Undefined(env->isolate());
else
trace_value = er->ToObject()->Get(env->stack_string());
v8::String::Utf8Value trace(trace_value);
// range errors have a trace member set to undefined
if (trace.length() > 0 && !trace_value->IsUndefined()) {
fprintf(stderr, "%s\n", *trace);
} else {
// this really only happens for RangeErrors, since they're the only
// kind that won't have all this info in the trace, or when non-Error
// objects are thrown manually.
v8::Local<v8::Value> message;
v8::Local<v8::Value> name;
if (er->IsObject()) {
v8::Local<v8::Object> err_obj = er.As<v8::Object>();
message = err_obj->Get(env->message_string());
name = err_obj->Get(FIXED_UTF8_STRING(env->isolate(), "name"));
}
if (message.IsEmpty() || message->IsUndefined() || name.IsEmpty() || name->IsUndefined()) {
// Not an error object. Just print as-is.
v8::String::Utf8Value message(er);
fprintf(stderr, "%s\n", *message);
} else {
v8::String::Utf8Value name_string(name);
v8::String::Utf8Value message_string(message);
fprintf(stderr, "%s: %s\n", *name_string, *message_string);
}
}
fflush(stderr);
}
int wpl_text::output_as_json_var(wpl_state *state, wpl_value *final_result) {
wpl_value_string name_string(get_name());
wpl_io &io = state->get_io();
io << "\"";
name_string.output_json(io);
io << "\": \"";
wpl_io_buffer buf;
wpl_output_json json_io;
run(state, final_result, buf);
json_io.output_json(io, buf.c_str(), buf.size());
io << "\",\n";
return WPL_OP_OK;
}
void tex_alloc(const char *name,
device_memory& mem,
InterpolationType interpolation,
ExtensionType extension)
{
VLOG(1) << "Texture allocate: " << name << ", " << mem.memory_size() << " bytes.";
thread_scoped_lock lock(rpc_lock);
mem.device_pointer = ++mem_counter;
RPCSend snd(socket, &error_func, "tex_alloc");
string name_string(name);
snd.add(name_string);
snd.add(mem);
snd.add(interpolation);
snd.add(extension);
snd.write();
snd.write_buffer((void*)mem.data_pointer, mem.memory_size());
}
/*
* structure_reference
*
* Expands a structure reference, for both the general case
* and the ordinary case.
*
* General structure reference
* structure-name [ expression {,access-actual...} {; alloc-actual...} ]
*
* Ordinary structure reference
* segment-name [ access-actual... ]
*
*/
expr_node_t *
structure_reference (expr_ctx_t ctx, name_t *struname, int ctce_accessors,
name_t *symname, lexeme_t *curlex)
{
parse_ctx_t pctx = expr_parse_ctx(ctx);
lexctx_t lctx = expr_lexmemctx(ctx);
lextype_t delim;
lexseq_t seq;
scopectx_t myscope, fldscope;
nameref_t *ref;
expr_node_t *exp, *resexp;
textpos_t pos = parser_curpos(pctx);
strudef_t *stru = name_extraspace(struname);
static lextype_t delims[3] = { LEXTYPE_DELIM_RBRACK, LEXTYPE_DELIM_COMMA,
LEXTYPE_DELIM_SEMI };
int ndelims;
fldscope = 0;
lexseq_init(&seq);
// If this is a general structure reference, get the
// address expression
if (symname == 0) {
// It might be more correct to use expr_parse_expr() here to get
// the address expression, rather than deferring that to the
// expansion step later, but just handling it lexically was
// simpler to implement. XXX
ndelims = 3;
if (!parse_lexeme_seq(pctx, 0, QL_NORMAL, delims, 3, &seq, &delim)) {
return 0;
}
myscope = scope_copy(stru->acctbl, 0);
} else {
// Here we have an ordinary structure reference, and can use
// the symbol name for the base address.
data_attr_t *attr = datasym_attr(symname);
if (attr == 0) {
expr_signal(ctx, STC__INTCMPERR, "structure_reference[1]");
return 0;
}
lexseq_instail(&seq,lexeme_copy(lctx, curlex));
// Semicolons (and allocation-formals) not allowed in this case
ndelims = 2;
delim = LEXTYPE_DELIM_COMMA;
myscope = ((attr->struscope == 0)
? scope_begin(expr_namectx(ctx), 0)
: scope_copy(attr->struscope, 0));
// Bring in the field names, so they can be used in the
// the structure expression
if (namereflist_length(&attr->fields) > 0) {
fldscope = scope_begin(scope_namectx(myscope), 0);
for (ref = namereflist_head(&attr->fields); ref != 0;
ref = ref->tq_next) {
if (ref->np != 0) {
strdesc_t *fname = name_string(ref->np);
macparam_special(fldscope, fname, field_lexseq(ref->np));
}
}
}
}
// In the expansion, the name of the structure represents the
// base address, so define that as a macro parameter.
macparam_special(myscope, name_string(struname), &seq);
lexseq_free(lctx, &seq);
// Now parse the access-actuals, bringing the field names into scope.
if (fldscope != 0) {
parser_scope_push(pctx, fldscope);
}
for (ref = namereflist_head(&stru->accformals); ref != 0; ref = ref->tq_next) {
if (ref->np != 0) {
strdesc_t *pname = name_string(ref->np);
lexseq_init(&seq);
if (delim == LEXTYPE_DELIM_COMMA) {
if (!parse_lexeme_seq(pctx, 0, QL_NORMAL, delims, ndelims,
&seq, &delim)) {
expr_signal(ctx, STC__SYNTAXERR);
break;
}
if (ctce_accessors) {
lexseq_t testseq;
lexseq_init(&testseq);
lexseq_copy(lctx, &testseq, &seq);
if (!expr_parse_seq(ctx, &testseq, &exp) ||
expr_type(exp) != EXPTYPE_PRIM_LIT) {
expr_signal(ctx, STC__EXPCTCE);
} else {
expr_node_free(ctx, exp);
}
lexseq_free(lctx, &testseq);
}
}
if (lexseq_length(&seq) == 0) {
macparam_lookup(lctx, stru->acctbl, pname, &seq);
}
// Parenthesize the parameter value if it's non-null, because we're
// doing lexical substitution and this could be used in an expression
// that is expecting it to be a single operand.
if (lexseq_length(&seq) > 0) {
lexseq_inshead(&seq, lexeme_create(lctx, LEXTYPE_DELIM_LPAR, &leftparen));
lexseq_instail(&seq, lexeme_create(lctx, LEXTYPE_DELIM_RPAR, &rightparen));
}
macparam_special(myscope, pname, &seq);
lexseq_free(lctx, &seq);
}
}
if (fldscope != 0) {
parser_scope_end(pctx);
}
// Allocation-actuals are only used in the general-reference case
if (symname == 0) {
for (ref = namereflist_head(&stru->alloformals); ref != 0;
ref = ref->tq_next) {
if (ref->np != 0) {
strdesc_t *pname = name_string(ref->np);
lexseq_init(&seq);
if (delim != LEXTYPE_DELIM_RBRACK) {
if (!parse_lexeme_seq(pctx, 0, QL_NORMAL, delims, 3,
&seq, &delim)) {
break;
}
}
if (lexseq_length(&seq) == 0) {
macparam_lookup(lctx, stru->allotbl, pname, &seq);
}
// Parenthesize the parameter value if it's non-null, because we're
// doing lexical substitution and this could be used in an expression
// that is expecting it to be a single operand.
if (lexseq_length(&seq) > 0) {
lexseq_inshead(&seq, lexeme_create(lctx, LEXTYPE_DELIM_LPAR, &leftparen));
lexseq_instail(&seq, lexeme_create(lctx, LEXTYPE_DELIM_RPAR, &rightparen));
}
macparam_special(myscope, pname, &seq);
}
}
}
if (delim != LEXTYPE_DELIM_RBRACK) {
expr_signal(ctx, STC__DELIMEXP, "]");
parser_skip_to_delim(pctx, LEXTYPE_DELIM_RBRACK);
}
// At this point, we have built the complete sequence
// of lexemes to convert into the structure reference
// expression.
lexseq_init(&seq);
lexseq_copy(lctx, &seq, &stru->accbody);
parser_scope_push(pctx, myscope);
if (!expr_parse_seq(ctx, &seq, &exp) || exp == 0) {
expr_signal(ctx, STC__SYNTAXERR);
lexseq_free(lctx, &seq);
parser_scope_end(pctx);
return 0;
}
parser_scope_end(pctx);
// Since STRUREF auto-parenthesizes the expression, we can
// simplify a resultant block expression if it only contains
// one expression and has no declarations, labels, or codecomments.
exp = expr_block_simplify(ctx, exp);
if (exp == 0) {
expr_signal(ctx, STC__INTCMPERR, "structure_reference[2]");
return 0;
}
resexp = expr_node_alloc(ctx, EXPTYPE_PRIM_STRUREF, pos);
expr_struref_accexpr_set(resexp, exp);
expr_struref_referer_set(resexp, symname);
expr_is_ctce_set(resexp, expr_is_ctce(exp));
expr_is_ltce_set(resexp, expr_is_ltce_only(exp));
expr_has_value_set(resexp, 1); // XXX *must* have value, right?
return resexp;
} /* structure_reference */
/*
* structure_allocate
*
* Expands a structure allocation.
*/
int
structure_allocate (expr_ctx_t ctx, name_t *struname,
strudef_t **strup, unsigned int *nunits,
scopectx_t *scopep, int is_ref)
{
parse_ctx_t pctx = expr_parse_ctx(ctx);
strudef_t *stru = name_extraspace(struname);
machinedef_t *mach = expr_machinedef(ctx);
lexctx_t lctx = expr_lexmemctx(ctx);
lexseq_t tmpseq;
scopectx_t myscope, retscope;
nameref_t *ref;
int nomoreactuals;
int nobrackets = 0;
int allowed_aus = 0;
static lextype_t aus[4] = { LEXTYPE_AU_BYTE, LEXTYPE_AU_WORD,
LEXTYPE_AU_LONG, LEXTYPE_AU_QUAD };
static lextype_t su[2] = { LEXTYPE_ATTR_UNSIGNED, LEXTYPE_ATTR_SIGNED };
if (!parser_expect(pctx, QL_NORMAL, LEXTYPE_DELIM_LBRACK, 0, 1)) {
nobrackets = 1;
}
// Set up for matching the allocation-unit names to byte counts,
// but only on byte-addressable machines
if (machine_unit_bits(mach) == 8) {
for (allowed_aus = 0; allowed_aus < 4 &&
machine_scalar_units(mach) >= (1<<allowed_aus); allowed_aus++);
}
myscope = parser_scope_begin(pctx);
if (scopep != 0) {
retscope = scope_begin(scope_namectx(myscope), 0);
}
// Now fill in the default values for the allocation formals, if they
// have defaults set.
for (ref = namereflist_head(&stru->alloformals); ref != 0; ref = ref->tq_next) {
if (ref->np != 0) {
strdesc_t *alloname = name_string(ref->np);
lexseq_t seq;
expr_node_t *exp;
lexseq_init(&seq);
lexseq_copy(lctx, &seq, macparam_lexseq(ref->np));
if (lexseq_length(&seq) > 0 && expr_parse_seq(ctx, &seq, &exp)) {
if (expr_type(exp) == EXPTYPE_PRIM_LIT)
litsym_special(myscope, alloname,
(unsigned int) expr_litval(exp));
expr_node_free(ctx, exp);
}
}
}
// Now parse the allocation actuals, if any have been specified.
// For an omitted actuals, fill in the default values, or zeros
// where there are no explicit defaults.
nomoreactuals = nobrackets;
for (ref = namereflist_head(&stru->alloformals); ref != 0; ref = ref->tq_next) {
if (ref->np != 0) {
name_t *np, *rnp;
strdesc_t *alloname = name_string(ref->np);
unsigned long val;
int i = -1;
np = 0;
// An actual could be one of the allocation-unit keywords
// or SIGNED/UNSIGNED, on certain machines, so check for
// those as well as for a normal compile-time constant
// expresion.
if (!nomoreactuals) {
if (allowed_aus > 0) {
i = parser_expect_oneof(pctx, QL_NORMAL, aus,
allowed_aus, 0, 1);
if (i >= 0) {
val = 1L << i;
}
}
if ((i < 0) && machine_signext_supported(mach)) {
i = parser_expect_oneof(pctx, QL_NORMAL, su, 2, 0, 1);
if (i >= 0) {
val = i;
}
}
if ((i < 0) && expr_parse_ctce(ctx, 0, (long *)&val)) {
np = litsym_special(myscope, alloname, val);
i = 0;
}
}
if (i < 0) {
np = litsym_search(myscope, alloname, &val);
if (np == 0) {
val = 0;
}
}
if (np == 0) {
np = litsym_special(myscope, alloname, val);
if (np == 0) {
expr_signal(ctx, STC__INTCMPERR, "structure_allocate[4]");
}
}
// Now copy the declaration into the scope we'll pass back
// to the caller for later use
if (scopep != 0) {
rnp = litsym_special(retscope, alloname, val);
if (rnp == 0) {
expr_signal(ctx, STC__INTCMPERR, "structure_allocate[5]");
}
}
}
if (!nomoreactuals &&
!parser_expect(pctx, QL_NORMAL, LEXTYPE_DELIM_COMMA, 0, 1)) {
nomoreactuals = 1;
}
} /* loop through all of the allocation parameters */
if (!nobrackets &&
!parser_expect(pctx, QL_NORMAL, LEXTYPE_DELIM_RBRACK, 0, 1)) {
expr_signal(ctx, STC__DELIMEXP, "]");
}
// A structure definition may not actually have an
// allocation part, but may only be used for accessing
// storage allocated in some other way.
if (lexseq_length(&stru->allobody) == 0) {
*nunits = 0;
} else {
long val;
lexseq_init(&tmpseq);
lexseq_copy(lctx, &tmpseq, &stru->allobody);
parser_insert_seq(pctx, &tmpseq);
if (!expr_parse_ctce(ctx, 0, &val)) {
expr_signal(ctx, STC__EXPCTCE);
return 0;
}
*nunits = (unsigned int) val;
}
if (scopep != 0) *scopep = retscope;
parser_scope_end(pctx);
if (strup != 0) *strup = stru;
return 1;
} /* structure_allocate */
void ModelObject::read_obj(const char * filename)
{
int vert_id = 1;
std::string temp;
std::string obj_line;
std::ifstream obj_file (filename);
if (obj_file.is_open()) {
while (getline(obj_file, obj_line)) {
if (obj_line[0] == 'v') {
std::istringstream vert_string (obj_line);
coord * new_coord = new coord;
new_coord->id = vert_id;
for (int i = 0; i < 4; i++) {
if (getline(vert_string, temp, ' ')) {
if (i == 1) {
new_coord->x = (float)atof(temp.c_str());
}
else if (i == 2) {
new_coord->y = (float)atof(temp.c_str());
}
else if (i == 3) {
new_coord->z = (float)atof(temp.c_str());
}
}
}
object->vertices.push_back(new_coord);
object->vert_count++;
vert_id++;
}
else if (obj_line[0] == 'f') {
object->face_count++;
std::istringstream face_string (obj_line);
face * new_face = new face;
int coord_id;
getline(face_string, temp, ' ');
while (getline(face_string, temp, ' '))
{
coord_id = (int)atoi(temp.c_str());
new_face->coords.push_back(object->vertices[coord_id - 1]);
}
object->faces.push_back(new_face);
}
else if (obj_line[0] == 'o' && object->obj_name == 0) {
std::string name_string (obj_line);
if (name_string.length() > 2) {
object->obj_name = new char[name_string.length() - 1];
for (int i = 2; i < name_string.length(); i++)
object->obj_name[i - 2] = name_string[i];
}
}
}
obj_file.close();
process_object();
}
}
/*
* macro_expand
*
* Expands a macro.
*/
static int
macro_expand (macroctx_t mctx, name_t *macroname, lexseq_t *result)
{
struct macrodecl_s *macro = name_extraspace(macroname);
expr_ctx_t ctx = mctx->ectx;
parse_ctx_t pctx = expr_parse_ctx(ctx);
lexctx_t lctx = parser_lexmemctx(pctx);
expansion_t *curexp = expansion_alloc(mctx);
expansion_t *prev_exp;
lextype_t lt;
lexeme_t *lex;
lexseq_t extras;
name_t *np;
scopectx_t expscope;
int which;
int nactuals;
punctclass_t pcl;
lextype_t psep;
lextype_t terms[3];
static strdesc_t comma = STRDEF(",");
if (macro == 0 || curexp == 0) {
expr_signal(ctx, STC__INTCMPERR, "macro_expand");
return 1;
}
memset(curexp, 0, sizeof(struct expansion_s));
// We save the punctuation class here, since it will get
// munged by the parsing of the macro parameters.
parser_punctclass_get(pctx, &pcl, &psep);
prev_exp = 0;
if (macro->type == MACRO_COND) {
for (prev_exp = mctx->curexp; prev_exp != 0 && prev_exp->curmacro != macroname;
prev_exp = prev_exp->next);
}
nactuals = 0;
lexseq_init(&extras);
// Simple macros with no formal arguments get no processing
// of parameter lists whatsoever.
if (macro->type == MACRO_SIMPLE && namereflist_length(¯o->plist) == 0) {
expscope = 0;
which = 3;
} else {
// For keyword macros, prime the scope with the declared
// formals, so we can inherit the default values.
if (macro->type == MACRO_KWD) {
expscope = scope_copy(macro->ptable, 0);
} else {
expscope = scope_begin(scope_namectx(parser_scope_get(pctx)), 0);
}
lt = parser_next(pctx, QL_NORMAL, &lex);
if (macro->type == MACRO_KWD) {
if (lt != LEXTYPE_DELIM_LPAR) {
expr_signal(ctx, STC__DELIMEXP, "(");
parser_insert(pctx, lex);
return 1;
}
which = 0;
lexeme_free(lctx, lex);
} else {
for (which = 0; lt != openers[which] && which < 3; which++);
if (which >= 3 && namereflist_length(¯o->plist) > 0) {
expr_signal(ctx, STC__DELIMEXP, "(");
parser_insert(pctx, lex);
return 1;
}
if (which >= 3) {
parser_insert(pctx, lex);
} else {
lexeme_free(lctx, lex);
}
}
}
// If we had a match on an opener, process
// the actual parameters.
if (which < 3) {
nameref_t *formal;
lexseq_t val;
terms[0] = LEXTYPE_DELIM_COMMA;
terms[1] = closers[which];
formal = namereflist_head(¯o->plist);
while (1) {
// Keyword macro actuals are of the form name=value
// For positionals, grab the next formal-parameter name,
// or set np to NULL to add the actual to %REMAINING.
if (macro->type == MACRO_KWD) {
lt = parser_next(pctx, QL_NAME, &lex);
if (lexeme_boundtype(lex) != LEXTYPE_NAME) {
expr_signal(ctx, STC__NAMEEXP);
lexeme_free(lctx, lex);
break;
}
np = name_search(macro->ptable, lex->text.ptr, lex->text.len, 0);
if (np == 0) {
expr_signal(ctx, STC__INTCMPERR, "macro_expand[2]");
}
lexeme_free(lctx, lex);
if (!parser_expect(pctx, QL_NORMAL, LEXTYPE_OP_ASSIGN, 0, 1)) {
expr_signal(ctx, STC__OPEREXP, "=");
break;
}
} else if (nactuals < namereflist_length(¯o->plist)) {
np = formal->np;
formal = formal->tq_next;
} else {
np = 0;
}
lexseq_init(&val);
// Now parse the actual-parameter, which can be an expression
if (!parse_lexeme_seq(pctx, 0, QL_NAME, terms, 2, &val, <)) {
lexseq_free(lctx, &val);
break;
}
// If we are recursively expanding a conditional macro and
// there are no parameters, we're done - no expansion.
if (prev_exp != 0 && lexseq_length(&val) == 0 && nactuals == 0) {
scope_end(expscope);
free(curexp);
return 1;
}
if (np == 0) {
if (lexseq_length(&extras) > 0) {
lexseq_instail(&extras,
lexeme_create(lctx, LEXTYPE_DELIM_COMMA, &comma));
}
lexseq_append(&extras, &val);
} else {
name_t *actual;
// Associate the actual with the formal. For keyword
// macros, the scope_copy() above sets a special "no check"
// flag that allows each name to be redeclared once.
// name_declare() clears this flag, so we can catch genuine
// redeclarations.
actual = macparam_special(expscope, name_string(np), &val);
if (actual == 0) {
expr_signal(ctx, STC__INTCMPERR, "macro_expand[3]");
}
lexseq_free(lctx, &val);
}
nactuals += 1;
if (lt == closers[which]) {
break;
}
if (lt != LEXTYPE_DELIM_COMMA) {
expr_signal(ctx, STC__DELIMEXP, ",");
break;
}
} /* while (1) */
if (lt != closers[which]) {
expr_signal(ctx, STC__DELIMEXP, "closer");
lexseq_free(lctx, &extras);
scope_end(expscope);
return 1;
}
if (nactuals < namereflist_length(¯o->plist)) {
name_t *anp;
while (formal != 0) {
anp = macparam_special(expscope, name_string(formal->np), 0);
if (anp == 0) {
expr_signal(ctx, STC__INTCMPERR, "macro_expand[4]");
}
formal = formal->tq_next;
}
}
} /* if which < 3 */
// The macro actual parameters are now processed; hook
// the scope into the current hierarchy, restore the punctuation
// class to what it was before we parsed the actuals, and
// generate the expansion sequence.
parser_punctclass_set(pctx, pcl, psep);
curexp->count = (prev_exp == 0 ? 0 : prev_exp->count);
curexp->expscope = expscope;
curexp->curmacro = macroname;
curexp->next = mctx->curexp;
curexp->nactuals = nactuals;
lexseq_append(&curexp->remaining, &extras);
mctx->curexp = curexp;
return prepare_body(mctx, curexp, result);
} /* macro_expand */
