static bool charstring_is_notdef_proc(const gs_memory_t *mem, const ref *pcstr) { if (r_is_array(pcstr) && r_size(pcstr) == 4) { ref elts[4]; long i; for (i = 0; i < 4; ++i) array_get(mem, pcstr, i, &elts[i]); if (r_has_type(&elts[0], t_name) && r_has_type(&elts[1], t_integer) && elts[1].value.intval == 0 && r_has_type(&elts[2], t_integer) && elts[2].value.intval == 0 && r_has_type(&elts[3], t_name) ) { ref nref; name_enter_string(mem, "pop", &nref); if (name_eq(&elts[0], &nref)) { name_enter_string(mem, "setcharwidth", &nref); if (name_eq(&elts[3], &nref)) return true; } } } return false; }
const ParserItem& ParserRecord::get( const std::string& name ) const { auto itr = std::find_if( this->m_items.begin(), this->m_items.end(), name_eq( name ) ); if( itr == this->m_items.end() ) throw std::out_of_range( "No item '" + name + "'" ); return *itr; }
void ParserRecord::addItem( ParserItem item ) { if (m_dataRecord) throw std::invalid_argument("Record is already marked as DataRecord - can not add items"); auto itr = std::find_if( this->m_items.begin(), this->m_items.end(), name_eq( item.name() ) ); if( itr != this->m_items.end() ) throw std::invalid_argument("Itemname: " + item.name() + " already exists."); this->m_items.push_back( std::move( item ) ); }
/* Implementation for putting parameters from an array. */ static int array_param_read(iparam_list * plist, const ref * pkey, iparam_loc * ploc) { ref *bot = ((array_param_list *) plist)->bot; ref *ptr = bot; ref *top = ((array_param_list *) plist)->top; for (; ptr < top; ptr += 2) { if (r_has_type(ptr, t_name) && name_eq(ptr, pkey)) { ploc->pvalue = ptr + 1; ploc->presult = &plist->results[ptr - bot]; *ploc->presult = 1; return 0; } } return 1; }
/* Implementation for putting parameters from a stack. */ static int stack_param_read(iparam_list * plist, const ref * pkey, iparam_loc * ploc) { stack_param_list *const splist = (stack_param_list *) plist; ref_stack_t *pstack = splist->pstack; /* This implementation is slow, but it probably doesn't matter. */ uint index = splist->skip + 1; uint count = splist->count; for (; count; count--, index += 2) { const ref *p = ref_stack_index(pstack, index); if (r_has_type(p, t_name) && name_eq(p, pkey)) { ploc->pvalue = ref_stack_index(pstack, index - 1); ploc->presult = &plist->results[count - 1]; *ploc->presult = 1; return 0; } } return 1; }
/* The current color space is the alternate space for the separation space. */ static int zsetseparationspace(i_ctx_t *i_ctx_p) { os_ptr op = osp; const ref *pcsa; gs_color_space *pcs; gs_color_space * pacs; ref_colorspace cspace_old; ref sname, name_none, name_all; gs_function_t *pfn = NULL; separation_type sep_type; int code; const gs_memory_t * mem = imemory; /* Verify that we have an array as our input parameter */ check_read_type(*op, t_array); if (r_size(op) != 4) return_error(e_rangecheck); /* The alternate color space has been selected as the current color space */ pacs = gs_currentcolorspace(igs); if (!pacs->type->can_be_alt_space) return_error(e_rangecheck); /* * pcsa is a pointer to element 1 (2nd element) in the Separation colorspace * description array. Thus pcsa[2] is element #3 (4th element) which is the * tint transform. */ pcsa = op->value.const_refs + 1; sname = *pcsa; switch (r_type(&sname)) { default: return_error(e_typecheck); case t_string: code = name_from_string(mem, &sname, &sname); if (code < 0) return code; /* falls through */ case t_name: break; } if ((code = name_ref(mem, (const byte *)"All", 3, &name_all, 0)) < 0) return code; if ((code = name_ref(mem, (const byte *)"None", 4, &name_none, 0)) < 0) return code; sep_type = ( name_eq(&sname, &name_all) ? SEP_ALL : name_eq(&sname, &name_none) ? SEP_NONE : SEP_OTHER); /* Check tint transform procedure. */ /* See comment above about psca */ check_proc(pcsa[2]); pfn = ref_function(pcsa + 2); if (pfn == NULL) return_error(e_rangecheck); cspace_old = istate->colorspace; /* Now set the current color space as Separation */ code = gs_cspace_new_Separation(&pcs, pacs, imemory); if (code < 0) return code; pcs->params.separation.sep_type = sep_type; pcs->params.separation.sep_name = name_index(mem, &sname); pcs->params.separation.get_colorname_string = gs_get_colorname_string; istate->colorspace.procs.special.separation.layer_name = pcsa[0]; istate->colorspace.procs.special.separation.tint_transform = pcsa[2]; if (code >= 0) code = gs_cspace_set_sepr_function(pcs, pfn); if (code >= 0) code = gs_setcolorspace(igs, pcs); /* release reference from construction */ rc_decrement_only(pcs, "zsetseparationspace"); if (code < 0) { istate->colorspace = cspace_old; return code; } pop(1); return 0; }
static int beginPlot(JOB *analysisPtr, CKTcircuit *circuitPtr, char *cktName, char *analName, char *refName, int refType, int numNames, char **dataNames, int dataType, bool windowed, runDesc **runp) { runDesc *run; struct save_info *saves; bool *savesused = NULL; int numsaves; int i, j, depind = 0; char namebuf[BSIZE_SP], parambuf[BSIZE_SP], depbuf[BSIZE_SP]; char *ch, tmpname[BSIZE_SP]; bool saveall = TRUE; bool savealli = FALSE; char *an_name; /*to resume a run saj *All it does is reassign the file pointer and return (requires *runp to be NULL if this is not needed) */ if (dataType == 666 && numNames == 666) { run = *runp; run->writeOut = ft_getOutReq(&run->fp, &run->runPlot, &run->binary, run->type, run->name); } else { /*end saj*/ /* Check to see if we want to print informational data. */ if (cp_getvar("printinfo", CP_BOOL, NULL)) fprintf(cp_err, "(debug printing enabled)\n"); /* Check to see if we want to save only interpolated data. */ if (cp_getvar("interp", CP_BOOL, NULL)) { interpolated = TRUE; fprintf(cp_out, "Warning: Interpolated raw file data!\n\n"); } *runp = run = TMALLOC(struct runDesc, 1); /* First fill in some general information. */ run->analysis = analysisPtr; run->circuit = circuitPtr; run->name = copy(cktName); run->type = copy(analName); run->windowed = windowed; run->numData = 0; an_name = spice_analysis_get_name(analysisPtr->JOBtype); ft_curckt->ci_last_an = an_name; /* Now let's see which of these things we need. First toss in the * reference vector. Then toss in anything that getSaves() tells * us to save that we can find in the name list. Finally unpack * the remaining saves into parameters. */ numsaves = ft_getSaves(&saves); if (numsaves) { savesused = TMALLOC(bool, numsaves); saveall = FALSE; for (i = 0; i < numsaves; i++) { if (saves[i].analysis && !cieq(saves[i].analysis, an_name)) { /* ignore this one this time around */ savesused[i] = TRUE; continue; } /* Check for ".save all" and new synonym ".save allv" */ if (cieq(saves[i].name, "all") || cieq(saves[i].name, "allv")) { saveall = TRUE; savesused[i] = TRUE; saves[i].used = 1; continue; } /* And now for the new ".save alli" option */ if (cieq(saves[i].name, "alli")) { savealli = TRUE; savesused[i] = TRUE; saves[i].used = 1; continue; } } } /* Pass 0. */ if (refName) { addDataDesc(run, refName, refType, -1); for (i = 0; i < numsaves; i++) if (!savesused[i] && name_eq(saves[i].name, refName)) { savesused[i] = TRUE; saves[i].used = 1; } } else { run->refIndex = -1; } /* Pass 1. */ if (numsaves && !saveall) { for (i = 0; i < numsaves; i++) if (!savesused[i]) for (j = 0; j < numNames; j++) if (name_eq(saves[i].name, dataNames[j])) { addDataDesc(run, dataNames[j], dataType, j); savesused[i] = TRUE; saves[i].used = 1; break; } } else { for (i = 0; i < numNames; i++) if (!refName || !name_eq(dataNames[i], refName)) /* Save the node as long as it's an internal device node */ if (!strstr(dataNames[i], "#internal") && !strstr(dataNames[i], "#source") && !strstr(dataNames[i], "#drain") && !strstr(dataNames[i], "#collector") && !strstr(dataNames[i], "#emitter") && !strstr(dataNames[i], "#base")) { addDataDesc(run, dataNames[i], dataType, i); } } /* Pass 1 and a bit. This is a new pass which searches for all the internal device nodes, and saves the terminal currents instead */ if (savealli) { depind = 0; for (i = 0; i < numNames; i++) { if (strstr(dataNames[i], "#internal") || strstr(dataNames[i], "#source") || strstr(dataNames[i], "#drain") || strstr(dataNames[i], "#collector") || strstr(dataNames[i], "#emitter") || strstr(dataNames[i], "#base")) { tmpname[0] = '@'; tmpname[1] = '\0'; strncat(tmpname, dataNames[i], BSIZE_SP-1); ch = strchr(tmpname, '#'); if (strstr(ch, "#collector")) { strcpy(ch, "[ic]"); } else if (strstr(ch, "#base")) { strcpy(ch, "[ib]"); } else if (strstr(ch, "#emitter")) { strcpy(ch, "[ie]"); if (parseSpecial(tmpname, namebuf, parambuf, depbuf)) addSpecialDesc(run, tmpname, namebuf, parambuf, depind); strcpy(ch, "[is]"); } else if (strstr(ch, "#drain")) { strcpy(ch, "[id]"); if (parseSpecial(tmpname, namebuf, parambuf, depbuf)) addSpecialDesc(run, tmpname, namebuf, parambuf, depind); strcpy(ch, "[ig]"); } else if (strstr(ch, "#source")) { strcpy(ch, "[is]"); if (parseSpecial(tmpname, namebuf, parambuf, depbuf)) addSpecialDesc(run, tmpname, namebuf, parambuf, depind); strcpy(ch, "[ib]"); } else if (strstr(ch, "#internal") && (tmpname[1] == 'd')) { strcpy(ch, "[id]"); } else { fprintf(cp_err, "Debug: could output current for %s\n", tmpname); continue; } if (parseSpecial(tmpname, namebuf, parambuf, depbuf)) { if (*depbuf) { fprintf(stderr, "Warning : unexpected dependent variable on %s\n", tmpname); } else { addSpecialDesc(run, tmpname, namebuf, parambuf, depind); } } } } } /* Pass 2. */ for (i = 0; i < numsaves; i++) { if (savesused[i]) continue; if (!parseSpecial(saves[i].name, namebuf, parambuf, depbuf)) { if (saves[i].analysis) fprintf(cp_err, "Warning: can't parse '%s': ignored\n", saves[i].name); continue; } /* Now, if there's a dep variable, do we already have it? */ if (*depbuf) { for (j = 0; j < run->numData; j++) if (name_eq(depbuf, run->data[j].name)) break; if (j == run->numData) { /* Better add it. */ for (j = 0; j < numNames; j++) if (name_eq(depbuf, dataNames[j])) break; if (j == numNames) { fprintf(cp_err, "Warning: can't find '%s': value '%s' ignored\n", depbuf, saves[i].name); continue; } addDataDesc(run, dataNames[j], dataType, j); savesused[i] = TRUE; saves[i].used = 1; depind = j; } else { depind = run->data[j].outIndex; } } addSpecialDesc(run, saves[i].name, namebuf, parambuf, depind); } if (numsaves) { for (i = 0; i < numsaves; i++) { tfree(saves[i].analysis); tfree(saves[i].name); } tfree(saves); tfree(savesused); } if (numNames && ((run->numData == 1 && run->refIndex != -1) || (run->numData == 0 && run->refIndex == -1))) { fprintf(cp_err, "Error: no data saved for %s; analysis not run\n", spice_analysis_get_description(analysisPtr->JOBtype)); return E_NOTFOUND; } /* Now that we have our own data structures built up, let's see what * nutmeg wants us to do. */ run->writeOut = ft_getOutReq(&run->fp, &run->runPlot, &run->binary, run->type, run->name); if (run->writeOut) { fileInit(run); } else { plotInit(run); if (refName) run->runPlot->pl_ndims = 1; } } /* define storage for old and new data, to allow interpolation */ if (interpolated && run->circuit->CKTcurJob->JOBtype == 4) { valueold = TMALLOC(double, run->numData); for (i = 0; i < run->numData; i++) valueold[i] = 0.0; valuenew = TMALLOC(double, run->numData); }
/* <any> <any> .... /spec_op name .special_op <any> <any> ..... * The special_op operator takes at a minimum the name of the spec_op to execute * and as many additional parameters as are required for the spec_op. It may * return as many additional parameters as required. */ int zspec_op(i_ctx_t *i_ctx_p) { os_ptr op = osp; gx_device *dev = gs_currentdevice(igs); int i, nprocs = sizeof(spec_op_defs) / sizeof(spec_op_t), code, proc = -1; ref opname, nref, namestr; char *data; /* At the very minimum we need a name object telling us which sepc_op to perform */ check_op(1); if (!r_has_type(op, t_name)) return_error(gs_error_typecheck); ref_assign(&opname, op); /* Find the relevant spec_op name */ for (i=0;i<nprocs;i++) { code = names_ref(imemory->gs_lib_ctx->gs_name_table, (const byte *)spec_op_defs[i].name, strlen(spec_op_defs[i].name), &nref, 0); if (code < 0) return code; if (name_eq(&opname, &nref)) { proc = i; break; } } if (proc < 0) return_error(gs_error_undefined); pop(1); /* We don't need the name of the spec_op any more */ op = osp; switch(proc) { case 0: { stack_param_list list; dev_param_req_t request; ref rkeys; /* Get a single device parameter, we should be supplied with * the name of the paramter, as a name object. */ check_op(1); if (!r_has_type(op, t_name)) return_error(gs_error_typecheck); ref_assign(&opname, op); name_string_ref(imemory, &opname, &namestr); data = (char *)gs_alloc_bytes(imemory, r_size(&namestr) + 1, "temporary special_op string"); if (data == 0) return_error(gs_error_VMerror); memset(data, 0x00, r_size(&namestr) + 1); memcpy(data, namestr.value.bytes, r_size(&namestr)); /* Discard the parameter name now, we're done with it */ pop (1); /* Make a null object so that the stack param list won't check for requests */ make_null(&rkeys); stack_param_list_write(&list, &o_stack, &rkeys, iimemory); /* Stuff the data into a structure for passing to the spec_op */ request.Param = data; request.list = &list; code = dev_proc(dev, dev_spec_op)(dev, gxdso_get_dev_param, &request, sizeof(dev_param_req_t)); gs_free_object(imemory, data, "temporary special_op string"); if (code < 0) { if (code == gs_error_undefined) { op = osp; push(1); make_bool(op, 0); } else return_error(code); } else { op = osp; push(1); make_bool(op, 1); } } break; default: /* Belt and braces; it shold not be possible to get here, as the table * containing the names should mirror the entries in this switch. If we * found a name there should be a matching case here. */ return_error(gs_error_undefined); break; } return 0; }
bool ParserRecord::hasItem( const std::string& name ) const { return std::any_of( this->m_items.begin(), this->m_items.end(), name_eq( name ) ); }