// castExpr ::= 'int' '(' expr ')'
// | 'string' '(' expr ')'
// | 'bool' '(' expr ')'
std::unique_ptr<Expr> FlowParser::castExpr()
{
FNTRACE();
FlowLocation sloc(location());
FlowToken targetTypeToken = token();
nextToken();
if (!consume(FlowToken::RndOpen))
return nullptr;
std::unique_ptr<Expr> e(expr());
if (!consume(FlowToken::RndClose))
return nullptr;
if (!e)
return nullptr;
Opcode targetType = makeOperator(targetTypeToken, e.get());
if (targetType == Opcode::EXIT) {
reportError("Type cast error. No cast implementation found for requested cast from %s to %s.",
tos(e->getType()).c_str(), targetTypeToken.c_str());
return nullptr;
}
if (targetType == Opcode::NOP) {
return e;
}
printf("Type cast from %s to %s: %s\n", tos(e->getType()).c_str(), targetTypeToken.c_str(), mnemonic(targetType));
return std::make_unique<UnaryExpr>(targetType, std::move(e), sloc.update(end()));
}
// rhsExpr ::= (BIN_OP primaryExpr)*
std::unique_ptr<Expr> FlowParser::rhsExpr(std::unique_ptr<Expr> lhs, int lastPrecedence)
{
FNTRACE();
for (;;) {
// quit if this is not a binOp *or* its binOp-precedence is lower than the
// minimal-binOp-requirement of our caller
int thisPrecedence = binopPrecedence(token());
if (thisPrecedence <= lastPrecedence)
return lhs;
FlowToken binaryOperator = token();
nextToken();
std::unique_ptr<Expr> rhs = powExpr();
if (!rhs)
return nullptr;
int nextPrecedence = binopPrecedence(token());
if (thisPrecedence < nextPrecedence) {
rhs = rhsExpr(std::move(rhs), thisPrecedence + 0);
if (!rhs)
return nullptr;
}
Opcode opc = makeOperator(binaryOperator, lhs.get(), rhs.get());
if (opc == Opcode::EXIT) {
reportError("Type error in binary expression (%s versus %s).",
tos(lhs->getType()).c_str(), tos(rhs->getType()).c_str());
return nullptr;
}
lhs = std::make_unique<BinaryExpr>(opc, std::move(lhs), std::move(rhs));
}
}
std::unique_ptr<Expr> FlowParser::powExpr()
{
// powExpr ::= primaryExpr ('**' powExpr)*
FNTRACE();
FlowLocation sloc(location());
std::unique_ptr<Expr> left = primaryExpr();
if (!left)
return nullptr;
while (token() == FlowToken::Pow) {
nextToken();
std::unique_ptr<Expr> right = powExpr();
if (!right)
return nullptr;
auto opc = makeOperator(FlowToken::Pow, left.get(), right.get());
if (opc == Opcode::EXIT) {
reportError("Type error in binary expression (%s versus %s).",
tos(left->getType()).c_str(), tos(right->getType()).c_str());
return nullptr;
}
left = std::make_unique<BinaryExpr>(opc, std::move(left), std::move(right));
}
return left;
}
string kb(ull x)
{
if ( x < 1000ull ) return tos(x);
x /= 1000; if ( x < 1000ull ) return tos(x) + 'k';
x /= 1000; if ( x < 1000ull ) return tos(x) + 'M';
x /= 1000; if ( x < 1000ull ) return tos(x) + 'G';
x /= 1000; return tos(x) + 'T';
}
int main(void)
{
int f,res,b[300],ji;
char a[300][20],c[20];
while(scanf("%s",&a[0])!=EOF)
{
strcpy(c,a[0]);
res=pan(a[0]);
ji=1;
for(ji=1;0==res;ji++)
{
b[ji]=tod(a[ji-1]);
fan(a[ji-1]);
b[ji]=b[ji]+tod(a[ji-1]);
tos(b[ji],a[ji]);
res=pan(a[ji]);
}
printf("%d\n",ji-1);
printf("%s",c);
for(f=1;f<ji;f++)
{
printf("--->");
printf("%s",a[f]);
}
printf("\n");
}
return 0;
}
void MCExecPoint::insert(const MCString &istring, uint4 s, uint4 e)
{
if (format == VF_NUMBER)
tos();
uint4 oldlength = svalue.getlength();
uint4 ilength = istring.getlength();
uint4 newlength = oldlength - (e - s) + ilength;
const char *sptr = svalue.getstring();
const char *isptr = istring.getstring();
char *oldbuffer = NULL;
if (newlength > size || sptr >= buffer && sptr < buffer + newlength
|| isptr >= buffer && isptr < buffer + newlength)
{
oldbuffer = buffer;
size = newlength + EP_PAD & EP_MASK;
buffer = new char[size];
memcpy(buffer, sptr, s);
memcpy(&buffer[s], isptr, ilength);
memcpy(&buffer[s + ilength], &sptr[e], oldlength - e);
}
else
{
memmove(buffer, sptr, s);
memmove(&buffer[s], isptr, ilength);
memmove(&buffer[s + ilength], &sptr[e], oldlength - e);
}
delete oldbuffer;
svalue.set(buffer, newlength);
format = VF_STRING;
}
void Class::dump()
{
printf("-----------------------------------------------\n");
printf("Version: %d.%d\n", major_, minor_);
printf("This class: %s\n", thisClassName_.c_str());
printf("Super class: %s\n", superClassName_.c_str());
printf("Flags: %s\n", tos(flags_).c_str());
printf("Interface count: %zu\n", interfaces_.size());
printf("CONSTANT_POOL:\n");
for (int k = 1; k < constantPool.size(); ++k) {
printf("\t[%d] %s\n", k, constantPool[k] ? constantPool[k]->to_s().c_str() : "null");
}
printf("FIELDS: #%zu\n", fields_.size());
for (int k = 0; k < fields_.size(); ++k) {
Field* field = fields_[k];
printf("\t[%d] ", k);
field->dump();
}
printf("METHODS: #%zu\n", methods_.size());
for (int k = 0; k < methods_.size(); ++k) {
Method* method = methods_[k];
printf("\t[%d] ", k);
method->dump();
}
}
void sysProcess::WriteOutputStream(const wxString &out)
{
// With wxEOL_DOS (=wxEOL_NATIVE in Windows) WriteString() will turn each '\n'
// into "\r\n", thus making "\r\n" a wrong "\r\r\n".
// With wxEOL_UNIX it passes EOL characters as-is, which is preferable.
wxTextOutputStream tos(*GetOutputStream(), wxEOL_UNIX);
tos.WriteString(out);
}
void Field::dump() const
{
printf("%s %s.%s: %s\n",
tos(flags_).c_str(),
thisClass_->name().c_str(),
name_->c_str(),
descriptor_->c_str()
);
}
void Method::dump() const
{
printf("%s %s: %s (code size: %zu)\n",
tos(flags_).c_str(),
name_.c_str(),
signature_.c_str(),
code_.size()
);
}
// MW-2007-07-03: [[ Bug 5123 ]] - Strict array checking modification
Exec_stat MCExecPoint::setlinedel(uint2 l, uint2 p)
{
if (tos() != ES_NORMAL || svalue.getlength() != 1)
{
MCeerror->add(EE_VARIABLE_NAC, l, p, svalue);
return ES_ERROR;
}
linedel = svalue.getstring()[0];
return ES_NORMAL;
}
bool CContactPage::DoExport(const wxString& strPath)
{
wxFileOutputStream file(strPath);
if (!file.IsOk()) return false;
wxTextOutputStream tos(file, wxEOL_DOS, wxCSConv(wxFONTENCODING_UTF8));
const TContactList& rEntries = m_listCtrl->getEntries();
size_t itemCount = rEntries.size();
wxProgressDialog progress(_("CSV Export"), _("Exporting..."),
itemCount, this, wxPD_APP_MODAL);
int numTel = 0;
for (size_t i = 0; i < itemCount; ++i) {
if (rEntries[i].getConstPhones().size() > numTel) {
numTel = rEntries[i].getConstPhones().size();
}
}
wxString strLine;
strLine += wxT("\"FN\",\"MN\",\"LN\",\"NN\",\"Title\",\"SN\",\"Email\",\"Organization\",\"Image\"");
for (size_t i = 0; i < numTel; ++i) {
strLine += ",";
strLine += wxString::Format(wxT("\"TelNumber%02d\""), i);
}
strLine += "\n"; tos.WriteString(strLine);
for (size_t i = 0; i < itemCount; ++i) {
strLine.Clear();
strLine += CSVQuote( rEntries[i].getFN() );
strLine += ",";
strLine += CSVQuote( rEntries[i].getMN() );
strLine += ",";
strLine += CSVQuote( rEntries[i].getLN() );
strLine += ",";
strLine += CSVQuote( rEntries[i].getNN() );
strLine += ",";
strLine += CSVQuote( rEntries[i].getTitle() );
strLine += ",";
strLine += CSVQuote( rEntries[i].getSN() );
strLine += ",";
strLine += CSVQuote( rEntries[i].getEmail() );
strLine += ",";
strLine += CSVQuote( rEntries[i].getOrganization() );
strLine += ",";
strLine += CSVQuote( rEntries[i].getImage() );
for (size_t j = 0; j < numTel; ++j) {
strLine += ",";
if (j < rEntries[i].getConstPhones().size()) {
strLine += CSVQuote( rEntries[i].getConstPhones()[j].getNumber() );
}
}
strLine += "\n"; tos.WriteString(strLine);
progress.Update(i);
}
return true;
}
static void
print_err(void)
{
struct value *value = tos();
if (value != NULL) {
print_value(stderr, value, "", bmachine.obase);
(void)putc('\n', stderr);
}
else
warnx("stack empty");
}
static __inline void
print_tos(void)
{
struct value *value = tos();
if (value != NULL) {
print_value(stdout, value, "", bmachine.obase);
(void)putchar('\n');
}
else
warnx("stack empty");
}
void MCExecPoint::grabsvalue()
{
if (format == VF_NUMBER)
tos();
if (svalue.getstring() != buffer)
{
uint4 l = svalue.getlength();
memmove(getbuffer(l), svalue.getstring(), l);
svalue.set(buffer, l);
}
}
Constant* IRGenerator::getConstant(Expr* expr)
{
if (auto e = dynamic_cast<StringExpr*>(expr))
return get(e->value());
else if (auto e = dynamic_cast<RegExpExpr*>(expr))
return get(e->value());
else {
reportError("FIXME: Invalid (unsupported) literal type <%s> in match case.",
tos(expr->getType()).c_str());
return nullptr;
}
}
Exec_stat MCExecPoint::getboolean(Boolean &d, uint2 l, uint2 p, Exec_errors e)
{
if (format == VF_UNDEFINED || format == VF_NUMBER
|| !MCU_stob(svalue, d))
{
if (format == VF_UNDEFINED)
clear();
if (format == VF_NUMBER)
tos();
MCeerror->add(e, l, p, svalue);
return ES_ERROR;
}
return ES_NORMAL;
}
std::unique_ptr<Stmt> FlowParser::postscriptStmt(std::unique_ptr<Stmt> baseStmt)
{
FNTRACE();
if (token() == FlowToken::Semicolon) {
nextToken();
return baseStmt;
}
if (baseStmt->location().end.line != lexer_->line())
return baseStmt;
FlowToken op = token();
switch (op) {
case FlowToken::If:
case FlowToken::Unless:
break;
default:
return baseStmt;
}
// STMT ['if' EXPR] ';'
// STMT ['unless' EXPR] ';'
FlowLocation sloc = location();
nextToken(); // 'if' | 'unless'
std::unique_ptr<Expr> condExpr = expr();
if (!condExpr)
return nullptr;
consumeIf(FlowToken::Semicolon);
if (op == FlowToken::Unless) {
auto opc = makeOperator(FlowToken::Not, condExpr.get());
if (opc == Opcode::EXIT) {
reportError("Type cast error. No cast implementation found for requested cast from %s to %s.",
tos(condExpr->getType()).c_str(), "bool");
return nullptr;
}
condExpr = std::make_unique<UnaryExpr>(opc, std::move(condExpr), sloc);
}
return std::make_unique<CondStmt>(std::move(condExpr), std::move(baseStmt), nullptr, sloc.update(end()));
}
void IRGenerator::accept(MatchStmt& stmt)
{
FNTRACE();
// TODO
BasicBlock* contBlock = createBlock("match.cont");
MatchInstr* matchInstr = new MatchInstr(stmt.op());
Value* cond = codegen(stmt.condition());
matchInstr->setCondition(cond);
for (const MatchCase& one: stmt.cases()) {
Value* label;
if (auto e = dynamic_cast<StringExpr*>(one.first.get()))
label = get(e->value());
else if (auto e = dynamic_cast<RegExpExpr*>(one.first.get()))
label = get(e->value());
else {
reportError("FIXME: Invalid (unsupported) literal type <%s> in match case.",
tos(one.first->getType()).c_str());
result_ = nullptr;
return;
}
BasicBlock* bb = createBlock("match.case");
setInsertPoint(bb);
codegen(one.second.get());
createBr(contBlock);
matchInstr->addCase(label, bb);
}
if (stmt.elseStmt()) {
BasicBlock* elseBlock = createBlock("match.else");
setInsertPoint(elseBlock);
codegen(stmt.elseStmt());
createBr(contBlock);
matchInstr->setElseBlock(elseBlock);
}
setInsertPoint(contBlock);
}
void MCExecPoint::binarytotext()
{
if (format == VF_NUMBER)
tos();
#ifdef __CRLF__
uint4 pad = 0;
const char *sptr = svalue.getstring();
uint4 i;
for (i = 0 ; i < svalue.getlength() ; i++)
if (*sptr++ == '\n')
pad++;
if (pad != 0)
{
uint4 newsize = svalue.getlength() + pad;
char *newbuffer = new char[newsize];
sptr = svalue.getstring() + svalue.getlength();
char *dptr = newbuffer + newsize;
while (dptr > newbuffer)
{
*--dptr = *--sptr;
if (*sptr == '\n')
*--dptr = '\r';
}
delete buffer;
buffer = newbuffer;
size = newsize;
svalue.set(buffer, newsize);
format = VF_STRING;
}
#elif defined __CR__
grabsvalue();
char *sptr = buffer;
uint4 i;
for (i = 0 ; i < svalue.getlength() ; i++)
{
if (*sptr == '\n')
*sptr = '\r';
sptr++;
}
format = VF_STRING;
#endif
}
void CallGraph::LogFn(wxString s)
{
return; // (log disabled)
FileLogger::Get()->AddLogLine(wxString("> ") + s, FileLogger::Dbg);
// on-demand log file creation
if (nil == m_LogFile) {
wxFileName cfn(wxGetenv("HOME"), "callgraph.log");
wxASSERT(cfn.IsOk());
m_LogFile = new wxFileOutputStream(cfn.GetFullPath());
}
wxTextOutputStream tos(*m_LogFile);
tos << s << "\n";
// cerr ends up in ~/xsesssion-errors ???
// cout goes nowhere?
// std::cout << s << "\n";
::wxPrintf("%s\n", s);
}
int main() {
string s;
int N;
while(cin >> N >> s) {
if(N > (int)s.size())
die(); // Not possible. Doesn't make sense.
map<ULL,int> m;
ULL curr = 0;
ULL mask = 0;
FORI(N) {
curr = (curr << 5) + (s[i]-'a');
mask = (mask << 5) + 31; // Fill with 1's.
}
m.insert(make_pair(curr, 1));
ULL best = curr;
int bestCnt = 1;
//cerr << "Init: " << tos(N, curr) << ": " << curr << endl;
for(int i = N; i < (int)s.size(); ++i) {
curr = mask & ((curr << 5) + (s[i]-'a'));
//cerr << " " << i << ": " << tos(N, curr) << ": " << curr << endl;
map<ULL,int>::iterator it = m.find(curr);
if(it == m.end()) {
m.insert(make_pair(curr, 1));
}
else {
++it->second;
if(it->second > bestCnt) {
bestCnt = it->second;
best = curr;
}
}
}
cout << tos(N, best) << endl;
}
return 0;
}
int main(int ac, char * av[])
try
{
try
{
try
{
cout << "Usage: same [SizeKb]\n";
ull sz = SZMAX;
if ( ac > 1 ) sz = std::atoi(av[1]) * 1000ull;
mymain(sz);
}
catch (...)
{
cout << "Current dir: [" << os::FileSys::cwd().str() << "]\n";
throw;
}
}
catch (int e) { throw "[" + tos(e) + "]"; }
catch (const char * e) { throw string(e); }
}
catch (string e)
{
cout << "Error: " << e << "\n";
return 1;
}
catch (std::exception & e)
{
cout << "Error (C++ exception) : " << e.what() << '\n';
return 2;
}
catch (...)
{
cout << "Error: unknown exception\n";
return 1;
}
int Gui::drawPage(
LGraphicsView *view,
QGraphicsScene *scene,
Steps *steps,
int stepNum,
QString const &addLine,
Where ¤t,
QStringList &csiParts,
QStringList &pliParts,
bool isMirrored,
QHash<QString, QStringList> &bfx,
bool printing,
bool bfxStore2,
QStringList &bfxParts,
bool calledOut)
{
bool global = true;
QString line;
Callout *callout = NULL;
Range *range = NULL;
Step *step = NULL;
bool pliIgnore = false;
bool partIgnore = false;
bool synthBegin = false;
bool multiStep = false;
bool partsAdded = false;
bool coverPage = false;
bool bfxStore1 = false;
bool bfxLoad = false;
int numLines = ldrawFile.size(current.modelName);
bool firstStep = true;
steps->isMirrored = isMirrored;
QList<InsertMeta> inserts;
Where topOfStep = current;
Rc gprc = OkRc;
Rc rc;
statusBar()->showMessage("Processing " + current.modelName);
page.coverPage = false;
QStringList calloutParts;
/*
* do until end of page
*/
for ( ; current <= numLines; current++) {
Meta &curMeta = callout ? callout->meta : steps->meta;
QStringList tokens;
// If we hit end of file we've got to note end of step
if (current >= numLines) {
line.clear();
gprc = EndOfFileRc;
tokens << "0";
// not end of file, so get the next LDraw line
} else {
line = ldrawFile.readLine(current.modelName,current.lineNumber);
split(line,tokens);
}
if (tokens.size() == 15 && tokens[0] == "1") {
QString color = tokens[1];
QString type = tokens[tokens.size()-1];
csiParts << line;
partsAdded = true;
/* since we have a part usage, we have a valid step */
if (step == NULL) {
if (range == NULL) {
range = newRange(steps,calledOut);
steps->append(range);
}
step = new Step(topOfStep,
range,
stepNum,
curMeta,
calledOut,
multiStep);
range->append(step);
}
/* addition of ldraw parts */
if (curMeta.LPub.pli.show.value()
&& ! pliIgnore
&& ! partIgnore
&& ! synthBegin) {
QString colorType = color+type;
if (! isSubmodel(type) || curMeta.LPub.pli.includeSubs.value()) {
if (bfxStore2 && bfxLoad) {
bool removed = false;
for (int i = 0; i < bfxParts.size(); i++) {
if (bfxParts[i] == colorType) {
bfxParts.removeAt(i);
removed = true;
break;
}
}
if ( ! removed) {
pliParts << Pli::partLine(line,current,steps->meta);
}
} else {
pliParts << Pli::partLine(line,current,steps->meta);
}
}
if (bfxStore1) {
bfxParts << colorType;
}
}
/* if it is a sub-model, then process it */
if (ldrawFile.contains(type) && callout) {
/* we are a callout, so gather all the steps within the callout */
/* start with new meta, but no rotation step */
if (callout->bottom.modelName != type) {
Where current2(type,0);
skipHeader(current2);
callout->meta.rotStep.clear();
SubmodelStack tos(current.modelName,current.lineNumber,stepNum);
callout->meta.submodelStack << tos;
Meta saveMeta = callout->meta;
callout->meta.LPub.pli.constrain.resetToDefault();
step->append(callout);
calloutParts.clear();
QStringList csiParts2;
QHash<QString, QStringList> calloutBfx;
int rc;
rc = drawPage(
view,
scene,
callout,
1,
line,
current2,
csiParts2,
calloutParts,
ldrawFile.mirrored(tokens),
calloutBfx,
printing,
bfxStore2,
bfxParts,
true);
callout->meta = saveMeta;
if (callout->meta.LPub.pli.show.value() &&
! callout->meta.LPub.callout.pli.perStep.value() &&
! pliIgnore && ! partIgnore && ! synthBegin) {
pliParts += calloutParts;
}
if (rc != 0) {
steps->placement = steps->meta.LPub.assem.placement;
return rc;
}
} else {
callout->instances++;
pliParts += calloutParts;
}
/* remind user what file we're working on */
statusBar()->showMessage("Processing " + current.modelName);
}
} else if (tokens.size() > 0 &&
(tokens[0] == "2" ||
tokens[0] == "3" ||
tokens[0] == "4" ||
tokens[0] == "5")) {
csiParts << line;
partsAdded = true;
/* we've got a line, triangle or polygon, so add it to the list */
/* and make sure we know we have a step */
if (step == NULL) {
if (range == NULL) {
range = newRange(steps,calledOut);
steps->append(range);
}
step = new Step(topOfStep,
range,
stepNum,
steps->meta,
calledOut,
multiStep);
range->append(step);
}
} else if (tokens.size() > 0 && tokens[0] == "0" || gprc == EndOfFileRc) {
/* must be meta-command (or comment) */
if (global && tokens.contains("!LPUB") && tokens.contains("GLOBAL")) {
topOfStep = current;
} else {
global = false;
}
QString part;
if (gprc == EndOfFileRc) {
rc = gprc;
} else {
rc = curMeta.parse(line,current,true);
}
/* handle specific meta-commands */
switch (rc) {
/* toss it all out the window, per James' original plan */
case ClearRc:
pliParts.clear();
csiParts.clear();
steps->freeSteps();
break;
/* Buffer exchange */
case BufferStoreRc:
bfx[curMeta.bfx.value()] = csiParts;
bfxStore1 = true;
bfxParts.clear();
break;
case BufferLoadRc:
csiParts = bfx[curMeta.bfx.value()];
bfxLoad = true;
break;
case MLCadGroupRc:
csiParts << line;
break;
case IncludeRc:
include(curMeta);
break;
/* substitute part/parts with this */
case PliBeginSub1Rc:
if (pliIgnore) {
parseError("Nested PLI BEGIN/ENDS not allowed\n",current);
}
if (steps->meta.LPub.pli.show.value() &&
! pliIgnore &&
! partIgnore &&
! synthBegin) {
SubData subData = curMeta.LPub.pli.begin.sub.value();
QString addPart = QString("1 0 0 0 0 0 0 0 0 0 0 0 0 0 %1") .arg(subData.part);
pliParts << Pli::partLine(addPart,current,curMeta);
}
if (step == NULL) {
if (range == NULL) {
range = newRange(steps,calledOut);
steps->append(range);
}
step = new Step(topOfStep,
range,
stepNum,
curMeta,
calledOut,
multiStep);
range->append(step);
}
pliIgnore = true;
break;
/* substitute part/parts with this */
case PliBeginSub2Rc:
if (pliIgnore) {
parseError("Nested BEGIN/ENDS not allowed\n",current);
}
if (steps->meta.LPub.pli.show.value() &&
! pliIgnore &&
! partIgnore &&
! synthBegin) {
SubData subData = curMeta.LPub.pli.begin.sub.value();
QString addPart = QString("1 %1 0 0 0 0 0 0 0 0 0 0 0 0 %2") .arg(subData.color) .arg(subData.part);
pliParts << Pli::partLine(addPart,current,curMeta);
}
if (step == NULL) {
if (range == NULL) {
range = newRange(steps,calledOut);
steps->append(range);
}
step = new Step(topOfStep,
range,
stepNum,
curMeta,
calledOut,
multiStep);
range->append(step);
}
pliIgnore = true;
break;
/* do not put subsequent parts into PLI */
case PliBeginIgnRc:
if (pliIgnore) {
parseError("Nested BEGIN/ENDS not allowed\n",current);
}
pliIgnore = true;
break;
case PliEndRc:
if ( ! pliIgnore) {
parseError("PLI END with no PLI BEGIN",current);
}
pliIgnore = false;
break;
/* discard subsequent parts, and don't create CSI's for them */
case PartBeginIgnRc:
case MLCadSkipBeginRc:
if (partIgnore) {
parseError("Nested BEGIN/ENDS not allowed\n",current);
}
partIgnore = true;
break;
case PartEndRc:
case MLCadSkipEndRc:
if (partIgnore) {
parseError("Ignore ending with no ignore begin",current);
}
partIgnore = false;
break;
case SynthBeginRc:
if (synthBegin) {
parseError("Nested BEGIN/ENDS not allowed\n",current);
}
synthBegin = true;
break;
case SynthEndRc:
if ( ! synthBegin) {
parseError("Ignore ending with no ignore begin",current);
}
synthBegin = false;
break;
/* remove a group or all instances of a part type */
case GroupRemoveRc:
case RemoveGroupRc:
case RemovePartRc:
case RemoveNameRc:
{
QStringList newCSIParts;
if (rc == RemoveGroupRc) {
remove_group(csiParts,steps->meta.LPub.remove.group.value(),newCSIParts);
} else if (rc == RemovePartRc) {
remove_parttype(csiParts, steps->meta.LPub.remove.parttype.value(),newCSIParts);
} else {
remove_partname(csiParts, steps->meta.LPub.remove.partname.value(),newCSIParts);
}
csiParts = newCSIParts;
if (step == NULL) {
if (range == NULL) {
range = newRange(steps,calledOut);
steps->append(range);
}
step = new Step(topOfStep,
range,
stepNum,
curMeta,
calledOut,
multiStep);
range->append(step);
}
}
break;
case ReserveSpaceRc:
/* since we have a part usage, we have a valid step */
if (calledOut || multiStep) {
step = NULL;
Reserve *reserve = new Reserve(current,steps->meta.LPub);
if (range == NULL) {
range = newRange(steps,calledOut);
steps->append(range);
}
range->append(reserve);
}
break;
case InsertCoverPageRc:
coverPage = true;
page.coverPage = true;
case InsertPageRc:
partsAdded = true;
break;
case InsertRc:
inserts.append(curMeta.LPub.insert); // these are always placed before any parts in step
break;
case CalloutBeginRc:
if (callout) {
parseError("Nested CALLOUT not allowed within the same file",current);
} else {
callout = new Callout(curMeta,view);
callout->setTopOfCallout(current);
}
break;
case CalloutDividerRc:
if (range) {
range->sepMeta = curMeta.LPub.callout.sep;
range = NULL;
step = NULL;
}
break;
case CalloutPointerRc:
if (callout) {
callout->appendPointer(current,curMeta.LPub.callout);
}
break;
case CalloutEndRc:
if ( ! callout) {
parseError("CALLOUT END without a CALLOUT BEGIN",current);
} else {
callout->parentStep = step;
callout->parentRelativeType = step->relativeType;
callout->pli.clear();
callout->placement = curMeta.LPub.callout.placement;
callout->setBottomOfCallout(current);
callout = NULL;
}
break;
case StepGroupBeginRc:
if (calledOut) {
parseError("MULTI_STEP not allowed inside callout models",current);
} else {
if (multiStep) {
parseError("Nested MULTI_STEP not allowed",current);
}
multiStep = true;
}
steps->relativeType = StepGroupType;
break;
case StepGroupDividerRc:
if (range) {
range->sepMeta = steps->meta.LPub.multiStep.sep;
range = NULL;
step = NULL;
}
break;
/* finished off a multiStep */
case StepGroupEndRc:
if (multiStep) {
// save the current meta as the meta for step group
// PLI for non-pli-per-step
if (partsAdded) {
parseError("Expected STEP before MULTI_STEP END", current);
}
multiStep = false;
if (pliParts.size() && steps->meta.LPub.multiStep.pli.perStep.value() == false) {
steps->pli.bom = false;
steps->pli.setParts(pliParts,steps->stepGroupMeta);
steps->pli.sizePli(&steps->stepGroupMeta, StepGroupType, false);
}
pliParts.clear();
/* this is a page we're supposed to process */
steps->placement = steps->meta.LPub.multiStep.placement;
showLine(steps->topOfSteps());
bool endOfSubmodel = stepNum == ldrawFile.numSteps(current.modelName);
int instances = ldrawFile.instances(current.modelName,isMirrored);
addGraphicsPageItems(steps, coverPage, endOfSubmodel,instances, view, scene,printing);
return HitEndOfPage;
}
break;
/* we're hit some kind of step, or implied step and end of file */
case EndOfFileRc:
case RotStepRc:
case StepRc:
if ( ! partsAdded && bfxLoad) { // special case of no parts added, but BFX load
if (step == NULL) {
if (range == NULL) {
range = newRange(steps,calledOut);
steps->append(range);
}
step = new Step(topOfStep,
range,
stepNum,
curMeta,
calledOut,
multiStep);
range->append(step);
}
int rc = step->createCsi(
isMirrored ? addLine : "1 color 0 0 0 1 0 0 0 1 0 0 0 1 foo.ldr",
csiParts,
&step->csiPixmap,
steps->meta);
partsAdded = true; // OK, so this is a lie, but it works
}
if (partsAdded) {
if (firstStep) {
steps->stepGroupMeta = curMeta;
firstStep = false;
}
if (pliIgnore) {
parseError("PLI BEGIN then STEP. Expected PLI END",current);
pliIgnore = false;
}
if (partIgnore) {
parseError("PART BEGIN then STEP. Expected PART END",current);
partIgnore = false;
}
if (synthBegin) {
parseError("SYNTH BEGIN then STEP. Expected SYNTH_END",current);
synthBegin = false;
}
bool pliPerStep;
if (multiStep && steps->meta.LPub.multiStep.pli.perStep.value()) {
pliPerStep = true;
} else if (calledOut && steps->meta.LPub.callout.pli.perStep.value()) {
pliPerStep = true;
} else if ( ! multiStep && ! calledOut) {
pliPerStep = true;
} else {
pliPerStep = false;
}
if (step) {
Page *page = dynamic_cast<Page *>(steps);
if (page) {
page->inserts = inserts;
}
if (pliPerStep) {
PlacementType relativeType;
if (multiStep) {
relativeType = StepGroupType;
} else if (calledOut) {
relativeType = CalloutType;
} else {
relativeType = SingleStepType;
}
step->pli.setParts(pliParts,steps->meta);
pliParts.clear();
step->pli.sizePli(&steps->meta,relativeType,pliPerStep);
}
int rc = step->createCsi(
isMirrored ? addLine : "1 color 0 0 0 1 0 0 0 1 0 0 0 1 foo.ldr",
csiParts,
&step->csiPixmap,
steps->meta);
statusBar()->showMessage("Processing " + current.modelName);
if (rc) {
return rc;
}
} else {
if (pliPerStep) {
pliParts.clear();
}
/*
* Only pages or step can have inserts.... no callouts
*/
if ( ! multiStep && ! calledOut) {
Page *page = dynamic_cast<Page *>(steps);
if (page) {
page->inserts = inserts;
}
}
}
if ( ! multiStep && ! calledOut) {
/*
* Simple step
*/
if (steps->list.size() == 0) {
steps->relativeType = PageType;
}
steps->placement = steps->meta.LPub.assem.placement;
showLine(topOfStep);
int numSteps = ldrawFile.numSteps(current.modelName);
bool endOfSubmodel = numSteps == 0 || stepNum == numSteps;
int instances = ldrawFile.instances(current.modelName,isMirrored);
addGraphicsPageItems(steps,coverPage,endOfSubmodel,instances,view,scene,printing);
stepPageNum += ! coverPage;
steps->setBottomOfSteps(current);
return HitEndOfPage;
}
steps->meta.pop();
stepNum += partsAdded;
topOfStep = current;
partsAdded = false;
coverPage = false;
step = NULL;
bfxStore2 = bfxStore1;
bfxStore1 = false;
bfxLoad = false;
}
inserts.clear();
steps->setBottomOfSteps(current);
break;
case RangeErrorRc:
showLine(current);
QMessageBox::critical(NULL,
QMessageBox::tr("LPub"),
QMessageBox::tr("Parameter(s) out of range: %1:%2\n%3")
.arg(current.modelName)
.arg(current.lineNumber)
.arg(line));
return RangeErrorRc;
break;
default:
break;
}
} else if (line != "") {
showLine(current);
QMessageBox::critical(NULL,
QMessageBox::tr("LPub"),
QMessageBox::tr("Invalid LDraw Line Type: %1:%2\n %3")
.arg(current.modelName)
.arg(current.lineNumber)
.arg(line));
return InvalidLDrawLineRc;
}
}
steps->meta.rotStep.clear();
return 0;
}
O toso(O o){S s=tos(o);O r=newosz(s);DL(s);R r;} //wrap tostring in object
int Gui::findPage(
LGraphicsView *view,
QGraphicsScene *scene,
int &pageNum,
QString const &addLine,
Where ¤t,
bool isMirrored,
Meta meta,
bool printing)
{
bool stepGroup = false;
bool partIgnore = false;
bool coverPage = false;
bool stepPage = false;
bool bfxStore1 = false;
bool bfxStore2 = false;
QStringList bfxParts;
int partsAdded = 0;
int stepNumber = 1;
Rc rc;
skipHeader(current);
if (pageNum == 1) {
topOfPages.clear();
topOfPages.append(current);
}
QStringList csiParts;
QStringList saveCsiParts;
Where saveCurrent = current;
Where stepGroupCurrent;
int saveStepNumber = 1;
saveStepPageNum = stepPageNum;
Meta saveMeta = meta;
QHash<QString, QStringList> bfx;
QHash<QString, QStringList> saveBfx;
int numLines = ldrawFile.size(current.modelName);
Where topOfStep = current;
ldrawFile.setRendered(current.modelName, isMirrored);
for ( ;
current.lineNumber < numLines;
current.lineNumber++) {
// scan through the rest of the model counting pages
// if we've already hit the display page, then do as little as possible
QString line = ldrawFile.readLine(current.modelName,current.lineNumber).trimmed();
if (line.startsWith("0 GHOST ")) {
line = line.mid(8).trimmed();
}
switch (line.toAscii()[0]) {
case '1':
if ( ! partIgnore) {
csiParts << line;
if (firstStepPageNum == -1) {
firstStepPageNum = pageNum;
}
lastStepPageNum = pageNum;
QStringList token;
split(line,token);
QString type = token[token.size()-1];
isMirrored = ldrawFile.mirrored(token);
bool contains = ldrawFile.contains(type);
bool rendered = ldrawFile.rendered(type,isMirrored);
if (contains) {
if ( ! rendered && ! bfxStore2) {
// can't be a callout
SubmodelStack tos(current.modelName,current.lineNumber,stepNumber);
meta.submodelStack << tos;
Where current2(type,0);
findPage(view,scene,pageNum,line,current2,isMirrored,meta,printing);
saveStepPageNum = stepPageNum;
meta.submodelStack.pop_back();
}
}
if (bfxStore1) {
bfxParts << token[1]+type;
}
}
case '2':
case '3':
case '4':
case '5':
++partsAdded;
csiParts << line;
break;
case '0':
rc = meta.parse(line,current);
switch (rc) {
case StepGroupBeginRc:
stepGroup = true;
stepGroupCurrent = topOfStep;
break;
case StepGroupEndRc:
if (stepGroup) {
stepGroup = false;
if (pageNum < displayPageNum) {
saveCsiParts = csiParts;
saveStepNumber = stepNumber;
saveMeta = meta;
saveBfx = bfx;
} else if (pageNum == displayPageNum) {
csiParts.clear();
stepPageNum = saveStepPageNum;
if (pageNum == 1) {
page.meta = meta;
} else {
page.meta = saveMeta;
}
page.meta.pop();
QStringList pliParts;
(void) drawPage(view,
scene,
&page,
saveStepNumber,
addLine,
stepGroupCurrent,
saveCsiParts,
pliParts,
isMirrored,
saveBfx,
printing,
bfxStore2,
bfxParts);
saveCurrent.modelName.clear();
saveCsiParts.clear();
}
++pageNum;
topOfPages.append(current);
saveStepPageNum = ++stepPageNum;
}
break;
case StepRc:
case RotStepRc:
if (partsAdded) {
stepNumber += ! coverPage && ! stepPage;
stepPageNum += ! coverPage && ! stepGroup;
if (pageNum < displayPageNum) {
if ( ! stepGroup) {
saveCsiParts = csiParts;
saveStepNumber = stepNumber;
saveMeta = meta;
saveBfx = bfx;
saveStepPageNum = stepPageNum;
}
saveCurrent = current;
}
if ( ! stepGroup) {
if (pageNum == displayPageNum) {
csiParts.clear();
stepPageNum = saveStepPageNum;
if (pageNum == 1) {
page.meta = meta;
} else {
page.meta = saveMeta;
}
page.meta.pop();
QStringList pliParts;
(void) drawPage(view,
scene,
&page,
saveStepNumber,
addLine,
saveCurrent,
saveCsiParts,
pliParts,
isMirrored,
saveBfx,
printing,
bfxStore2,
bfxParts);
saveCurrent.modelName.clear();
saveCsiParts.clear();
}
++pageNum;
topOfPages.append(current);
}
topOfStep = current;
partsAdded = 0;
meta.pop();
coverPage = false;
stepPage = false;
bfxStore2 = bfxStore1;
bfxStore1 = false;
if ( ! bfxStore2) {
bfxParts.clear();
}
} else if ( ! stepGroup) {
saveCurrent = current; // so that draw page doesn't have to
// deal with steps that are not steps
}
break;
case CalloutBeginRc:
++current;
{
Meta tmpMeta;
while (rc != CalloutEndRc && current.lineNumber < numLines) {
line = ldrawFile.readLine(current.modelName,current.lineNumber++).trimmed();
rc = OkRc;
if (line[0] == '0') {
rc = tmpMeta.parse(line,current);
} else if (line[0] >= '1' && line[0] <= '5') {
if (line[0] == '1') {
partsAdded++;
csiParts << line;
}
}
}
}
--current;
break;
case InsertCoverPageRc:
coverPage = true;
partsAdded = true;
break;
case InsertPageRc:
stepPage = true;
partsAdded = true;
break;
case PartBeginIgnRc:
partIgnore = true;
break;
case PartEndRc:
partIgnore = false;
break;
// Any of the metas that can change csiParts needs
// to be processed here
case ClearRc:
csiParts.empty();
break;
/* Buffer exchange */
case BufferStoreRc:
if (pageNum < displayPageNum) {
bfx[meta.bfx.value()] = csiParts;
}
bfxStore1 = true;
bfxParts.clear();
break;
case BufferLoadRc:
if (pageNum < displayPageNum) {
csiParts = bfx[meta.bfx.value()];
}
partsAdded = true;
break;
case MLCadGroupRc:
if (pageNum < displayPageNum) {
csiParts << line;
partsAdded++;
}
break;
/* remove a group or all instances of a part type */
case GroupRemoveRc:
case RemoveGroupRc:
case RemovePartRc:
case RemoveNameRc:
if (pageNum < displayPageNum) {
QStringList newCSIParts;
if (rc == RemoveGroupRc) {
remove_group(csiParts, meta.LPub.remove.group.value(),newCSIParts);
} else if (rc == RemovePartRc) {
remove_parttype(csiParts, meta.LPub.remove.parttype.value(),newCSIParts);
} else {
remove_partname(csiParts, meta.LPub.remove.partname.value(),newCSIParts);
}
csiParts = newCSIParts;
newCSIParts.empty();
}
break;
case IncludeRc:
include(meta);
break;
default:
break;
} // switch
break;
}
} // for every line
csiParts.clear();
if (partsAdded) {
if (pageNum == displayPageNum) {
page.meta = saveMeta;
QStringList pliParts;
(void) drawPage(view,
scene,
&page,
saveStepNumber,
addLine,
saveCurrent,
saveCsiParts,
pliParts,
isMirrored,
bfx,
printing,
bfxStore2,
bfxParts);
}
++pageNum;
topOfPages.append(current);
++stepPageNum;
}
return 0;
}
void MCExecPoint::concat(const MCString &two, Exec_concat ec, Boolean first)
{
if (format == VF_NUMBER)
tos();
uint4 oldlength = svalue.getlength();
uint4 newlength = oldlength + two.getlength();
if (!first && ec != EC_NONE)
newlength++;
if (newlength > size)
{
// MW-2012-01-25: [[ Bug 9956 ]] Small optimization to improve large
// concatenations. Using 'realloc' means that no copying of data is
// needed in the best cases.
size = newlength + EP_PAD & EP_MASK;
if (svalue.getstring() != buffer)
{
char *newbuffer = new char[size];
memcpy(newbuffer, svalue.getstring(), oldlength);
delete buffer;
buffer = newbuffer;
}
else
{
char *newbuffer = (char *)realloc(buffer, size);
if (newbuffer == nil)
return;
buffer = newbuffer;
}
svalue.setstring(buffer);
}
else
if (svalue.getstring() != buffer)
{
memmove(buffer, svalue.getstring(), oldlength);
svalue.setstring(buffer);
}
if (!first)
switch (ec)
{
case EC_NONE:
break;
case EC_SPACE:
buffer[oldlength++] = ' ';
break;
case EC_COMMA:
buffer[oldlength++] = ',';
break;
case EC_NULL:
buffer[oldlength++] = '\0';
break;
case EC_RETURN:
buffer[oldlength++] = '\n';
break;
// MW-2009-06-17: Can now concatenate with tab into an EP.
case EC_TAB:
buffer[oldlength++] = '\t';
break;
}
if (two.getlength() == 1)
buffer[oldlength] = two.getstring()[0];
else
memcpy(&buffer[oldlength], two.getstring(), two.getlength());
svalue.setlength(newlength);
format = VF_STRING;
}
int32_t action_hold(int32_t v, struct action *a, int offset) {
if(beatno()==a->u32) { return 0; }
else if(tos()==a) { pop_stack(); }
return v;
}
V po(FP f,O o){S s=tos(o);fputs(s,f);DL(s);} //print object
S tos(O o){
S r,t;L z,i;switch(o->t){
case TD:r=alc(BZ)/*hope this is big enough!*/;sprintf(r,"%f",o->d);z=strlen(r)-1;while(r[z]=='0')r[z--]=0;if(r[z]=='.')r[z]=0;BK;
case TS:r=alc(o->s.z+1);memcpy(r,o->s.s,o->s.z);r[o->s.z]=0;BK;
case TA:r=alc(1);r[0]='[';z=1;for(i=0;i<len(o->a);++i){L l;if(i){r=rlc(r,z+1);r[z++]=',';}t=tos(o->a->st[i]);l=strlen(t);r=rlc(r,z+l);memcpy(r+z,t,l);z+=l;DL(t);}r=rlc(r,z+2);r[z]=']';r[z+1]=0;BK;
case TCB:r=alc(o->s.z+3);r[0]='{';memcpy(r+1,o->s.s,o->s.z);memcpy(r+1+o->s.z,"}",2);BK;
}R r;
} //tostring (copies)
