void GapStringBuffer::insert(const char *chars, size_t l) { size_t gapPosInBuf = gapPos % bufferSize; if (l >= gapLen) { // we must ensure that gapLen is never 0, otherwise, we might end up with a NULL gapBuf pointer when moving the cursor to the end of the string // add first buf gc<Buffer *> buf = gcnew(Buffer); buf->prev = gapBuf; buf->next = gapBuf->next; memBarrier(); gapBuf->next = buf; if (buf->next) buf->next->prev = buf; // copy chars if they were in the same buffer as the start of the gap size_t nextCharPos = gapPosInBuf + gapLen; if (nextCharPos < bufferSize) memcpy(buf->chars + nextCharPos, gapBuf->chars + nextCharPos, bufferSize - nextCharPos); // increase gapLen to reflect gap increasing gapLen += bufferSize; length += bufferSize; // now add additional buffers without copying, if required while (l >= gapLen) { buf = gcnew(Buffer); buf->prev = gapBuf; buf->next = gapBuf->next; memBarrier(); gapBuf->next = buf; buf->next->prev = buf; gapLen += bufferSize; length += bufferSize; } } // now we have enough room, copy the characters while (l) { size_t w = bufferSize - gapPosInBuf; if (l >= w) { memcpy(gapBuf->chars + gapPosInBuf, chars, w); gapPosInBuf = 0; gapPos += w; gapLen -= w; gapBuf = gapBuf->next; l -= w; chars += w; } else { memcpy(gapBuf->chars + gapPosInBuf, chars, l); gapPosInBuf += l; gapPos += l; gapLen -= l; l = 0; } } }
Frame::Access * X86Frame::allocLocal(bool escape) { Frame::Access *access = NULL; if (escape) { frameOffset += WORD_SIZE; DBG("frameOffset %d", frameOffset); access = gcnew(InFrame, (-frameOffset)); } else { Temp *t = gcnew(Temp, ()); access = gcnew(InReg, (t)); } return access; }
tree::Stm * X86Frame::procEntryExit1(tree::Stm *body) { if (!tree::isExistType(body, tree::Tree::CALL_T)) { //this is leaf function //TODO: } Label *fname = gcnew(Label, (name->name)); tree::LABEL *l = _LABEL(fname); tree::SEQMaker sm; sm.add(l); /* int i = 0; int offset = 4; std::vector<Access*>::iterator it = formals.begin(); while (it != formals.end()) { tree::CONST *offs = _CONST(offset); tree::TEMP *base = _TEMP(fp()); tree::MEM *m = _MEM(_(base) + _(offs)); tree::Exp *tmp = (*it)->exp(_TEMP(fp())); sm.add(_MOVE(tmp, m)); offset += WORD_SIZE; ++it; ++i; } */ sm.add(body); return sm.make(); }
GapStringBuffer::GapStringBuffer(const String &string) { size_t l = string.getLength(); const char *chars = string.getChars(); length = 0; first = NULL; gc<Buffer *> buf; Buffer *lastBuf = NULL; for (;;) { buf = gcnew(Buffer); buf->prev = lastBuf; buf->next = NULL; memBarrier(); if (lastBuf) lastBuf->next = buf; if (!first) first = buf; lastBuf = buf; if (l < bufferSize) { memcpy(buf->chars, chars, l); gapBuf = buf; gapPos = length + l; gapLen = bufferSize - l; length += bufferSize; break; } else { memcpy(buf->chars, chars, bufferSize); l -= bufferSize; length += bufferSize; } } }
gc<const CObject *> CReal::parseString(String::AbstractIterator &stri) { double value = stringToDouble(stri); if (isnan(value)) gcthrownew(EInvalidObjectValue(Message(InvalidRealValue))); return gcnew(CReal(value)); }
tree::Exp * X86Frame::externalCall(const std::string &func, const tree::ExpList &args) { Label *flabel = gcnew(Label, (func)); tree::NAME *name = _NAME(flabel); tree::CALL *call = _CALL(name, args); return call; }
extern Term *mkstr(char *str) { Term *term; Ref(char *, string, str); term = gcnew(Term); term->str = string; term->closure = NULL; RefEnd(string); return term; }
static Var *mkvar(List *defn) { Ref(Var *, var, NULL); Ref(List *, lp, defn); var = gcnew(Var); var->env = NULL; var->defn = lp; var->flags = hasbindings(lp) ? var_hasbindings : 0; RefEnd(lp); RefReturn(var); }
GapStringBuffer::GapStringBuffer() { first = gcnew(Buffer); first->next = NULL; first->prev = NULL; length = bufferSize; gapBuf = first; gapPos = 0; gapLen = bufferSize; }
static void *VarCopy(void *op) { void *np = gcnew(Var); memcpy(np, op, sizeof (Var)); return np; }
static void *TermCopy(void *op) { void *np = gcnew(Term); memcpy(np, op, sizeof (Term)); return np; }
gc<Kernel::SysThreadGroup *> createThreadGroup(ThreadGroup *userThreadGroup) { return gcnew(SysThreadGroup(userThreadGroup)); }
gc<Kernel::SysThread *> createThread(Thread *userThread, size_t stackSize, int priority, bool privileged) { if (stackSize == 0 || (privileged && !Kernel::getCurrentThread()->isPrivileged())) throw gcnew(EOperationNotPermitted); return gcnew(SysThread(userThread, stackSize, priority, privileged)); }
static void *ListCopy(void *op) { void *np = gcnew(List); memcpy(np, op, sizeof (List)); return np; }
gc<WaitableEvent *> createEvent(bool autoReset, bool wakeupAll, bool set) { return gcnew(WaitableEvent(autoReset, wakeupAll, set)); }
gc<const CObject *> CReal::deserializeData(IO::InputStream *stream) { double value; stream->read(&value, sizeof(value)); return gcnew(CReal(value)); }
Frame * Frame::newFrame(Symbol *name, const std::vector<int> &formals) { return gcnew(X86Frame, (name, formals)); }
X86Frame::X86Frame(Symbol *n, const std::vector<int> &f) : frameOffset(0) , maxArgSize(0) { Frame::name = n; std::string end = format("end_of_%s", name->name.c_str()); Frame::endFuncLabel = gcnew(Label, (end)); frameCount++; eax = gcnew(Temp, ("%eax")); ecx = gcnew(Temp, ("%ecx")); edx = gcnew(Temp, ("%edx")); ebx = gcnew(Temp, ("%ebx")); esi = gcnew(Temp, ("%esi")); edi = gcnew(Temp, ("%edi")); ebp = gcnew(Temp, ("%ebp")); esp = gcnew(Temp, ("%esp")); eip = gcnew(Temp, ("%eip")); regs.all.push_back(eax); regs.all.push_back(ecx); regs.all.push_back(edx); regs.all.push_back(ebx); regs.all.push_back(esi); regs.all.push_back(edi); regs.all.push_back(ebp); regs.all.push_back(esp); regs.all.push_back(eip); std::vector<int>::const_iterator it; it = f.begin(); int argOffset = 8;//0 ... ebp, 4 ... return addr while (it != f.end()) { Access *acc = gcnew(InFrame, (argOffset)); formals.push_back(acc); argOffset += WORD_SIZE; ++it; } generator = new X86CodeGen(this); regs.callerSaves.push_back(eax); regs.callerSaves.push_back(ecx); regs.callerSaves.push_back(edx); regs.calleeSaves.push_back(ebx); regs.calleeSaves.push_back(esi); regs.calleeSaves.push_back(edi); regs.specials.push_back(ebp); regs.specials.push_back(esp); regs.specials.push_back(eip); }